[skill-creator] Add forward-testing instructions

This adds a first-class server request for MCP server elicitations:
`mcpServer/elicitation/request`.

Until now, MCP elicitation requests only showed up as a raw
`codex/event/elicitation_request` event from core. That made it hard for
v2 clients to handle elicitations using the same request/response flow
as other server-driven interactions (like shell and `apply_patch`
tools).

This also updates the underlying MCP elicitation request handling in
core to pass through the full MCP request (including URL and form data)
so we can expose it properly in app-server.

### Why not `item/mcpToolCall/elicitationRequest`?
This is because MCP elicitations are related to MCP servers first, and
only optionally to a specific MCP tool call.

In the MCP protocol, elicitation is a server-to-client capability: the
server sends `elicitation/create`, and the client replies with an
elicitation result. RMCP models it that way as well.

In practice an elicitation is often triggered by an MCP tool call, but
not always.

### What changed
- add `mcpServer/elicitation/request` to the v2 app-server API
- translate core `codex/event/elicitation_request` events into the new
v2 server request
- map client responses back into `Op::ResolveElicitation` so the MCP
server can continue
- update app-server docs and generated protocol schema
- add an end-to-end app-server test that covers the full round trip
through a real RMCP elicitation flow
- The new test exercises a realistic case where an MCP tool call
triggers an elicitation, the app-server emits
mcpServer/elicitation/request, the client accepts it, and the tool call
resumes and completes successfully.

### app-server API flow
- Client starts a thread with `thread/start`.
- Client starts a turn with `turn/start`.
- App-server sends `item/started` for the `mcpToolCall`.
- While that tool call is in progress, app-server sends
`mcpServer/elicitation/request`.
- Client responds to that request with `{ action: "accept" | "decline" |
"cancel" }`.
- App-server sends `serverRequest/resolved`.
- App-server sends `item/completed` for the mcpToolCall.
- App-server sends `turn/completed`.
- If the turn is interrupted while the elicitation is pending,
app-server still sends `serverRequest/resolved` before the turn
finishes.

.github/workflows/ci.yml

@@ -47,7 +47,7 @@ jobs:
           echo "pack_output=$PACK_OUTPUT" >> "$GITHUB_OUTPUT"
 
       - name: Upload staged npm package artifact
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: codex-npm-staging
           path: ${{ steps.stage_npm_package.outputs.pack_output }}

.github/workflows/rust-ci.yml

@@ -392,7 +392,7 @@ jobs:
 
       - name: Upload Cargo timings (clippy)
         if: always()
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: cargo-timings-rust-ci-clippy-${{ matrix.target }}-${{ matrix.profile }}
           path: codex-rs/target/**/cargo-timings/cargo-timing.html
@@ -605,7 +605,7 @@ jobs:
 
       - name: Upload Cargo timings (nextest)
         if: always()
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: cargo-timings-rust-ci-nextest-${{ matrix.target }}-${{ matrix.profile }}
           path: codex-rs/target/**/cargo-timings/cargo-timing.html

.github/workflows/rust-release-windows.yml

@@ -92,7 +92,7 @@ jobs:
           cargo build --target ${{ matrix.target }} --release --timings ${{ matrix.build_args }}
 
       - name: Upload Cargo timings
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: cargo-timings-rust-release-windows-${{ matrix.target }}-${{ matrix.bundle }}
           path: codex-rs/target/**/cargo-timings/cargo-timing.html
@@ -112,7 +112,7 @@ jobs:
           fi
 
       - name: Upload Windows binaries
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: windows-binaries-${{ matrix.target }}-${{ matrix.bundle }}
           path: |
@@ -150,13 +150,13 @@ jobs:
       - uses: actions/checkout@v6
 
       - name: Download prebuilt Windows primary binaries
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v8
         with:
           name: windows-binaries-${{ matrix.target }}-primary
           path: codex-rs/target/${{ matrix.target }}/release
 
       - name: Download prebuilt Windows helper binaries
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v8
         with:
           name: windows-binaries-${{ matrix.target }}-helpers
           path: codex-rs/target/${{ matrix.target }}/release
@@ -257,7 +257,7 @@ jobs:
             "${GITHUB_WORKSPACE}/.github/workflows/zstd" -T0 -19 "$dest/$base"
           done
 
-      - uses: actions/upload-artifact@v6
+      - uses: actions/upload-artifact@v7
         with:
           name: ${{ matrix.target }}
           path: |

.github/workflows/rust-release.yml

@@ -57,7 +57,9 @@ jobs:
       run:
         working-directory: codex-rs
     env:
-      CARGO_PROFILE_RELEASE_LTO: ${{ contains(github.ref_name, '-alpha') && 'thin' || 'fat' }}
+      # 2026-03-04: temporarily change releases to use thin LTO because
+      # Ubuntu ARM is timing out at 60 minutes.
+      CARGO_PROFILE_RELEASE_LTO: ${{ contains(github.ref_name, '-alpha') && 'thin' || 'thin' }}
 
     strategy:
       fail-fast: false
@@ -211,10 +213,11 @@ jobs:
       - name: Cargo build
         shell: bash
         run: |
+          echo "CARGO_PROFILE_RELEASE_LTO: ${CARGO_PROFILE_RELEASE_LTO}"
           cargo build --target ${{ matrix.target }} --release --timings --bin codex --bin codex-responses-api-proxy
 
       - name: Upload Cargo timings
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: cargo-timings-rust-release-${{ matrix.target }}
           path: codex-rs/target/**/cargo-timings/cargo-timing.html
@@ -353,7 +356,7 @@ jobs:
             zstd -T0 -19 --rm "$dest/$base"
           done
 
-      - uses: actions/upload-artifact@v6
+      - uses: actions/upload-artifact@v7
         with:
           name: ${{ matrix.target }}
           # Upload the per-binary .zst files as well as the new .tar.gz
@@ -417,7 +420,7 @@ jobs:
 
           echo "path=${notes_path}" >> "${GITHUB_OUTPUT}"
 
-      - uses: actions/download-artifact@v7
+      - uses: actions/download-artifact@v8
         with:
           path: dist
 

.github/workflows/shell-tool-mcp.yml

@@ -158,7 +158,7 @@ jobs:
           mkdir -p "$dest"
           cp bash "$dest/bash"
 
-      - uses: actions/upload-artifact@v6
+      - uses: actions/upload-artifact@v7
         with:
           name: shell-tool-mcp-bash-${{ matrix.target }}-${{ matrix.variant }}
           path: artifacts/**
@@ -199,7 +199,7 @@ jobs:
           mkdir -p "$dest"
           cp bash "$dest/bash"
 
-      - uses: actions/upload-artifact@v6
+      - uses: actions/upload-artifact@v7
         with:
           name: shell-tool-mcp-bash-${{ matrix.target }}-${{ matrix.variant }}
           path: artifacts/**
@@ -325,7 +325,7 @@ jobs:
           grep -Fx "smoke-zsh" "$tmpdir/stdout.txt"
           grep -Fx "/bin/echo" "$tmpdir/wrapper.log"
 
-      - uses: actions/upload-artifact@v6
+      - uses: actions/upload-artifact@v7
         with:
           name: shell-tool-mcp-zsh-${{ matrix.target }}-${{ matrix.variant }}
           path: artifacts/**
@@ -403,7 +403,7 @@ jobs:
           grep -Fx "smoke-zsh" "$tmpdir/stdout.txt"
           grep -Fx "/bin/echo" "$tmpdir/wrapper.log"
 
-      - uses: actions/upload-artifact@v6
+      - uses: actions/upload-artifact@v7
         with:
           name: shell-tool-mcp-zsh-${{ matrix.target }}-${{ matrix.variant }}
           path: artifacts/**
@@ -441,7 +441,7 @@ jobs:
         run: pnpm --filter @openai/codex-shell-tool-mcp run build
 
       - name: Download build artifacts
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v8
         with:
           path: artifacts
 
@@ -500,7 +500,7 @@ jobs:
           filename=$(PACK_INFO="$pack_info" node -e 'const data = JSON.parse(process.env.PACK_INFO); console.log(data[0].filename);')
           mv "dist/npm/${filename}" "dist/npm/codex-shell-tool-mcp-npm-${PACKAGE_VERSION}.tgz"
 
-      - uses: actions/upload-artifact@v6
+      - uses: actions/upload-artifact@v7
         with:
           name: codex-shell-tool-mcp-npm
           path: dist/npm/codex-shell-tool-mcp-npm-${{ env.PACKAGE_VERSION }}.tgz
@@ -529,7 +529,7 @@ jobs:
         run: npm install -g npm@latest
 
       - name: Download npm tarball
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v8
         with:
           name: codex-shell-tool-mcp-npm
           path: dist/npm

codex-rs/Cargo.toml

@@ -33,8 +33,6 @@ members = [
     "mcp-server",
     "network-proxy",
     "ollama",
-    "artifact-presentation",
-    "artifact-spreadsheet",
     "process-hardening",
     "protocol",
     "rmcp-client",
@@ -66,6 +64,8 @@ members = [
     "state",
     "codex-experimental-api-macros",
     "test-macros",
+    "package-manager",
+    "artifacts",
 ]
 resolver = "2"
 
@@ -83,6 +83,8 @@ license = "Apache-2.0"
 app_test_support = { path = "app-server/tests/common" }
 codex-ansi-escape = { path = "ansi-escape" }
 codex-api = { path = "codex-api" }
+codex-artifacts = { path = "artifacts" }
+codex-package-manager = { path = "package-manager" }
 codex-app-server = { path = "app-server" }
 codex-app-server-protocol = { path = "app-server-protocol" }
 codex-app-server-test-client = { path = "app-server-test-client" }
@@ -111,8 +113,6 @@ codex-mcp-server = { path = "mcp-server" }
 codex-network-proxy = { path = "network-proxy" }
 codex-ollama = { path = "ollama" }
 codex-otel = { path = "otel" }
-codex-artifact-presentation = { path = "artifact-presentation" }
-codex-artifact-spreadsheet = { path = "artifact-spreadsheet" }
 codex-process-hardening = { path = "process-hardening" }
 codex-protocol = { path = "protocol" }
 codex-responses-api-proxy = { path = "responses-api-proxy" }
@@ -178,9 +178,11 @@ dirs = "6"
 dotenvy = "0.15.7"
 dunce = "1.0.4"
 encoding_rs = "0.8.35"
+fd-lock = "4.0.4"
 env-flags = "0.1.1"
 env_logger = "0.11.9"
 eventsource-stream = "0.2.3"
+flate2 = "1.1.4"
 futures = { version = "0.3", default-features = false }
 gethostname = "1.1.0"
 globset = "0.4"
@@ -219,7 +221,6 @@ owo-colors = "4.3.0"
 path-absolutize = "3.1.1"
 pathdiff = "0.2"
 portable-pty = "0.9.0"
-ppt-rs = "0.2.6"
 predicates = "3"
 pretty_assertions = "1.4.1"
 pulldown-cmark = "0.10"
@@ -242,7 +243,7 @@ sentry = "0.46.0"
 serde = "1"
 serde_json = "1"
 serde_path_to_error = "0.1.20"
-serde_with = "3.16"
+serde_with = "3.17"
 serde_yaml = "0.9"
 serial_test = "3.2.0"
 sha1 = "0.10.6"
@@ -262,11 +263,12 @@ sqlx = { version = "0.8.6", default-features = false, features = [
 ] }
 starlark = "0.13.0"
 strum = "0.27.2"
-strum_macros = "0.27.2"
+strum_macros = "0.28.0"
 supports-color = "3.0.2"
 syntect = "5"
 sys-locale = "0.3.2"
 tempfile = "3.23.0"
+tar = "0.4.44"
 test-log = "0.2.19"
 textwrap = "0.16.2"
 thiserror = "2.0.17"
@@ -353,8 +355,7 @@ ignored = [
     "icu_provider",
     "openssl-sys",
     "codex-utils-readiness",
-    "codex-secrets",
-    "codex-artifact-spreadsheet"
+    "codex-secrets"
 ]
 
 [profile.release]

codex-rs/README.md

@@ -88,6 +88,7 @@ codex --sandbox danger-full-access
 ```
 
 The same setting can be persisted in `~/.codex/config.toml` via the top-level `sandbox_mode = "MODE"` key, e.g. `sandbox_mode = "workspace-write"`.
+In `workspace-write`, Codex also includes `~/.codex/memories` in its writable roots so memory maintenance does not require an extra approval.
 
 ## Code Organization
 

codex-rs/app-server-protocol/Cargo.toml

@@ -24,6 +24,12 @@ serde_with = { workspace = true }
 shlex = { workspace = true }
 strum_macros = { workspace = true }
 thiserror = { workspace = true }
+rmcp = { workspace = true, default-features = false, features = [
+    "base64",
+    "macros",
+    "schemars",
+    "server",
+] }
 ts-rs = { workspace = true }
 inventory = { workspace = true }
 tracing = { workspace = true }

codex-rs/app-server-protocol/schema/json/ClientRequest.json

@@ -951,6 +951,27 @@
       ],
       "type": "string"
     },
+    "PluginInstallParams": {
+      "properties": {
+        "cwd": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "marketplaceName": {
+          "type": "string"
+        },
+        "pluginName": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "marketplaceName",
+        "pluginName"
+      ],
+      "type": "object"
+    },
     "ProductSurface": {
       "enum": [
         "chatgpt",
@@ -1416,6 +1437,40 @@
           "title": "WebSearchCallResponseItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revised_prompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "image_generation_call"
+              ],
+              "title": "ImageGenerationCallResponseItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationCallResponseItem",
+          "type": "object"
+        },
         {
           "properties": {
             "ghost_commit": {
@@ -1728,7 +1783,8 @@
     },
     "ServiceTier": {
       "enum": [
-        "fast"
+        "fast",
+        "flex"
       ],
       "type": "string"
     },
@@ -2829,6 +2885,12 @@
     },
     "WindowsSandboxSetupStartParams": {
       "properties": {
+        "cwd": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
         "mode": {
           "$ref": "#/definitions/WindowsSandboxSetupMode"
         }
@@ -3298,6 +3360,30 @@
       "title": "Skills/config/writeRequest",
       "type": "object"
     },
+    {
+      "properties": {
+        "id": {
+          "$ref": "#/definitions/RequestId"
+        },
+        "method": {
+          "enum": [
+            "plugin/install"
+          ],
+          "title": "Plugin/installRequestMethod",
+          "type": "string"
+        },
+        "params": {
+          "$ref": "#/definitions/PluginInstallParams"
+        }
+      },
+      "required": [
+        "id",
+        "method",
+        "params"
+      ],
+      "title": "Plugin/installRequest",
+      "type": "object"
+    },
     {
       "properties": {
         "id": {

codex-rs/app-server-protocol/schema/json/EventMsg.json

@@ -544,6 +544,56 @@
         }
       ]
     },
+    "ElicitationRequest": {
+      "oneOf": [
+        {
+          "properties": {
+            "message": {
+              "type": "string"
+            },
+            "mode": {
+              "enum": [
+                "form"
+              ],
+              "type": "string"
+            },
+            "requested_schema": true
+          },
+          "required": [
+            "message",
+            "mode",
+            "requested_schema"
+          ],
+          "type": "object"
+        },
+        {
+          "properties": {
+            "elicitation_id": {
+              "type": "string"
+            },
+            "message": {
+              "type": "string"
+            },
+            "mode": {
+              "enum": [
+                "url"
+              ],
+              "type": "string"
+            },
+            "url": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "elicitation_id",
+            "message",
+            "mode",
+            "url"
+          ],
+          "type": "object"
+        }
+      ]
+    },
     "EventMsg": {
       "description": "Response event from the agent NOTE: Make sure none of these values have optional types, as it will mess up the extension code-gen.",
       "oneOf": [
@@ -1387,6 +1437,60 @@
           "title": "WebSearchEndEventMsg",
           "type": "object"
         },
+        {
+          "properties": {
+            "call_id": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "image_generation_begin"
+              ],
+              "title": "ImageGenerationBeginEventMsgType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "call_id",
+            "type"
+          ],
+          "title": "ImageGenerationBeginEventMsg",
+          "type": "object"
+        },
+        {
+          "properties": {
+            "call_id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revised_prompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "image_generation_end"
+              ],
+              "title": "ImageGenerationEndEventMsgType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "call_id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationEndEventMsg",
+          "type": "object"
+        },
         {
           "description": "Notification that the server is about to execute a command.",
           "properties": {
@@ -1909,8 +2013,8 @@
             "id": {
               "$ref": "#/definitions/RequestId"
             },
-            "message": {
-              "type": "string"
+            "request": {
+              "$ref": "#/definitions/ElicitationRequest"
             },
             "server_name": {
               "type": "string"
@@ -1925,7 +2029,7 @@
           },
           "required": [
             "id",
-            "message",
+            "request",
             "server_name",
             "type"
           ],
@@ -4983,6 +5087,40 @@
           "title": "WebSearchCallResponseItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revised_prompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "image_generation_call"
+              ],
+              "title": "ImageGenerationCallResponseItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationCallResponseItem",
+          "type": "object"
+        },
         {
           "properties": {
             "ghost_commit": {
@@ -5460,7 +5598,8 @@
     },
     "ServiceTier": {
       "enum": [
-        "fast"
+        "fast",
+        "flex"
       ],
       "type": "string"
     },
@@ -5966,6 +6105,40 @@
           "title": "WebSearchTurnItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revised_prompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "ImageGeneration"
+              ],
+              "title": "ImageGenerationTurnItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationTurnItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {
@@ -7057,6 +7230,60 @@
       "title": "WebSearchEndEventMsg",
       "type": "object"
     },
+    {
+      "properties": {
+        "call_id": {
+          "type": "string"
+        },
+        "type": {
+          "enum": [
+            "image_generation_begin"
+          ],
+          "title": "ImageGenerationBeginEventMsgType",
+          "type": "string"
+        }
+      },
+      "required": [
+        "call_id",
+        "type"
+      ],
+      "title": "ImageGenerationBeginEventMsg",
+      "type": "object"
+    },
+    {
+      "properties": {
+        "call_id": {
+          "type": "string"
+        },
+        "result": {
+          "type": "string"
+        },
+        "revised_prompt": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "status": {
+          "type": "string"
+        },
+        "type": {
+          "enum": [
+            "image_generation_end"
+          ],
+          "title": "ImageGenerationEndEventMsgType",
+          "type": "string"
+        }
+      },
+      "required": [
+        "call_id",
+        "result",
+        "status",
+        "type"
+      ],
+      "title": "ImageGenerationEndEventMsg",
+      "type": "object"
+    },
     {
       "description": "Notification that the server is about to execute a command.",
       "properties": {
@@ -7579,8 +7806,8 @@
         "id": {
           "$ref": "#/definitions/RequestId"
         },
-        "message": {
-          "type": "string"
+        "request": {
+          "$ref": "#/definitions/ElicitationRequest"
         },
         "server_name": {
           "type": "string"
@@ -7595,7 +7822,7 @@
       },
       "required": [
         "id",
-        "message",
+        "request",
         "server_name",
         "type"
       ],

codex-rs/app-server-protocol/schema/json/McpServerElicitationRequestParams.json

@@ -0,0 +1,72 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "oneOf": [
+    {
+      "properties": {
+        "message": {
+          "type": "string"
+        },
+        "mode": {
+          "enum": [
+            "form"
+          ],
+          "type": "string"
+        },
+        "requestedSchema": true
+      },
+      "required": [
+        "message",
+        "mode",
+        "requestedSchema"
+      ],
+      "type": "object"
+    },
+    {
+      "properties": {
+        "elicitationId": {
+          "type": "string"
+        },
+        "message": {
+          "type": "string"
+        },
+        "mode": {
+          "enum": [
+            "url"
+          ],
+          "type": "string"
+        },
+        "url": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "elicitationId",
+        "message",
+        "mode",
+        "url"
+      ],
+      "type": "object"
+    }
+  ],
+  "properties": {
+    "serverName": {
+      "type": "string"
+    },
+    "threadId": {
+      "type": "string"
+    },
+    "turnId": {
+      "description": "Active Codex turn when this elicitation was observed, if app-server could correlate one.\n\nThis is nullable because MCP models elicitation as a standalone server-to-client request identified by the MCP server request id. It may be triggered during a turn, but turn context is app-server correlation rather than part of the protocol identity of the elicitation itself.",
+      "type": [
+        "string",
+        "null"
+      ]
+    }
+  },
+  "required": [
+    "serverName",
+    "threadId"
+  ],
+  "title": "McpServerElicitationRequestParams",
+  "type": "object"
+}

codex-rs/app-server-protocol/schema/json/McpServerElicitationRequestResponse.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "McpServerElicitationAction": {
+      "enum": [
+        "accept",
+        "decline",
+        "cancel"
+      ],
+      "type": "string"
+    }
+  },
+  "properties": {
+    "action": {
+      "$ref": "#/definitions/McpServerElicitationAction"
+    },
+    "content": {
+      "description": "Structured user input for accepted elicitations, mirroring RMCP `CreateElicitationResult`.\n\nThis is nullable because decline/cancel responses have no content."
+    }
+  },
+  "required": [
+    "action"
+  ],
+  "title": "McpServerElicitationRequestResponse",
+  "type": "object"
+}

codex-rs/app-server-protocol/schema/json/ServerNotification.json

@@ -2251,6 +2251,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/ServerRequest.json

@@ -652,6 +652,76 @@
         }
       ]
     },
+    "McpServerElicitationRequestParams": {
+      "oneOf": [
+        {
+          "properties": {
+            "message": {
+              "type": "string"
+            },
+            "mode": {
+              "enum": [
+                "form"
+              ],
+              "type": "string"
+            },
+            "requestedSchema": true
+          },
+          "required": [
+            "message",
+            "mode",
+            "requestedSchema"
+          ],
+          "type": "object"
+        },
+        {
+          "properties": {
+            "elicitationId": {
+              "type": "string"
+            },
+            "message": {
+              "type": "string"
+            },
+            "mode": {
+              "enum": [
+                "url"
+              ],
+              "type": "string"
+            },
+            "url": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "elicitationId",
+            "message",
+            "mode",
+            "url"
+          ],
+          "type": "object"
+        }
+      ],
+      "properties": {
+        "serverName": {
+          "type": "string"
+        },
+        "threadId": {
+          "type": "string"
+        },
+        "turnId": {
+          "description": "Active Codex turn when this elicitation was observed, if app-server could correlate one.\n\nThis is nullable because MCP models elicitation as a standalone server-to-client request identified by the MCP server request id. It may be triggered during a turn, but turn context is app-server correlation rather than part of the protocol identity of the elicitation itself.",
+          "type": [
+            "string",
+            "null"
+          ]
+        }
+      },
+      "required": [
+        "serverName",
+        "threadId"
+      ],
+      "type": "object"
+    },
     "NetworkApprovalContext": {
       "properties": {
         "host": {
@@ -981,6 +1051,31 @@
       "title": "Item/tool/requestUserInputRequest",
       "type": "object"
     },
+    {
+      "description": "Request input for an MCP server elicitation.",
+      "properties": {
+        "id": {
+          "$ref": "#/definitions/RequestId"
+        },
+        "method": {
+          "enum": [
+            "mcpServer/elicitation/request"
+          ],
+          "title": "McpServer/elicitation/requestRequestMethod",
+          "type": "string"
+        },
+        "params": {
+          "$ref": "#/definitions/McpServerElicitationRequestParams"
+        }
+      },
+      "required": [
+        "id",
+        "method",
+        "params"
+      ],
+      "title": "McpServer/elicitation/requestRequest",
+      "type": "object"
+    },
     {
       "description": "Execute a dynamic tool call on the client.",
       "properties": {

codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json

@@ -826,6 +826,30 @@
           "title": "Skills/config/writeRequest",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "$ref": "#/definitions/v2/RequestId"
+            },
+            "method": {
+              "enum": [
+                "plugin/install"
+              ],
+              "title": "Plugin/installRequestMethod",
+              "type": "string"
+            },
+            "params": {
+              "$ref": "#/definitions/v2/PluginInstallParams"
+            }
+          },
+          "required": [
+            "id",
+            "method",
+            "params"
+          ],
+          "title": "Plugin/installRequest",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {
@@ -1750,6 +1774,56 @@
       "title": "DynamicToolCallResponse",
       "type": "object"
     },
+    "ElicitationRequest": {
+      "oneOf": [
+        {
+          "properties": {
+            "message": {
+              "type": "string"
+            },
+            "mode": {
+              "enum": [
+                "form"
+              ],
+              "type": "string"
+            },
+            "requested_schema": true
+          },
+          "required": [
+            "message",
+            "mode",
+            "requested_schema"
+          ],
+          "type": "object"
+        },
+        {
+          "properties": {
+            "elicitation_id": {
+              "type": "string"
+            },
+            "message": {
+              "type": "string"
+            },
+            "mode": {
+              "enum": [
+                "url"
+              ],
+              "type": "string"
+            },
+            "url": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "elicitation_id",
+            "message",
+            "mode",
+            "url"
+          ],
+          "type": "object"
+        }
+      ]
+    },
     "EventMsg": {
       "$schema": "http://json-schema.org/draft-07/schema#",
       "description": "Response event from the agent NOTE: Make sure none of these values have optional types, as it will mess up the extension code-gen.",
@@ -2594,6 +2668,60 @@
           "title": "WebSearchEndEventMsg",
           "type": "object"
         },
+        {
+          "properties": {
+            "call_id": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "image_generation_begin"
+              ],
+              "title": "ImageGenerationBeginEventMsgType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "call_id",
+            "type"
+          ],
+          "title": "ImageGenerationBeginEventMsg",
+          "type": "object"
+        },
+        {
+          "properties": {
+            "call_id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revised_prompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "image_generation_end"
+              ],
+              "title": "ImageGenerationEndEventMsgType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "call_id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationEndEventMsg",
+          "type": "object"
+        },
         {
           "description": "Notification that the server is about to execute a command.",
           "properties": {
@@ -3116,8 +3244,8 @@
             "id": {
               "$ref": "#/definitions/v2/RequestId"
             },
-            "message": {
-              "type": "string"
+            "request": {
+              "$ref": "#/definitions/ElicitationRequest"
             },
             "server_name": {
               "type": "string"
@@ -3132,7 +3260,7 @@
           },
           "required": [
             "id",
-            "message",
+            "request",
             "server_name",
             "type"
           ],
@@ -5181,6 +5309,102 @@
       ],
       "type": "object"
     },
+    "McpServerElicitationAction": {
+      "enum": [
+        "accept",
+        "decline",
+        "cancel"
+      ],
+      "type": "string"
+    },
+    "McpServerElicitationRequestParams": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "oneOf": [
+        {
+          "properties": {
+            "message": {
+              "type": "string"
+            },
+            "mode": {
+              "enum": [
+                "form"
+              ],
+              "type": "string"
+            },
+            "requestedSchema": true
+          },
+          "required": [
+            "message",
+            "mode",
+            "requestedSchema"
+          ],
+          "type": "object"
+        },
+        {
+          "properties": {
+            "elicitationId": {
+              "type": "string"
+            },
+            "message": {
+              "type": "string"
+            },
+            "mode": {
+              "enum": [
+                "url"
+              ],
+              "type": "string"
+            },
+            "url": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "elicitationId",
+            "message",
+            "mode",
+            "url"
+          ],
+          "type": "object"
+        }
+      ],
+      "properties": {
+        "serverName": {
+          "type": "string"
+        },
+        "threadId": {
+          "type": "string"
+        },
+        "turnId": {
+          "description": "Active Codex turn when this elicitation was observed, if app-server could correlate one.\n\nThis is nullable because MCP models elicitation as a standalone server-to-client request identified by the MCP server request id. It may be triggered during a turn, but turn context is app-server correlation rather than part of the protocol identity of the elicitation itself.",
+          "type": [
+            "string",
+            "null"
+          ]
+        }
+      },
+      "required": [
+        "serverName",
+        "threadId"
+      ],
+      "title": "McpServerElicitationRequestParams",
+      "type": "object"
+    },
+    "McpServerElicitationRequestResponse": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "properties": {
+        "action": {
+          "$ref": "#/definitions/McpServerElicitationAction"
+        },
+        "content": {
+          "description": "Structured user input for accepted elicitations, mirroring RMCP `CreateElicitationResult`.\n\nThis is nullable because decline/cancel responses have no content."
+        }
+      },
+      "required": [
+        "action"
+      ],
+      "title": "McpServerElicitationRequestResponse",
+      "type": "object"
+    },
     "McpStartupFailure": {
       "properties": {
         "error": {
@@ -6894,6 +7118,31 @@
           "title": "Item/tool/requestUserInputRequest",
           "type": "object"
         },
+        {
+          "description": "Request input for an MCP server elicitation.",
+          "properties": {
+            "id": {
+              "$ref": "#/definitions/v2/RequestId"
+            },
+            "method": {
+              "enum": [
+                "mcpServer/elicitation/request"
+              ],
+              "title": "McpServer/elicitation/requestRequestMethod",
+              "type": "string"
+            },
+            "params": {
+              "$ref": "#/definitions/McpServerElicitationRequestParams"
+            }
+          },
+          "required": [
+            "id",
+            "method",
+            "params"
+          ],
+          "title": "McpServer/elicitation/requestRequest",
+          "type": "object"
+        },
         {
           "description": "Execute a dynamic tool call on the client.",
           "properties": {
@@ -7353,6 +7602,40 @@
           "title": "WebSearchTurnItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revised_prompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "ImageGeneration"
+              ],
+              "title": "ImageGenerationTurnItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationTurnItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {
@@ -10897,6 +11180,34 @@
         ],
         "type": "string"
       },
+      "PluginInstallParams": {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "properties": {
+          "cwd": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "marketplaceName": {
+            "type": "string"
+          },
+          "pluginName": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "marketplaceName",
+          "pluginName"
+        ],
+        "title": "PluginInstallParams",
+        "type": "object"
+      },
+      "PluginInstallResponse": {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "title": "PluginInstallResponse",
+        "type": "object"
+      },
       "ProductSurface": {
         "enum": [
           "chatgpt",
@@ -11761,6 +12072,40 @@
             "title": "WebSearchCallResponseItem",
             "type": "object"
           },
+          {
+            "properties": {
+              "id": {
+                "type": "string"
+              },
+              "result": {
+                "type": "string"
+              },
+              "revised_prompt": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              },
+              "status": {
+                "type": "string"
+              },
+              "type": {
+                "enum": [
+                  "image_generation_call"
+                ],
+                "title": "ImageGenerationCallResponseItemType",
+                "type": "string"
+              }
+            },
+            "required": [
+              "id",
+              "result",
+              "status",
+              "type"
+            ],
+            "title": "ImageGenerationCallResponseItem",
+            "type": "object"
+          },
           {
             "properties": {
               "ghost_commit": {
@@ -12134,7 +12479,8 @@
       },
       "ServiceTier": {
         "enum": [
-          "fast"
+          "fast",
+          "flex"
         ],
         "type": "string"
       },
@@ -13508,6 +13854,40 @@
             "title": "ImageViewThreadItem",
             "type": "object"
           },
+          {
+            "properties": {
+              "id": {
+                "type": "string"
+              },
+              "result": {
+                "type": "string"
+              },
+              "revisedPrompt": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              },
+              "status": {
+                "type": "string"
+              },
+              "type": {
+                "enum": [
+                  "imageGeneration"
+                ],
+                "title": "ImageGenerationThreadItemType",
+                "type": "string"
+              }
+            },
+            "required": [
+              "id",
+              "result",
+              "status",
+              "type"
+            ],
+            "title": "ImageGenerationThreadItem",
+            "type": "object"
+          },
           {
             "properties": {
               "id": {
@@ -15290,6 +15670,12 @@
       "WindowsSandboxSetupStartParams": {
         "$schema": "http://json-schema.org/draft-07/schema#",
         "properties": {
+          "cwd": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
           "mode": {
             "$ref": "#/definitions/v2/WindowsSandboxSetupMode"
           }

codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json

@@ -1300,6 +1300,30 @@
           "title": "Skills/config/writeRequest",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "$ref": "#/definitions/RequestId"
+            },
+            "method": {
+              "enum": [
+                "plugin/install"
+              ],
+              "title": "Plugin/installRequestMethod",
+              "type": "string"
+            },
+            "params": {
+              "$ref": "#/definitions/PluginInstallParams"
+            }
+          },
+          "required": [
+            "id",
+            "method",
+            "params"
+          ],
+          "title": "Plugin/installRequest",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {
@@ -3262,6 +3286,56 @@
       ],
       "type": "object"
     },
+    "ElicitationRequest": {
+      "oneOf": [
+        {
+          "properties": {
+            "message": {
+              "type": "string"
+            },
+            "mode": {
+              "enum": [
+                "form"
+              ],
+              "type": "string"
+            },
+            "requested_schema": true
+          },
+          "required": [
+            "message",
+            "mode",
+            "requested_schema"
+          ],
+          "type": "object"
+        },
+        {
+          "properties": {
+            "elicitation_id": {
+              "type": "string"
+            },
+            "message": {
+              "type": "string"
+            },
+            "mode": {
+              "enum": [
+                "url"
+              ],
+              "type": "string"
+            },
+            "url": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "elicitation_id",
+            "message",
+            "mode",
+            "url"
+          ],
+          "type": "object"
+        }
+      ]
+    },
     "ErrorNotification": {
       "$schema": "http://json-schema.org/draft-07/schema#",
       "properties": {
@@ -4131,6 +4205,60 @@
           "title": "WebSearchEndEventMsg",
           "type": "object"
         },
+        {
+          "properties": {
+            "call_id": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "image_generation_begin"
+              ],
+              "title": "ImageGenerationBeginEventMsgType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "call_id",
+            "type"
+          ],
+          "title": "ImageGenerationBeginEventMsg",
+          "type": "object"
+        },
+        {
+          "properties": {
+            "call_id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revised_prompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "image_generation_end"
+              ],
+              "title": "ImageGenerationEndEventMsgType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "call_id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationEndEventMsg",
+          "type": "object"
+        },
         {
           "description": "Notification that the server is about to execute a command.",
           "properties": {
@@ -4653,8 +4781,8 @@
             "id": {
               "$ref": "#/definitions/RequestId"
             },
-            "message": {
-              "type": "string"
+            "request": {
+              "$ref": "#/definitions/ElicitationRequest"
             },
             "server_name": {
               "type": "string"
@@ -4669,7 +4797,7 @@
           },
           "required": [
             "id",
-            "message",
+            "request",
             "server_name",
             "type"
           ],
@@ -8235,6 +8363,34 @@
       ],
       "type": "string"
     },
+    "PluginInstallParams": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "properties": {
+        "cwd": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "marketplaceName": {
+          "type": "string"
+        },
+        "pluginName": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "marketplaceName",
+        "pluginName"
+      ],
+      "title": "PluginInstallParams",
+      "type": "object"
+    },
+    "PluginInstallResponse": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "PluginInstallResponse",
+      "type": "object"
+    },
     "ProductSurface": {
       "enum": [
         "chatgpt",
@@ -9324,6 +9480,40 @@
           "title": "WebSearchCallResponseItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revised_prompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "image_generation_call"
+              ],
+              "title": "ImageGenerationCallResponseItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationCallResponseItem",
+          "type": "object"
+        },
         {
           "properties": {
             "ghost_commit": {
@@ -10770,7 +10960,8 @@
     },
     "ServiceTier": {
       "enum": [
-        "fast"
+        "fast",
+        "flex"
       ],
       "type": "string"
     },
@@ -12171,6 +12362,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {
@@ -13658,6 +13883,40 @@
           "title": "WebSearchTurnItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revised_prompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "ImageGeneration"
+              ],
+              "title": "ImageGenerationTurnItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationTurnItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {
@@ -14191,6 +14450,12 @@
     "WindowsSandboxSetupStartParams": {
       "$schema": "http://json-schema.org/draft-07/schema#",
       "properties": {
+        "cwd": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
         "mode": {
           "$ref": "#/definitions/WindowsSandboxSetupMode"
         }

codex-rs/app-server-protocol/schema/json/v2/ConfigReadResponse.json

@@ -707,7 +707,8 @@
     },
     "ServiceTier": {
       "enum": [
-        "fast"
+        "fast",
+        "flex"
       ],
       "type": "string"
     },

codex-rs/app-server-protocol/schema/json/v2/ItemCompletedNotification.json

@@ -863,6 +863,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/ItemStartedNotification.json

@@ -863,6 +863,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/PluginInstallParams.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "properties": {
+    "cwd": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "marketplaceName": {
+      "type": "string"
+    },
+    "pluginName": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "marketplaceName",
+    "pluginName"
+  ],
+  "title": "PluginInstallParams",
+  "type": "object"
+}

codex-rs/app-server-protocol/schema/json/v2/PluginInstallResponse.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "PluginInstallResponse",
+  "type": "object"
+}

codex-rs/app-server-protocol/schema/json/v2/RawResponseItemCompletedNotification.json

@@ -641,6 +641,40 @@
           "title": "WebSearchCallResponseItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revised_prompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "image_generation_call"
+              ],
+              "title": "ImageGenerationCallResponseItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationCallResponseItem",
+          "type": "object"
+        },
         {
           "properties": {
             "ghost_commit": {

codex-rs/app-server-protocol/schema/json/v2/ReviewStartResponse.json

@@ -977,6 +977,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/ThreadForkParams.json

@@ -53,7 +53,8 @@
     },
     "ServiceTier": {
       "enum": [
-        "fast"
+        "fast",
+        "flex"
       ],
       "type": "string"
     }

codex-rs/app-server-protocol/schema/json/v2/ThreadForkResponse.json

@@ -744,7 +744,8 @@
     },
     "ServiceTier": {
       "enum": [
-        "fast"
+        "fast",
+        "flex"
       ],
       "type": "string"
     },
@@ -1452,6 +1453,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/ThreadListResponse.json

@@ -1215,6 +1215,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/ThreadMetadataUpdateResponse.json

@@ -1215,6 +1215,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/ThreadReadResponse.json

@@ -1215,6 +1215,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/ThreadResumeParams.json

@@ -691,6 +691,40 @@
           "title": "WebSearchCallResponseItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revised_prompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "image_generation_call"
+              ],
+              "title": "ImageGenerationCallResponseItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationCallResponseItem",
+          "type": "object"
+        },
         {
           "properties": {
             "ghost_commit": {
@@ -759,7 +793,8 @@
     },
     "ServiceTier": {
       "enum": [
-        "fast"
+        "fast",
+        "flex"
       ],
       "type": "string"
     },

codex-rs/app-server-protocol/schema/json/v2/ThreadResumeResponse.json

@@ -744,7 +744,8 @@
     },
     "ServiceTier": {
       "enum": [
-        "fast"
+        "fast",
+        "flex"
       ],
       "type": "string"
     },
@@ -1452,6 +1453,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/ThreadRollbackResponse.json

@@ -1215,6 +1215,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/ThreadStartParams.json

@@ -78,7 +78,8 @@
     },
     "ServiceTier": {
       "enum": [
-        "fast"
+        "fast",
+        "flex"
       ],
       "type": "string"
     }

codex-rs/app-server-protocol/schema/json/v2/ThreadStartResponse.json

@@ -744,7 +744,8 @@
     },
     "ServiceTier": {
       "enum": [
-        "fast"
+        "fast",
+        "flex"
       ],
       "type": "string"
     },
@@ -1452,6 +1453,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/ThreadStartedNotification.json

@@ -1215,6 +1215,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/ThreadUnarchiveResponse.json

@@ -1215,6 +1215,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/TurnCompletedNotification.json

@@ -977,6 +977,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/TurnStartParams.json

@@ -305,7 +305,8 @@
     },
     "ServiceTier": {
       "enum": [
-        "fast"
+        "fast",
+        "flex"
       ],
       "type": "string"
     },

codex-rs/app-server-protocol/schema/json/v2/TurnStartResponse.json

@@ -977,6 +977,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/TurnStartedNotification.json

@@ -977,6 +977,40 @@
           "title": "ImageViewThreadItem",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "result": {
+              "type": "string"
+            },
+            "revisedPrompt": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "status": {
+              "type": "string"
+            },
+            "type": {
+              "enum": [
+                "imageGeneration"
+              ],
+              "title": "ImageGenerationThreadItemType",
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "result",
+            "status",
+            "type"
+          ],
+          "title": "ImageGenerationThreadItem",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {

codex-rs/app-server-protocol/schema/json/v2/WindowsSandboxSetupStartParams.json

@@ -10,6 +10,12 @@
     }
   },
   "properties": {
+    "cwd": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
     "mode": {
       "$ref": "#/definitions/WindowsSandboxSetupMode"
     }

codex-rs/app-server-protocol/schema/typescript/ClientRequest.ts

@@ -22,6 +22,7 @@ import type { ListMcpServerStatusParams } from "./v2/ListMcpServerStatusParams";
 import type { LoginAccountParams } from "./v2/LoginAccountParams";
 import type { McpServerOauthLoginParams } from "./v2/McpServerOauthLoginParams";
 import type { ModelListParams } from "./v2/ModelListParams";
+import type { PluginInstallParams } from "./v2/PluginInstallParams";
 import type { ReviewStartParams } from "./v2/ReviewStartParams";
 import type { SkillsConfigWriteParams } from "./v2/SkillsConfigWriteParams";
 import type { SkillsListParams } from "./v2/SkillsListParams";
@@ -48,4 +49,4 @@ import type { WindowsSandboxSetupStartParams } from "./v2/WindowsSandboxSetupSta
 /**
  * Request from the client to the server.
  */
-export type ClientRequest ={ "method": "initialize", id: RequestId, params: InitializeParams, } | { "method": "thread/start", id: RequestId, params: ThreadStartParams, } | { "method": "thread/resume", id: RequestId, params: ThreadResumeParams, } | { "method": "thread/fork", id: RequestId, params: ThreadForkParams, } | { "method": "thread/archive", id: RequestId, params: ThreadArchiveParams, } | { "method": "thread/unsubscribe", id: RequestId, params: ThreadUnsubscribeParams, } | { "method": "thread/name/set", id: RequestId, params: ThreadSetNameParams, } | { "method": "thread/metadata/update", id: RequestId, params: ThreadMetadataUpdateParams, } | { "method": "thread/unarchive", id: RequestId, params: ThreadUnarchiveParams, } | { "method": "thread/compact/start", id: RequestId, params: ThreadCompactStartParams, } | { "method": "thread/rollback", id: RequestId, params: ThreadRollbackParams, } | { "method": "thread/list", id: RequestId, params: ThreadListParams, } | { "method": "thread/loaded/list", id: RequestId, params: ThreadLoadedListParams, } | { "method": "thread/read", id: RequestId, params: ThreadReadParams, } | { "method": "skills/list", id: RequestId, params: SkillsListParams, } | { "method": "skills/remote/list", id: RequestId, params: SkillsRemoteReadParams, } | { "method": "skills/remote/export", id: RequestId, params: SkillsRemoteWriteParams, } | { "method": "app/list", id: RequestId, params: AppsListParams, } | { "method": "skills/config/write", id: RequestId, params: SkillsConfigWriteParams, } | { "method": "turn/start", id: RequestId, params: TurnStartParams, } | { "method": "turn/steer", id: RequestId, params: TurnSteerParams, } | { "method": "turn/interrupt", id: RequestId, params: TurnInterruptParams, } | { "method": "review/start", id: RequestId, params: ReviewStartParams, } | { "method": "model/list", id: RequestId, params: ModelListParams, } | { "method": "experimentalFeature/list", id: RequestId, params: ExperimentalFeatureListParams, } | { "method": "mcpServer/oauth/login", id: RequestId, params: McpServerOauthLoginParams, } | { "method": "config/mcpServer/reload", id: RequestId, params: undefined, } | { "method": "mcpServerStatus/list", id: RequestId, params: ListMcpServerStatusParams, } | { "method": "windowsSandbox/setupStart", id: RequestId, params: WindowsSandboxSetupStartParams, } | { "method": "account/login/start", id: RequestId, params: LoginAccountParams, } | { "method": "account/login/cancel", id: RequestId, params: CancelLoginAccountParams, } | { "method": "account/logout", id: RequestId, params: undefined, } | { "method": "account/rateLimits/read", id: RequestId, params: undefined, } | { "method": "feedback/upload", id: RequestId, params: FeedbackUploadParams, } | { "method": "command/exec", id: RequestId, params: CommandExecParams, } | { "method": "config/read", id: RequestId, params: ConfigReadParams, } | { "method": "externalAgentConfig/detect", id: RequestId, params: ExternalAgentConfigDetectParams, } | { "method": "externalAgentConfig/import", id: RequestId, params: ExternalAgentConfigImportParams, } | { "method": "config/value/write", id: RequestId, params: ConfigValueWriteParams, } | { "method": "config/batchWrite", id: RequestId, params: ConfigBatchWriteParams, } | { "method": "configRequirements/read", id: RequestId, params: undefined, } | { "method": "account/read", id: RequestId, params: GetAccountParams, } | { "method": "getConversationSummary", id: RequestId, params: GetConversationSummaryParams, } | { "method": "gitDiffToRemote", id: RequestId, params: GitDiffToRemoteParams, } | { "method": "getAuthStatus", id: RequestId, params: GetAuthStatusParams, } | { "method": "fuzzyFileSearch", id: RequestId, params: FuzzyFileSearchParams, };
+export type ClientRequest ={ "method": "initialize", id: RequestId, params: InitializeParams, } | { "method": "thread/start", id: RequestId, params: ThreadStartParams, } | { "method": "thread/resume", id: RequestId, params: ThreadResumeParams, } | { "method": "thread/fork", id: RequestId, params: ThreadForkParams, } | { "method": "thread/archive", id: RequestId, params: ThreadArchiveParams, } | { "method": "thread/unsubscribe", id: RequestId, params: ThreadUnsubscribeParams, } | { "method": "thread/name/set", id: RequestId, params: ThreadSetNameParams, } | { "method": "thread/metadata/update", id: RequestId, params: ThreadMetadataUpdateParams, } | { "method": "thread/unarchive", id: RequestId, params: ThreadUnarchiveParams, } | { "method": "thread/compact/start", id: RequestId, params: ThreadCompactStartParams, } | { "method": "thread/rollback", id: RequestId, params: ThreadRollbackParams, } | { "method": "thread/list", id: RequestId, params: ThreadListParams, } | { "method": "thread/loaded/list", id: RequestId, params: ThreadLoadedListParams, } | { "method": "thread/read", id: RequestId, params: ThreadReadParams, } | { "method": "skills/list", id: RequestId, params: SkillsListParams, } | { "method": "skills/remote/list", id: RequestId, params: SkillsRemoteReadParams, } | { "method": "skills/remote/export", id: RequestId, params: SkillsRemoteWriteParams, } | { "method": "app/list", id: RequestId, params: AppsListParams, } | { "method": "skills/config/write", id: RequestId, params: SkillsConfigWriteParams, } | { "method": "plugin/install", id: RequestId, params: PluginInstallParams, } | { "method": "turn/start", id: RequestId, params: TurnStartParams, } | { "method": "turn/steer", id: RequestId, params: TurnSteerParams, } | { "method": "turn/interrupt", id: RequestId, params: TurnInterruptParams, } | { "method": "review/start", id: RequestId, params: ReviewStartParams, } | { "method": "model/list", id: RequestId, params: ModelListParams, } | { "method": "experimentalFeature/list", id: RequestId, params: ExperimentalFeatureListParams, } | { "method": "mcpServer/oauth/login", id: RequestId, params: McpServerOauthLoginParams, } | { "method": "config/mcpServer/reload", id: RequestId, params: undefined, } | { "method": "mcpServerStatus/list", id: RequestId, params: ListMcpServerStatusParams, } | { "method": "windowsSandbox/setupStart", id: RequestId, params: WindowsSandboxSetupStartParams, } | { "method": "account/login/start", id: RequestId, params: LoginAccountParams, } | { "method": "account/login/cancel", id: RequestId, params: CancelLoginAccountParams, } | { "method": "account/logout", id: RequestId, params: undefined, } | { "method": "account/rateLimits/read", id: RequestId, params: undefined, } | { "method": "feedback/upload", id: RequestId, params: FeedbackUploadParams, } | { "method": "command/exec", id: RequestId, params: CommandExecParams, } | { "method": "config/read", id: RequestId, params: ConfigReadParams, } | { "method": "externalAgentConfig/detect", id: RequestId, params: ExternalAgentConfigDetectParams, } | { "method": "externalAgentConfig/import", id: RequestId, params: ExternalAgentConfigImportParams, } | { "method": "config/value/write", id: RequestId, params: ConfigValueWriteParams, } | { "method": "config/batchWrite", id: RequestId, params: ConfigBatchWriteParams, } | { "method": "configRequirements/read", id: RequestId, params: undefined, } | { "method": "account/read", id: RequestId, params: GetAccountParams, } | { "method": "getConversationSummary", id: RequestId, params: GetConversationSummaryParams, } | { "method": "gitDiffToRemote", id: RequestId, params: GitDiffToRemoteParams, } | { "method": "getAuthStatus", id: RequestId, params: GetAuthStatusParams, } | { "method": "fuzzyFileSearch", id: RequestId, params: FuzzyFileSearchParams, };

codex-rs/app-server-protocol/schema/typescript/ElicitationRequest.ts

@@ -0,0 +1,6 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { JsonValue } from "./serde_json/JsonValue";
+
+export type ElicitationRequest = { "mode": "form", message: string, requested_schema: JsonValue, } | { "mode": "url", message: string, url: string, elicitation_id: string, };

codex-rs/app-server-protocol/schema/typescript/ElicitationRequestEvent.ts

@@ -1,5 +1,6 @@
 // GENERATED CODE! DO NOT MODIFY BY HAND!
 
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { ElicitationRequest } from "./ElicitationRequest";
 
-export type ElicitationRequestEvent = { server_name: string, id: string | number, message: string, };
+export type ElicitationRequestEvent = { server_name: string, id: string | number, request: ElicitationRequest, };

codex-rs/app-server-protocol/schema/typescript/EventMsg.ts

@@ -33,6 +33,8 @@ import type { ExecCommandEndEvent } from "./ExecCommandEndEvent";
 import type { ExecCommandOutputDeltaEvent } from "./ExecCommandOutputDeltaEvent";
 import type { ExitedReviewModeEvent } from "./ExitedReviewModeEvent";
 import type { GetHistoryEntryResponseEvent } from "./GetHistoryEntryResponseEvent";
+import type { ImageGenerationBeginEvent } from "./ImageGenerationBeginEvent";
+import type { ImageGenerationEndEvent } from "./ImageGenerationEndEvent";
 import type { ItemCompletedEvent } from "./ItemCompletedEvent";
 import type { ItemStartedEvent } from "./ItemStartedEvent";
 import type { ListCustomPromptsResponseEvent } from "./ListCustomPromptsResponseEvent";
@@ -79,4 +81,4 @@ import type { WebSearchEndEvent } from "./WebSearchEndEvent";
  * Response event from the agent
  * NOTE: Make sure none of these values have optional types, as it will mess up the extension code-gen.
  */
-export type EventMsg = { "type": "error" } & ErrorEvent | { "type": "warning" } & WarningEvent | { "type": "realtime_conversation_started" } & RealtimeConversationStartedEvent | { "type": "realtime_conversation_realtime" } & RealtimeConversationRealtimeEvent | { "type": "realtime_conversation_closed" } & RealtimeConversationClosedEvent | { "type": "model_reroute" } & ModelRerouteEvent | { "type": "context_compacted" } & ContextCompactedEvent | { "type": "thread_rolled_back" } & ThreadRolledBackEvent | { "type": "task_started" } & TurnStartedEvent | { "type": "task_complete" } & TurnCompleteEvent | { "type": "token_count" } & TokenCountEvent | { "type": "agent_message" } & AgentMessageEvent | { "type": "user_message" } & UserMessageEvent | { "type": "agent_message_delta" } & AgentMessageDeltaEvent | { "type": "agent_reasoning" } & AgentReasoningEvent | { "type": "agent_reasoning_delta" } & AgentReasoningDeltaEvent | { "type": "agent_reasoning_raw_content" } & AgentReasoningRawContentEvent | { "type": "agent_reasoning_raw_content_delta" } & AgentReasoningRawContentDeltaEvent | { "type": "agent_reasoning_section_break" } & AgentReasoningSectionBreakEvent | { "type": "session_configured" } & SessionConfiguredEvent | { "type": "thread_name_updated" } & ThreadNameUpdatedEvent | { "type": "mcp_startup_update" } & McpStartupUpdateEvent | { "type": "mcp_startup_complete" } & McpStartupCompleteEvent | { "type": "mcp_tool_call_begin" } & McpToolCallBeginEvent | { "type": "mcp_tool_call_end" } & McpToolCallEndEvent | { "type": "web_search_begin" } & WebSearchBeginEvent | { "type": "web_search_end" } & WebSearchEndEvent | { "type": "exec_command_begin" } & ExecCommandBeginEvent | { "type": "exec_command_output_delta" } & ExecCommandOutputDeltaEvent | { "type": "terminal_interaction" } & TerminalInteractionEvent | { "type": "exec_command_end" } & ExecCommandEndEvent | { "type": "view_image_tool_call" } & ViewImageToolCallEvent | { "type": "exec_approval_request" } & ExecApprovalRequestEvent | { "type": "request_user_input" } & RequestUserInputEvent | { "type": "dynamic_tool_call_request" } & DynamicToolCallRequest | { "type": "dynamic_tool_call_response" } & DynamicToolCallResponseEvent | { "type": "elicitation_request" } & ElicitationRequestEvent | { "type": "apply_patch_approval_request" } & ApplyPatchApprovalRequestEvent | { "type": "deprecation_notice" } & DeprecationNoticeEvent | { "type": "background_event" } & BackgroundEventEvent | { "type": "undo_started" } & UndoStartedEvent | { "type": "undo_completed" } & UndoCompletedEvent | { "type": "stream_error" } & StreamErrorEvent | { "type": "patch_apply_begin" } & PatchApplyBeginEvent | { "type": "patch_apply_end" } & PatchApplyEndEvent | { "type": "turn_diff" } & TurnDiffEvent | { "type": "get_history_entry_response" } & GetHistoryEntryResponseEvent | { "type": "mcp_list_tools_response" } & McpListToolsResponseEvent | { "type": "list_custom_prompts_response" } & ListCustomPromptsResponseEvent | { "type": "list_skills_response" } & ListSkillsResponseEvent | { "type": "list_remote_skills_response" } & ListRemoteSkillsResponseEvent | { "type": "remote_skill_downloaded" } & RemoteSkillDownloadedEvent | { "type": "skills_update_available" } | { "type": "plan_update" } & UpdatePlanArgs | { "type": "turn_aborted" } & TurnAbortedEvent | { "type": "shutdown_complete" } | { "type": "entered_review_mode" } & ReviewRequest | { "type": "exited_review_mode" } & ExitedReviewModeEvent | { "type": "raw_response_item" } & RawResponseItemEvent | { "type": "item_started" } & ItemStartedEvent | { "type": "item_completed" } & ItemCompletedEvent | { "type": "agent_message_content_delta" } & AgentMessageContentDeltaEvent | { "type": "plan_delta" } & PlanDeltaEvent | { "type": "reasoning_content_delta" } & ReasoningContentDeltaEvent | { "type": "reasoning_raw_content_delta" } & ReasoningRawContentDeltaEvent | { "type": "collab_agent_spawn_begin" } & CollabAgentSpawnBeginEvent | { "type": "collab_agent_spawn_end" } & CollabAgentSpawnEndEvent | { "type": "collab_agent_interaction_begin" } & CollabAgentInteractionBeginEvent | { "type": "collab_agent_interaction_end" } & CollabAgentInteractionEndEvent | { "type": "collab_waiting_begin" } & CollabWaitingBeginEvent | { "type": "collab_waiting_end" } & CollabWaitingEndEvent | { "type": "collab_close_begin" } & CollabCloseBeginEvent | { "type": "collab_close_end" } & CollabCloseEndEvent | { "type": "collab_resume_begin" } & CollabResumeBeginEvent | { "type": "collab_resume_end" } & CollabResumeEndEvent;
+export type EventMsg = { "type": "error" } & ErrorEvent | { "type": "warning" } & WarningEvent | { "type": "realtime_conversation_started" } & RealtimeConversationStartedEvent | { "type": "realtime_conversation_realtime" } & RealtimeConversationRealtimeEvent | { "type": "realtime_conversation_closed" } & RealtimeConversationClosedEvent | { "type": "model_reroute" } & ModelRerouteEvent | { "type": "context_compacted" } & ContextCompactedEvent | { "type": "thread_rolled_back" } & ThreadRolledBackEvent | { "type": "task_started" } & TurnStartedEvent | { "type": "task_complete" } & TurnCompleteEvent | { "type": "token_count" } & TokenCountEvent | { "type": "agent_message" } & AgentMessageEvent | { "type": "user_message" } & UserMessageEvent | { "type": "agent_message_delta" } & AgentMessageDeltaEvent | { "type": "agent_reasoning" } & AgentReasoningEvent | { "type": "agent_reasoning_delta" } & AgentReasoningDeltaEvent | { "type": "agent_reasoning_raw_content" } & AgentReasoningRawContentEvent | { "type": "agent_reasoning_raw_content_delta" } & AgentReasoningRawContentDeltaEvent | { "type": "agent_reasoning_section_break" } & AgentReasoningSectionBreakEvent | { "type": "session_configured" } & SessionConfiguredEvent | { "type": "thread_name_updated" } & ThreadNameUpdatedEvent | { "type": "mcp_startup_update" } & McpStartupUpdateEvent | { "type": "mcp_startup_complete" } & McpStartupCompleteEvent | { "type": "mcp_tool_call_begin" } & McpToolCallBeginEvent | { "type": "mcp_tool_call_end" } & McpToolCallEndEvent | { "type": "web_search_begin" } & WebSearchBeginEvent | { "type": "web_search_end" } & WebSearchEndEvent | { "type": "image_generation_begin" } & ImageGenerationBeginEvent | { "type": "image_generation_end" } & ImageGenerationEndEvent | { "type": "exec_command_begin" } & ExecCommandBeginEvent | { "type": "exec_command_output_delta" } & ExecCommandOutputDeltaEvent | { "type": "terminal_interaction" } & TerminalInteractionEvent | { "type": "exec_command_end" } & ExecCommandEndEvent | { "type": "view_image_tool_call" } & ViewImageToolCallEvent | { "type": "exec_approval_request" } & ExecApprovalRequestEvent | { "type": "request_user_input" } & RequestUserInputEvent | { "type": "dynamic_tool_call_request" } & DynamicToolCallRequest | { "type": "dynamic_tool_call_response" } & DynamicToolCallResponseEvent | { "type": "elicitation_request" } & ElicitationRequestEvent | { "type": "apply_patch_approval_request" } & ApplyPatchApprovalRequestEvent | { "type": "deprecation_notice" } & DeprecationNoticeEvent | { "type": "background_event" } & BackgroundEventEvent | { "type": "undo_started" } & UndoStartedEvent | { "type": "undo_completed" } & UndoCompletedEvent | { "type": "stream_error" } & StreamErrorEvent | { "type": "patch_apply_begin" } & PatchApplyBeginEvent | { "type": "patch_apply_end" } & PatchApplyEndEvent | { "type": "turn_diff" } & TurnDiffEvent | { "type": "get_history_entry_response" } & GetHistoryEntryResponseEvent | { "type": "mcp_list_tools_response" } & McpListToolsResponseEvent | { "type": "list_custom_prompts_response" } & ListCustomPromptsResponseEvent | { "type": "list_skills_response" } & ListSkillsResponseEvent | { "type": "list_remote_skills_response" } & ListRemoteSkillsResponseEvent | { "type": "remote_skill_downloaded" } & RemoteSkillDownloadedEvent | { "type": "skills_update_available" } | { "type": "plan_update" } & UpdatePlanArgs | { "type": "turn_aborted" } & TurnAbortedEvent | { "type": "shutdown_complete" } | { "type": "entered_review_mode" } & ReviewRequest | { "type": "exited_review_mode" } & ExitedReviewModeEvent | { "type": "raw_response_item" } & RawResponseItemEvent | { "type": "item_started" } & ItemStartedEvent | { "type": "item_completed" } & ItemCompletedEvent | { "type": "agent_message_content_delta" } & AgentMessageContentDeltaEvent | { "type": "plan_delta" } & PlanDeltaEvent | { "type": "reasoning_content_delta" } & ReasoningContentDeltaEvent | { "type": "reasoning_raw_content_delta" } & ReasoningRawContentDeltaEvent | { "type": "collab_agent_spawn_begin" } & CollabAgentSpawnBeginEvent | { "type": "collab_agent_spawn_end" } & CollabAgentSpawnEndEvent | { "type": "collab_agent_interaction_begin" } & CollabAgentInteractionBeginEvent | { "type": "collab_agent_interaction_end" } & CollabAgentInteractionEndEvent | { "type": "collab_waiting_begin" } & CollabWaitingBeginEvent | { "type": "collab_waiting_end" } & CollabWaitingEndEvent | { "type": "collab_close_begin" } & CollabCloseBeginEvent | { "type": "collab_close_end" } & CollabCloseEndEvent | { "type": "collab_resume_begin" } & CollabResumeBeginEvent | { "type": "collab_resume_end" } & CollabResumeEndEvent;

codex-rs/app-server-protocol/schema/typescript/ImageGenerationBeginEvent.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type ImageGenerationBeginEvent = { call_id: string, };

codex-rs/app-server-protocol/schema/typescript/ImageGenerationEndEvent.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type ImageGenerationEndEvent = { call_id: string, status: string, revised_prompt?: string, result: string, };

codex-rs/app-server-protocol/schema/typescript/ImageGenerationItem.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type ImageGenerationItem = { id: string, status: string, revised_prompt?: string, result: string, };

codex-rs/app-server-protocol/schema/typescript/ResponseItem.ts

@@ -15,4 +15,4 @@ export type ResponseItem = { "type": "message", role: string, content: Array<Con
 /**
  * Set when using the Responses API.
  */
-call_id: string | null, status: LocalShellStatus, action: LocalShellAction, } | { "type": "function_call", name: string, arguments: string, call_id: string, } | { "type": "function_call_output", call_id: string, output: FunctionCallOutputPayload, } | { "type": "custom_tool_call", status?: string, call_id: string, name: string, input: string, } | { "type": "custom_tool_call_output", call_id: string, output: FunctionCallOutputPayload, } | { "type": "web_search_call", status?: string, action?: WebSearchAction, } | { "type": "ghost_snapshot", ghost_commit: GhostCommit, } | { "type": "compaction", encrypted_content: string, } | { "type": "other" };
+call_id: string | null, status: LocalShellStatus, action: LocalShellAction, } | { "type": "function_call", name: string, arguments: string, call_id: string, } | { "type": "function_call_output", call_id: string, output: FunctionCallOutputPayload, } | { "type": "custom_tool_call", status?: string, call_id: string, name: string, input: string, } | { "type": "custom_tool_call_output", call_id: string, output: FunctionCallOutputPayload, } | { "type": "web_search_call", status?: string, action?: WebSearchAction, } | { "type": "image_generation_call", id: string, status: string, revised_prompt?: string, result: string, } | { "type": "ghost_snapshot", ghost_commit: GhostCommit, } | { "type": "compaction", encrypted_content: string, } | { "type": "other" };

codex-rs/app-server-protocol/schema/typescript/ServerRequest.ts

@@ -8,9 +8,10 @@ import type { ChatgptAuthTokensRefreshParams } from "./v2/ChatgptAuthTokensRefre
 import type { CommandExecutionRequestApprovalParams } from "./v2/CommandExecutionRequestApprovalParams";
 import type { DynamicToolCallParams } from "./v2/DynamicToolCallParams";
 import type { FileChangeRequestApprovalParams } from "./v2/FileChangeRequestApprovalParams";
+import type { McpServerElicitationRequestParams } from "./v2/McpServerElicitationRequestParams";
 import type { ToolRequestUserInputParams } from "./v2/ToolRequestUserInputParams";
 
 /**
  * Request initiated from the server and sent to the client.
  */
-export type ServerRequest = { "method": "item/commandExecution/requestApproval", id: RequestId, params: CommandExecutionRequestApprovalParams, } | { "method": "item/fileChange/requestApproval", id: RequestId, params: FileChangeRequestApprovalParams, } | { "method": "item/tool/requestUserInput", id: RequestId, params: ToolRequestUserInputParams, } | { "method": "item/tool/call", id: RequestId, params: DynamicToolCallParams, } | { "method": "account/chatgptAuthTokens/refresh", id: RequestId, params: ChatgptAuthTokensRefreshParams, } | { "method": "applyPatchApproval", id: RequestId, params: ApplyPatchApprovalParams, } | { "method": "execCommandApproval", id: RequestId, params: ExecCommandApprovalParams, };
+export type ServerRequest = { "method": "item/commandExecution/requestApproval", id: RequestId, params: CommandExecutionRequestApprovalParams, } | { "method": "item/fileChange/requestApproval", id: RequestId, params: FileChangeRequestApprovalParams, } | { "method": "item/tool/requestUserInput", id: RequestId, params: ToolRequestUserInputParams, } | { "method": "mcpServer/elicitation/request", id: RequestId, params: McpServerElicitationRequestParams, } | { "method": "item/tool/call", id: RequestId, params: DynamicToolCallParams, } | { "method": "account/chatgptAuthTokens/refresh", id: RequestId, params: ChatgptAuthTokensRefreshParams, } | { "method": "applyPatchApproval", id: RequestId, params: ApplyPatchApprovalParams, } | { "method": "execCommandApproval", id: RequestId, params: ExecCommandApprovalParams, };

codex-rs/app-server-protocol/schema/typescript/ServiceTier.ts

@@ -2,4 +2,4 @@
 
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
-export type ServiceTier = "fast";
+export type ServiceTier = "fast" | "flex";

codex-rs/app-server-protocol/schema/typescript/TurnItem.ts

@@ -3,9 +3,10 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { AgentMessageItem } from "./AgentMessageItem";
 import type { ContextCompactionItem } from "./ContextCompactionItem";
+import type { ImageGenerationItem } from "./ImageGenerationItem";
 import type { PlanItem } from "./PlanItem";
 import type { ReasoningItem } from "./ReasoningItem";
 import type { UserMessageItem } from "./UserMessageItem";
 import type { WebSearchItem } from "./WebSearchItem";
 
-export type TurnItem = { "type": "UserMessage" } & UserMessageItem | { "type": "AgentMessage" } & AgentMessageItem | { "type": "Plan" } & PlanItem | { "type": "Reasoning" } & ReasoningItem | { "type": "WebSearch" } & WebSearchItem | { "type": "ContextCompaction" } & ContextCompactionItem;
+export type TurnItem = { "type": "UserMessage" } & UserMessageItem | { "type": "AgentMessage" } & AgentMessageItem | { "type": "Plan" } & PlanItem | { "type": "Reasoning" } & ReasoningItem | { "type": "WebSearch" } & WebSearchItem | { "type": "ImageGeneration" } & ImageGenerationItem | { "type": "ContextCompaction" } & ContextCompactionItem;

codex-rs/app-server-protocol/schema/typescript/index.ts

@@ -48,6 +48,7 @@ export type { DeprecationNoticeEvent } from "./DeprecationNoticeEvent";
 export type { DynamicToolCallOutputContentItem } from "./DynamicToolCallOutputContentItem";
 export type { DynamicToolCallRequest } from "./DynamicToolCallRequest";
 export type { DynamicToolCallResponseEvent } from "./DynamicToolCallResponseEvent";
+export type { ElicitationRequest } from "./ElicitationRequest";
 export type { ElicitationRequestEvent } from "./ElicitationRequestEvent";
 export type { ErrorEvent } from "./ErrorEvent";
 export type { EventMsg } from "./EventMsg";
@@ -84,6 +85,9 @@ export type { GitDiffToRemoteResponse } from "./GitDiffToRemoteResponse";
 export type { GitSha } from "./GitSha";
 export type { HistoryEntry } from "./HistoryEntry";
 export type { ImageDetail } from "./ImageDetail";
+export type { ImageGenerationBeginEvent } from "./ImageGenerationBeginEvent";
+export type { ImageGenerationEndEvent } from "./ImageGenerationEndEvent";
+export type { ImageGenerationItem } from "./ImageGenerationItem";
 export type { InitializeCapabilities } from "./InitializeCapabilities";
 export type { InitializeParams } from "./InitializeParams";
 export type { InitializeResponse } from "./InitializeResponse";

codex-rs/app-server-protocol/schema/typescript/v2/McpServerElicitationAction.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type McpServerElicitationAction = "accept" | "decline" | "cancel";

codex-rs/app-server-protocol/schema/typescript/v2/McpServerElicitationRequestParams.ts

@@ -0,0 +1,15 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { JsonValue } from "../serde_json/JsonValue";
+
+export type McpServerElicitationRequestParams = { threadId: string, 
+/**
+ * Active Codex turn when this elicitation was observed, if app-server could correlate one.
+ *
+ * This is nullable because MCP models elicitation as a standalone server-to-client request
+ * identified by the MCP server request id. It may be triggered during a turn, but turn
+ * context is app-server correlation rather than part of the protocol identity of the
+ * elicitation itself.
+ */
+turnId: string | null, serverName: string, } & ({ "mode": "form", message: string, requestedSchema: JsonValue, } | { "mode": "url", message: string, url: string, elicitationId: string, });

codex-rs/app-server-protocol/schema/typescript/v2/McpServerElicitationRequestResponse.ts

@@ -0,0 +1,13 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { JsonValue } from "../serde_json/JsonValue";
+import type { McpServerElicitationAction } from "./McpServerElicitationAction";
+
+export type McpServerElicitationRequestResponse = { action: McpServerElicitationAction, 
+/**
+ * Structured user input for accepted elicitations, mirroring RMCP `CreateElicitationResult`.
+ *
+ * This is nullable because decline/cancel responses have no content.
+ */
+content: JsonValue | null, };

codex-rs/app-server-protocol/schema/typescript/v2/PluginInstallParams.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type PluginInstallParams = { marketplaceName: string, pluginName: string, cwd?: string | null, };

codex-rs/app-server-protocol/schema/typescript/v2/PluginInstallResponse.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type PluginInstallResponse = Record<string, never>;

codex-rs/app-server-protocol/schema/typescript/v2/ThreadItem.ts

@@ -85,4 +85,4 @@ prompt: string | null,
 /**
  * Last known status of the target agents, when available.
  */
-agentsStates: { [key in string]?: CollabAgentState }, } | { "type": "webSearch", id: string, query: string, action: WebSearchAction | null, } | { "type": "imageView", id: string, path: string, } | { "type": "enteredReviewMode", id: string, review: string, } | { "type": "exitedReviewMode", id: string, review: string, } | { "type": "contextCompaction", id: string, };
+agentsStates: { [key in string]?: CollabAgentState }, } | { "type": "webSearch", id: string, query: string, action: WebSearchAction | null, } | { "type": "imageView", id: string, path: string, } | { "type": "imageGeneration", id: string, status: string, revisedPrompt: string | null, result: string, } | { "type": "enteredReviewMode", id: string, review: string, } | { "type": "exitedReviewMode", id: string, review: string, } | { "type": "contextCompaction", id: string, };

codex-rs/app-server-protocol/schema/typescript/v2/WindowsSandboxSetupStartParams.ts

@@ -3,4 +3,4 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { WindowsSandboxSetupMode } from "./WindowsSandboxSetupMode";
 
-export type WindowsSandboxSetupStartParams = { mode: WindowsSandboxSetupMode, };
+export type WindowsSandboxSetupStartParams = { mode: WindowsSandboxSetupMode, cwd?: string | null, };

codex-rs/app-server-protocol/schema/typescript/v2/index.ts

@@ -97,6 +97,9 @@ export type { LoginAccountParams } from "./LoginAccountParams";
 export type { LoginAccountResponse } from "./LoginAccountResponse";
 export type { LogoutAccountResponse } from "./LogoutAccountResponse";
 export type { McpAuthStatus } from "./McpAuthStatus";
+export type { McpServerElicitationAction } from "./McpServerElicitationAction";
+export type { McpServerElicitationRequestParams } from "./McpServerElicitationRequestParams";
+export type { McpServerElicitationRequestResponse } from "./McpServerElicitationRequestResponse";
 export type { McpServerOauthLoginCompletedNotification } from "./McpServerOauthLoginCompletedNotification";
 export type { McpServerOauthLoginParams } from "./McpServerOauthLoginParams";
 export type { McpServerOauthLoginResponse } from "./McpServerOauthLoginResponse";
@@ -124,6 +127,8 @@ export type { OverriddenMetadata } from "./OverriddenMetadata";
 export type { PatchApplyStatus } from "./PatchApplyStatus";
 export type { PatchChangeKind } from "./PatchChangeKind";
 export type { PlanDeltaNotification } from "./PlanDeltaNotification";
+export type { PluginInstallParams } from "./PluginInstallParams";
+export type { PluginInstallResponse } from "./PluginInstallResponse";
 export type { ProductSurface } from "./ProductSurface";
 export type { ProfileV2 } from "./ProfileV2";
 export type { RateLimitSnapshot } from "./RateLimitSnapshot";

codex-rs/app-server-protocol/src/protocol/common.rs

@@ -264,6 +264,10 @@ client_request_definitions! {
         params: v2::SkillsConfigWriteParams,
         response: v2::SkillsConfigWriteResponse,
     },
+    PluginInstall => "plugin/install" {
+        params: v2::PluginInstallParams,
+        response: v2::PluginInstallResponse,
+    },
     TurnStart => "turn/start" {
         params: v2::TurnStartParams,
         inspect_params: true,
@@ -646,6 +650,12 @@ server_request_definitions! {
         response: v2::ToolRequestUserInputResponse,
     },
 
+    /// Request input for an MCP server elicitation.
+    McpServerElicitationRequest => "mcpServer/elicitation/request" {
+        params: v2::McpServerElicitationRequestParams,
+        response: v2::McpServerElicitationRequestResponse,
+    },
+
     /// Execute a dynamic tool call on the client.
     DynamicToolCall => "item/tool/call" {
         params: v2::DynamicToolCallParams,
@@ -1042,6 +1052,60 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn serialize_mcp_server_elicitation_request() -> Result<()> {
+        let params = v2::McpServerElicitationRequestParams {
+            thread_id: "thr_123".to_string(),
+            turn_id: Some("turn_123".to_string()),
+            server_name: "codex_apps".to_string(),
+            request: v2::McpServerElicitationRequest::Form {
+                message: "Allow this request?".to_string(),
+                requested_schema: json!({
+                    "type": "object",
+                    "properties": {
+                        "confirmed": {
+                            "type": "boolean"
+                        }
+                    },
+                    "required": ["confirmed"]
+                }),
+            },
+        };
+        let request = ServerRequest::McpServerElicitationRequest {
+            request_id: RequestId::Integer(9),
+            params: params.clone(),
+        };
+
+        assert_eq!(
+            json!({
+                "method": "mcpServer/elicitation/request",
+                "id": 9,
+                "params": {
+                    "threadId": "thr_123",
+                    "turnId": "turn_123",
+                    "serverName": "codex_apps",
+                    "mode": "form",
+                    "message": "Allow this request?",
+                    "requestedSchema": {
+                        "type": "object",
+                        "properties": {
+                            "confirmed": {
+                                "type": "boolean"
+                            }
+                        },
+                        "required": ["confirmed"]
+                    }
+                }
+            }),
+            serde_json::to_value(&request)?,
+        );
+
+        let payload = ServerRequestPayload::McpServerElicitationRequest(params);
+        assert_eq!(request.id(), &RequestId::Integer(9));
+        assert_eq!(payload.request_with_id(RequestId::Integer(9)), request);
+        Ok(())
+    }
+
     #[test]
     fn serialize_get_account_rate_limits() -> Result<()> {
         let request = ClientRequest::GetAccountRateLimits {

codex-rs/app-server-protocol/src/protocol/thread_history.rs

@@ -30,6 +30,8 @@ use codex_protocol::protocol::ErrorEvent;
 use codex_protocol::protocol::EventMsg;
 use codex_protocol::protocol::ExecCommandBeginEvent;
 use codex_protocol::protocol::ExecCommandEndEvent;
+use codex_protocol::protocol::ImageGenerationBeginEvent;
+use codex_protocol::protocol::ImageGenerationEndEvent;
 use codex_protocol::protocol::ItemCompletedEvent;
 use codex_protocol::protocol::ItemStartedEvent;
 use codex_protocol::protocol::McpToolCallBeginEvent;
@@ -141,6 +143,8 @@ impl ThreadHistoryBuilder {
             EventMsg::McpToolCallBegin(payload) => self.handle_mcp_tool_call_begin(payload),
             EventMsg::McpToolCallEnd(payload) => self.handle_mcp_tool_call_end(payload),
             EventMsg::ViewImageToolCall(payload) => self.handle_view_image_tool_call(payload),
+            EventMsg::ImageGenerationBegin(payload) => self.handle_image_generation_begin(payload),
+            EventMsg::ImageGenerationEnd(payload) => self.handle_image_generation_end(payload),
             EventMsg::CollabAgentSpawnBegin(payload) => {
                 self.handle_collab_agent_spawn_begin(payload)
             }
@@ -269,6 +273,7 @@ impl ThreadHistoryBuilder {
             | codex_protocol::items::TurnItem::AgentMessage(_)
             | codex_protocol::items::TurnItem::Reasoning(_)
             | codex_protocol::items::TurnItem::WebSearch(_)
+            | codex_protocol::items::TurnItem::ImageGeneration(_)
             | codex_protocol::items::TurnItem::ContextCompaction(_) => {}
         }
     }
@@ -288,6 +293,7 @@ impl ThreadHistoryBuilder {
             | codex_protocol::items::TurnItem::AgentMessage(_)
             | codex_protocol::items::TurnItem::Reasoning(_)
             | codex_protocol::items::TurnItem::WebSearch(_)
+            | codex_protocol::items::TurnItem::ImageGeneration(_)
             | codex_protocol::items::TurnItem::ContextCompaction(_) => {}
         }
     }
@@ -516,6 +522,26 @@ impl ThreadHistoryBuilder {
         self.upsert_item_in_current_turn(item);
     }
 
+    fn handle_image_generation_begin(&mut self, payload: &ImageGenerationBeginEvent) {
+        let item = ThreadItem::ImageGeneration {
+            id: payload.call_id.clone(),
+            status: String::new(),
+            revised_prompt: None,
+            result: String::new(),
+        };
+        self.upsert_item_in_current_turn(item);
+    }
+
+    fn handle_image_generation_end(&mut self, payload: &ImageGenerationEndEvent) {
+        let item = ThreadItem::ImageGeneration {
+            id: payload.call_id.clone(),
+            status: payload.status.clone(),
+            revised_prompt: payload.revised_prompt.clone(),
+            result: payload.result.clone(),
+        };
+        self.upsert_item_in_current_turn(item);
+    }
+
     fn handle_collab_agent_spawn_begin(
         &mut self,
         payload: &codex_protocol::protocol::CollabAgentSpawnBeginEvent,

codex-rs/app-server-protocol/src/protocol/v2.rs

@@ -6,6 +6,7 @@ use crate::RequestId;
 use crate::protocol::common::AuthMode;
 use codex_experimental_api_macros::ExperimentalApi;
 use codex_protocol::account::PlanType;
+use codex_protocol::approvals::ElicitationRequest as CoreElicitationRequest;
 use codex_protocol::approvals::ExecPolicyAmendment as CoreExecPolicyAmendment;
 use codex_protocol::approvals::NetworkApprovalContext as CoreNetworkApprovalContext;
 use codex_protocol::approvals::NetworkApprovalProtocol as CoreNetworkApprovalProtocol;
@@ -637,7 +638,7 @@ pub struct NetworkRequirements {
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema, TS)]
-#[serde(rename_all = "lowercase")]
+#[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub enum ResidencyRequirement {
     Us,
@@ -2393,8 +2394,8 @@ pub enum HazelnutScope {
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, JsonSchema, TS, Default)]
-#[serde(rename_all = "lowercase")]
-#[ts(rename_all = "lowercase")]
+#[serde(rename_all = "camelCase")]
+#[ts(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub enum ProductSurface {
     Chatgpt,
@@ -2546,6 +2547,21 @@ pub struct SkillsConfigWriteResponse {
     pub effective_enabled: bool,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export_to = "v2/")]
+pub struct PluginInstallParams {
+    pub marketplace_name: String,
+    pub plugin_name: String,
+    #[ts(optional = nullable)]
+    pub cwd: Option<PathBuf>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export_to = "v2/")]
+pub struct PluginInstallResponse {}
+
 impl From<CoreSkillMetadata> for SkillMetadata {
     fn from(value: CoreSkillMetadata) -> Self {
         Self {
@@ -3332,6 +3348,14 @@ pub enum ThreadItem {
     ImageView { id: String, path: String },
     #[serde(rename_all = "camelCase")]
     #[ts(rename_all = "camelCase")]
+    ImageGeneration {
+        id: String,
+        status: String,
+        revised_prompt: Option<String>,
+        result: String,
+    },
+    #[serde(rename_all = "camelCase")]
+    #[ts(rename_all = "camelCase")]
     EnteredReviewMode { id: String, review: String },
     #[serde(rename_all = "camelCase")]
     #[ts(rename_all = "camelCase")]
@@ -3355,6 +3379,7 @@ impl ThreadItem {
             | ThreadItem::CollabAgentToolCall { id, .. }
             | ThreadItem::WebSearch { id, .. }
             | ThreadItem::ImageView { id, .. }
+            | ThreadItem::ImageGeneration { id, .. }
             | ThreadItem::EnteredReviewMode { id, .. }
             | ThreadItem::ExitedReviewMode { id, .. }
             | ThreadItem::ContextCompaction { id, .. } => id,
@@ -3434,6 +3459,12 @@ impl From<CoreTurnItem> for ThreadItem {
                 query: search.query,
                 action: Some(WebSearchAction::from(search.action)),
             },
+            CoreTurnItem::ImageGeneration(image) => ThreadItem::ImageGeneration {
+                id: image.id,
+                status: image.status,
+                revised_prompt: image.revised_prompt,
+                result: image.result,
+            },
             CoreTurnItem::ContextCompaction(compaction) => {
                 ThreadItem::ContextCompaction { id: compaction.id }
             }
@@ -3927,6 +3958,8 @@ pub enum WindowsSandboxSetupMode {
 #[ts(export_to = "v2/")]
 pub struct WindowsSandboxSetupStartParams {
     pub mode: WindowsSandboxSetupMode,
+    #[ts(optional = nullable)]
+    pub cwd: Option<PathBuf>,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
@@ -4049,6 +4082,138 @@ pub struct FileChangeRequestApprovalResponse {
     pub decision: FileChangeApprovalDecision,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, JsonSchema, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(rename_all = "camelCase")]
+#[ts(export_to = "v2/")]
+pub enum McpServerElicitationAction {
+    Accept,
+    Decline,
+    Cancel,
+}
+
+impl McpServerElicitationAction {
+    pub fn to_core(self) -> codex_protocol::approvals::ElicitationAction {
+        match self {
+            Self::Accept => codex_protocol::approvals::ElicitationAction::Accept,
+            Self::Decline => codex_protocol::approvals::ElicitationAction::Decline,
+            Self::Cancel => codex_protocol::approvals::ElicitationAction::Cancel,
+        }
+    }
+}
+
+impl From<McpServerElicitationAction> for rmcp::model::ElicitationAction {
+    fn from(value: McpServerElicitationAction) -> Self {
+        match value {
+            McpServerElicitationAction::Accept => Self::Accept,
+            McpServerElicitationAction::Decline => Self::Decline,
+            McpServerElicitationAction::Cancel => Self::Cancel,
+        }
+    }
+}
+
+impl From<rmcp::model::ElicitationAction> for McpServerElicitationAction {
+    fn from(value: rmcp::model::ElicitationAction) -> Self {
+        match value {
+            rmcp::model::ElicitationAction::Accept => Self::Accept,
+            rmcp::model::ElicitationAction::Decline => Self::Decline,
+            rmcp::model::ElicitationAction::Cancel => Self::Cancel,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export_to = "v2/")]
+pub struct McpServerElicitationRequestParams {
+    pub thread_id: String,
+    /// Active Codex turn when this elicitation was observed, if app-server could correlate one.
+    ///
+    /// This is nullable because MCP models elicitation as a standalone server-to-client request
+    /// identified by the MCP server request id. It may be triggered during a turn, but turn
+    /// context is app-server correlation rather than part of the protocol identity of the
+    /// elicitation itself.
+    pub turn_id: Option<String>,
+    pub server_name: String,
+    #[serde(flatten)]
+    pub request: McpServerElicitationRequest,
+    // TODO: When core can correlate an elicitation with an MCP tool call, expose the associated
+    // McpToolCall item id here as an optional field. The current core event does not carry that
+    // association.
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
+#[serde(tag = "mode", rename_all = "camelCase")]
+#[ts(tag = "mode")]
+#[ts(export_to = "v2/")]
+pub enum McpServerElicitationRequest {
+    #[serde(rename_all = "camelCase")]
+    #[ts(rename_all = "camelCase")]
+    Form {
+        message: String,
+        requested_schema: JsonValue,
+    },
+    #[serde(rename_all = "camelCase")]
+    #[ts(rename_all = "camelCase")]
+    Url {
+        message: String,
+        url: String,
+        elicitation_id: String,
+    },
+}
+
+impl From<CoreElicitationRequest> for McpServerElicitationRequest {
+    fn from(value: CoreElicitationRequest) -> Self {
+        match value {
+            CoreElicitationRequest::Form {
+                message,
+                requested_schema,
+            } => Self::Form {
+                message,
+                requested_schema,
+            },
+            CoreElicitationRequest::Url {
+                message,
+                url,
+                elicitation_id,
+            } => Self::Url {
+                message,
+                url,
+                elicitation_id,
+            },
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export_to = "v2/")]
+pub struct McpServerElicitationRequestResponse {
+    pub action: McpServerElicitationAction,
+    /// Structured user input for accepted elicitations, mirroring RMCP `CreateElicitationResult`.
+    ///
+    /// This is nullable because decline/cancel responses have no content.
+    pub content: Option<JsonValue>,
+}
+
+impl From<McpServerElicitationRequestResponse> for rmcp::model::CreateElicitationResult {
+    fn from(value: McpServerElicitationRequestResponse) -> Self {
+        Self {
+            action: value.action.into(),
+            content: value.content,
+        }
+    }
+}
+
+impl From<rmcp::model::CreateElicitationResult> for McpServerElicitationRequestResponse {
+    fn from(value: rmcp::model::CreateElicitationResult) -> Self {
+        Self {
+            action: value.action.into(),
+            content: value.content,
+        }
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
@@ -4385,6 +4550,65 @@ mod tests {
         assert_eq!(back_to_v2, v2_policy);
     }
 
+    #[test]
+    fn mcp_server_elicitation_response_round_trips_rmcp_result() {
+        let rmcp_result = rmcp::model::CreateElicitationResult {
+            action: rmcp::model::ElicitationAction::Accept,
+            content: Some(json!({
+                "confirmed": true,
+            })),
+        };
+
+        let v2_response = McpServerElicitationRequestResponse::from(rmcp_result.clone());
+        assert_eq!(
+            v2_response,
+            McpServerElicitationRequestResponse {
+                action: McpServerElicitationAction::Accept,
+                content: Some(json!({
+                    "confirmed": true,
+                })),
+            }
+        );
+        assert_eq!(
+            rmcp::model::CreateElicitationResult::from(v2_response),
+            rmcp_result
+        );
+    }
+
+    #[test]
+    fn mcp_server_elicitation_request_from_core_url_request() {
+        let request = McpServerElicitationRequest::from(CoreElicitationRequest::Url {
+            message: "Finish sign-in".to_string(),
+            url: "https://example.com/complete".to_string(),
+            elicitation_id: "elicitation-123".to_string(),
+        });
+
+        assert_eq!(
+            request,
+            McpServerElicitationRequest::Url {
+                message: "Finish sign-in".to_string(),
+                url: "https://example.com/complete".to_string(),
+                elicitation_id: "elicitation-123".to_string(),
+            }
+        );
+    }
+
+    #[test]
+    fn mcp_server_elicitation_response_serializes_nullable_content() {
+        let response = McpServerElicitationRequestResponse {
+            action: McpServerElicitationAction::Decline,
+            content: None,
+        };
+
+        assert_eq!(
+            serde_json::to_value(response).expect("response should serialize"),
+            json!({
+                "action": "decline",
+                "content": null,
+            })
+        );
+    }
+
     #[test]
     fn sandbox_policy_round_trips_workspace_write_read_only_access() {
         let readable_root = test_absolute_path();

codex-rs/app-server-test-client/Cargo.toml

@@ -11,9 +11,15 @@ workspace = true
 anyhow = { workspace = true }
 clap = { workspace = true, features = ["derive", "env"] }
 codex-app-server-protocol = { workspace = true }
+codex-core = { workspace = true }
+codex-otel = { workspace = true }
 codex-protocol = { workspace = true }
+codex-utils-cli = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
+tokio = { workspace = true, features = ["rt"] }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
 tungstenite = { workspace = true }
 url = { workspace = true }
 uuid = { workspace = true, features = ["v4"] }

codex-rs/app-server-test-client/src/lib.rs

@@ -62,10 +62,17 @@ use codex_app_server_protocol::TurnStartParams;
 use codex_app_server_protocol::TurnStartResponse;
 use codex_app_server_protocol::TurnStatus;
 use codex_app_server_protocol::UserInput as V2UserInput;
+use codex_core::config::Config;
+use codex_otel::current_span_w3c_trace_context;
+use codex_otel::otel_provider::OtelProvider;
 use codex_protocol::protocol::W3cTraceContext;
+use codex_utils_cli::CliConfigOverrides;
 use serde::Serialize;
 use serde::de::DeserializeOwned;
 use serde_json::Value;
+use tracing::info_span;
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::util::SubscriberInitExt;
 use tungstenite::Message;
 use tungstenite::WebSocket;
 use tungstenite::connect;
@@ -98,6 +105,10 @@ const NOTIFICATIONS_TO_OPT_OUT: &[&str] = &[
 ];
 const APP_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(5);
 const APP_SERVER_GRACEFUL_SHUTDOWN_POLL_INTERVAL: Duration = Duration::from_millis(100);
+const DEFAULT_ANALYTICS_ENABLED: bool = true;
+const OTEL_SERVICE_NAME: &str = "codex-app-server-test-client";
+const TRACE_DISABLED_MESSAGE: &str =
+    "Not enabled - enable tracing in $CODEX_HOME/config.toml to get a trace URL!";
 
 /// Minimal launcher that initializes the Codex app-server and logs the handshake.
 #[derive(Parser)]
@@ -236,7 +247,7 @@ enum CliCommand {
     },
 }
 
-pub fn run() -> Result<()> {
+pub async fn run() -> Result<()> {
     let Cli {
         codex_bin,
         url,
@@ -256,7 +267,7 @@ pub fn run() -> Result<()> {
         CliCommand::SendMessage { user_message } => {
             ensure_dynamic_tools_unused(&dynamic_tools, "send-message")?;
             let endpoint = resolve_endpoint(codex_bin, url)?;
-            send_message(&endpoint, &config_overrides, user_message)
+            send_message(&endpoint, &config_overrides, user_message).await
         }
         CliCommand::SendMessageV2 {
             experimental_api,
@@ -270,6 +281,7 @@ pub fn run() -> Result<()> {
                 experimental_api,
                 &dynamic_tools,
             )
+            .await
         }
         CliCommand::ResumeMessageV2 {
             thread_id,
@@ -283,28 +295,29 @@ pub fn run() -> Result<()> {
                 user_message,
                 &dynamic_tools,
             )
+            .await
         }
         CliCommand::ThreadResume { thread_id } => {
             ensure_dynamic_tools_unused(&dynamic_tools, "thread-resume")?;
             let endpoint = resolve_endpoint(codex_bin, url)?;
-            thread_resume_follow(&endpoint, &config_overrides, thread_id)
+            thread_resume_follow(&endpoint, &config_overrides, thread_id).await
         }
         CliCommand::Watch => {
             ensure_dynamic_tools_unused(&dynamic_tools, "watch")?;
             let endpoint = resolve_endpoint(codex_bin, url)?;
-            watch(&endpoint, &config_overrides)
+            watch(&endpoint, &config_overrides).await
         }
         CliCommand::TriggerCmdApproval { user_message } => {
             let endpoint = resolve_endpoint(codex_bin, url)?;
-            trigger_cmd_approval(&endpoint, &config_overrides, user_message, &dynamic_tools)
+            trigger_cmd_approval(&endpoint, &config_overrides, user_message, &dynamic_tools).await
         }
         CliCommand::TriggerPatchApproval { user_message } => {
             let endpoint = resolve_endpoint(codex_bin, url)?;
-            trigger_patch_approval(&endpoint, &config_overrides, user_message, &dynamic_tools)
+            trigger_patch_approval(&endpoint, &config_overrides, user_message, &dynamic_tools).await
         }
         CliCommand::NoTriggerCmdApproval => {
             let endpoint = resolve_endpoint(codex_bin, url)?;
-            no_trigger_cmd_approval(&endpoint, &config_overrides, &dynamic_tools)
+            no_trigger_cmd_approval(&endpoint, &config_overrides, &dynamic_tools).await
         }
         CliCommand::SendFollowUpV2 {
             first_message,
@@ -318,6 +331,7 @@ pub fn run() -> Result<()> {
                 follow_up_message,
                 &dynamic_tools,
             )
+            .await
         }
         CliCommand::TriggerZshForkMultiCmdApproval {
             user_message,
@@ -333,26 +347,27 @@ pub fn run() -> Result<()> {
                 abort_on,
                 &dynamic_tools,
             )
+            .await
         }
         CliCommand::TestLogin => {
             ensure_dynamic_tools_unused(&dynamic_tools, "test-login")?;
             let endpoint = resolve_endpoint(codex_bin, url)?;
-            test_login(&endpoint, &config_overrides)
+            test_login(&endpoint, &config_overrides).await
         }
         CliCommand::GetAccountRateLimits => {
             ensure_dynamic_tools_unused(&dynamic_tools, "get-account-rate-limits")?;
             let endpoint = resolve_endpoint(codex_bin, url)?;
-            get_account_rate_limits(&endpoint, &config_overrides)
+            get_account_rate_limits(&endpoint, &config_overrides).await
         }
         CliCommand::ModelList => {
             ensure_dynamic_tools_unused(&dynamic_tools, "model-list")?;
             let endpoint = resolve_endpoint(codex_bin, url)?;
-            model_list(&endpoint, &config_overrides)
+            model_list(&endpoint, &config_overrides).await
         }
         CliCommand::ThreadList { limit } => {
             ensure_dynamic_tools_unused(&dynamic_tools, "thread-list")?;
             let endpoint = resolve_endpoint(codex_bin, url)?;
-            thread_list(&endpoint, &config_overrides, limit)
+            thread_list(&endpoint, &config_overrides, limit).await
         }
     }
 }
@@ -487,7 +502,15 @@ fn shell_quote(input: &str) -> String {
     format!("'{}'", input.replace('\'', "'\\''"))
 }
 
-fn send_message(
+struct SendMessagePolicies<'a> {
+    command_name: &'static str,
+    experimental_api: bool,
+    approval_policy: Option<AskForApproval>,
+    sandbox_policy: Option<SandboxPolicy>,
+    dynamic_tools: &'a Option<Vec<DynamicToolSpec>>,
+}
+
+async fn send_message(
     endpoint: &Endpoint,
     config_overrides: &[String],
     user_message: String,
@@ -497,14 +520,18 @@ fn send_message(
         endpoint,
         config_overrides,
         user_message,
-        false,
-        None,
-        None,
-        &dynamic_tools,
+        SendMessagePolicies {
+            command_name: "send-message",
+            experimental_api: false,
+            approval_policy: None,
+            sandbox_policy: None,
+            dynamic_tools: &dynamic_tools,
+        },
     )
+    .await
 }
 
-pub fn send_message_v2(
+pub async fn send_message_v2(
     codex_bin: &Path,
     config_overrides: &[String],
     user_message: String,
@@ -518,9 +545,10 @@ pub fn send_message_v2(
         true,
         dynamic_tools,
     )
+    .await
 }
 
-fn send_message_v2_endpoint(
+async fn send_message_v2_endpoint(
     endpoint: &Endpoint,
     config_overrides: &[String],
     user_message: String,
@@ -535,14 +563,18 @@ fn send_message_v2_endpoint(
         endpoint,
         config_overrides,
         user_message,
-        experimental_api,
-        None,
-        None,
-        dynamic_tools,
+        SendMessagePolicies {
+            command_name: "send-message-v2",
+            experimental_api,
+            approval_policy: None,
+            sandbox_policy: None,
+            dynamic_tools,
+        },
     )
+    .await
 }
 
-fn trigger_zsh_fork_multi_cmd_approval(
+async fn trigger_zsh_fork_multi_cmd_approval(
     endpoint: &Endpoint,
     config_overrides: &[String],
     user_message: Option<String>,
@@ -559,89 +591,96 @@ fn trigger_zsh_fork_multi_cmd_approval(
     let default_prompt = "Run this exact command using shell command execution without rewriting or splitting it: /usr/bin/true && /usr/bin/true";
     let message = user_message.unwrap_or_else(|| default_prompt.to_string());
 
-    with_client(endpoint, config_overrides, |client| {
-        let initialize = client.initialize()?;
-        println!("< initialize response: {initialize:?}");
+    with_client(
+        "trigger-zsh-fork-multi-cmd-approval",
+        endpoint,
+        config_overrides,
+        |client| {
+            let initialize = client.initialize()?;
+            println!("< initialize response: {initialize:?}");
 
-        let thread_response = client.thread_start(ThreadStartParams {
-            dynamic_tools: dynamic_tools.clone(),
-            ..Default::default()
-        })?;
-        println!("< thread/start response: {thread_response:?}");
+            let thread_response = client.thread_start(ThreadStartParams {
+                dynamic_tools: dynamic_tools.clone(),
+                ..Default::default()
+            })?;
+            println!("< thread/start response: {thread_response:?}");
 
-        client.command_approval_behavior = match abort_on {
-            Some(index) => CommandApprovalBehavior::AbortOn(index),
-            None => CommandApprovalBehavior::AlwaysAccept,
-        };
-        client.command_approval_count = 0;
-        client.command_approval_item_ids.clear();
-        client.command_execution_statuses.clear();
-        client.last_turn_status = None;
+            client.command_approval_behavior = match abort_on {
+                Some(index) => CommandApprovalBehavior::AbortOn(index),
+                None => CommandApprovalBehavior::AlwaysAccept,
+            };
+            client.command_approval_count = 0;
+            client.command_approval_item_ids.clear();
+            client.command_execution_statuses.clear();
+            client.last_turn_status = None;
 
-        let mut turn_params = TurnStartParams {
-            thread_id: thread_response.thread.id.clone(),
-            input: vec![V2UserInput::Text {
-                text: message,
-                text_elements: Vec::new(),
-            }],
-            ..Default::default()
-        };
-        turn_params.approval_policy = Some(AskForApproval::OnRequest);
-        turn_params.sandbox_policy = Some(SandboxPolicy::ReadOnly {
-            access: ReadOnlyAccess::FullAccess,
-            network_access: false,
-        });
+            let mut turn_params = TurnStartParams {
+                thread_id: thread_response.thread.id.clone(),
+                input: vec![V2UserInput::Text {
+                    text: message,
+                    text_elements: Vec::new(),
+                }],
+                ..Default::default()
+            };
+            turn_params.approval_policy = Some(AskForApproval::OnRequest);
+            turn_params.sandbox_policy = Some(SandboxPolicy::ReadOnly {
+                access: ReadOnlyAccess::FullAccess,
+                network_access: false,
+            });
 
-        let turn_response = client.turn_start(turn_params)?;
-        println!("< turn/start response: {turn_response:?}");
-        client.stream_turn(&thread_response.thread.id, &turn_response.turn.id)?;
+            let turn_response = client.turn_start(turn_params)?;
+            println!("< turn/start response: {turn_response:?}");
+            client.stream_turn(&thread_response.thread.id, &turn_response.turn.id)?;
 
-        if client.command_approval_count < min_approvals {
-            bail!(
-                "expected at least {min_approvals} command approvals, got {}",
-                client.command_approval_count
-            );
-        }
-        let mut approvals_per_item = std::collections::BTreeMap::new();
-        for item_id in &client.command_approval_item_ids {
-            *approvals_per_item.entry(item_id.clone()).or_insert(0usize) += 1;
-        }
-        let max_approvals_for_one_item = approvals_per_item.values().copied().max().unwrap_or(0);
-        if max_approvals_for_one_item < min_approvals {
-            bail!(
-                "expected at least {min_approvals} approvals for one command item, got max {max_approvals_for_one_item} with map {approvals_per_item:?}"
-            );
-        }
-
-        let last_command_status = client.command_execution_statuses.last();
-        if abort_on.is_none() {
-            if last_command_status != Some(&CommandExecutionStatus::Completed) {
-                bail!("expected completed command execution, got {last_command_status:?}");
-            }
-            if client.last_turn_status != Some(TurnStatus::Completed) {
+            if client.command_approval_count < min_approvals {
                 bail!(
-                    "expected completed turn in all-accept flow, got {:?}",
-                    client.last_turn_status
+                    "expected at least {min_approvals} command approvals, got {}",
+                    client.command_approval_count
                 );
             }
-        } else if last_command_status == Some(&CommandExecutionStatus::Completed) {
-            bail!(
-                "expected non-completed command execution in mixed approval/decline flow, got {last_command_status:?}"
+            let mut approvals_per_item = std::collections::BTreeMap::new();
+            for item_id in &client.command_approval_item_ids {
+                *approvals_per_item.entry(item_id.clone()).or_insert(0usize) += 1;
+            }
+            let max_approvals_for_one_item =
+                approvals_per_item.values().copied().max().unwrap_or(0);
+            if max_approvals_for_one_item < min_approvals {
+                bail!(
+                    "expected at least {min_approvals} approvals for one command item, got max {max_approvals_for_one_item} with map {approvals_per_item:?}"
+                );
+            }
+
+            let last_command_status = client.command_execution_statuses.last();
+            if abort_on.is_none() {
+                if last_command_status != Some(&CommandExecutionStatus::Completed) {
+                    bail!("expected completed command execution, got {last_command_status:?}");
+                }
+                if client.last_turn_status != Some(TurnStatus::Completed) {
+                    bail!(
+                        "expected completed turn in all-accept flow, got {:?}",
+                        client.last_turn_status
+                    );
+                }
+            } else if last_command_status == Some(&CommandExecutionStatus::Completed) {
+                bail!(
+                    "expected non-completed command execution in mixed approval/decline flow, got {last_command_status:?}"
+                );
+            }
+
+            println!(
+                "[zsh-fork multi-approval summary] approvals={}, approvals_per_item={approvals_per_item:?}, command_statuses={:?}, turn_status={:?}",
+                client.command_approval_count,
+                client.command_execution_statuses,
+                client.last_turn_status
             );
-        }
 
-        println!(
-            "[zsh-fork multi-approval summary] approvals={}, approvals_per_item={approvals_per_item:?}, command_statuses={:?}, turn_status={:?}",
-            client.command_approval_count,
-            client.command_execution_statuses,
-            client.last_turn_status
-        );
-
-        Ok(())
-    })
+            Ok(())
+        },
+    )
+    .await
 }
 
-fn resume_message_v2(
+async fn resume_message_v2(
     endpoint: &Endpoint,
     config_overrides: &[String],
     thread_id: String,
@@ -650,7 +689,7 @@ fn resume_message_v2(
 ) -> Result<()> {
     ensure_dynamic_tools_unused(dynamic_tools, "resume-message-v2")?;
 
-    with_client(endpoint, config_overrides, |client| {
+    with_client("resume-message-v2", endpoint, config_overrides, |client| {
         let initialize = client.initialize()?;
         println!("< initialize response: {initialize:?}");
 
@@ -674,39 +713,42 @@ fn resume_message_v2(
 
         Ok(())
     })
+    .await
 }
 
-fn thread_resume_follow(
+async fn thread_resume_follow(
     endpoint: &Endpoint,
     config_overrides: &[String],
     thread_id: String,
 ) -> Result<()> {
-    let mut client = CodexClient::connect(endpoint, config_overrides)?;
+    with_client("thread-resume", endpoint, config_overrides, |client| {
+        let initialize = client.initialize()?;
+        println!("< initialize response: {initialize:?}");
 
-    let initialize = client.initialize()?;
-    println!("< initialize response: {initialize:?}");
+        let resume_response = client.thread_resume(ThreadResumeParams {
+            thread_id,
+            ..Default::default()
+        })?;
+        println!("< thread/resume response: {resume_response:?}");
+        println!("< streaming notifications until process is terminated");
 
-    let resume_response = client.thread_resume(ThreadResumeParams {
-        thread_id,
-        ..Default::default()
-    })?;
-    println!("< thread/resume response: {resume_response:?}");
-    println!("< streaming notifications until process is terminated");
-
-    client.stream_notifications_forever()
+        client.stream_notifications_forever()
+    })
+    .await
 }
 
-fn watch(endpoint: &Endpoint, config_overrides: &[String]) -> Result<()> {
-    let mut client = CodexClient::connect(endpoint, config_overrides)?;
+async fn watch(endpoint: &Endpoint, config_overrides: &[String]) -> Result<()> {
+    with_client("watch", endpoint, config_overrides, |client| {
+        let initialize = client.initialize()?;
+        println!("< initialize response: {initialize:?}");
+        println!("< streaming inbound messages until process is terminated");
 
-    let initialize = client.initialize()?;
-    println!("< initialize response: {initialize:?}");
-    println!("< streaming inbound messages until process is terminated");
-
-    client.stream_notifications_forever()
+        client.stream_notifications_forever()
+    })
+    .await
 }
 
-fn trigger_cmd_approval(
+async fn trigger_cmd_approval(
     endpoint: &Endpoint,
     config_overrides: &[String],
     user_message: Option<String>,
@@ -719,17 +761,21 @@ fn trigger_cmd_approval(
         endpoint,
         config_overrides,
         message,
-        true,
-        Some(AskForApproval::OnRequest),
-        Some(SandboxPolicy::ReadOnly {
-            access: ReadOnlyAccess::FullAccess,
-            network_access: false,
-        }),
-        dynamic_tools,
+        SendMessagePolicies {
+            command_name: "trigger-cmd-approval",
+            experimental_api: true,
+            approval_policy: Some(AskForApproval::OnRequest),
+            sandbox_policy: Some(SandboxPolicy::ReadOnly {
+                access: ReadOnlyAccess::FullAccess,
+                network_access: false,
+            }),
+            dynamic_tools,
+        },
     )
+    .await
 }
 
-fn trigger_patch_approval(
+async fn trigger_patch_approval(
     endpoint: &Endpoint,
     config_overrides: &[String],
     user_message: Option<String>,
@@ -742,17 +788,21 @@ fn trigger_patch_approval(
         endpoint,
         config_overrides,
         message,
-        true,
-        Some(AskForApproval::OnRequest),
-        Some(SandboxPolicy::ReadOnly {
-            access: ReadOnlyAccess::FullAccess,
-            network_access: false,
-        }),
-        dynamic_tools,
+        SendMessagePolicies {
+            command_name: "trigger-patch-approval",
+            experimental_api: true,
+            approval_policy: Some(AskForApproval::OnRequest),
+            sandbox_policy: Some(SandboxPolicy::ReadOnly {
+                access: ReadOnlyAccess::FullAccess,
+                network_access: false,
+            }),
+            dynamic_tools,
+        },
     )
+    .await
 }
 
-fn no_trigger_cmd_approval(
+async fn no_trigger_cmd_approval(
     endpoint: &Endpoint,
     config_overrides: &[String],
     dynamic_tools: &Option<Vec<DynamicToolSpec>>,
@@ -762,60 +812,67 @@ fn no_trigger_cmd_approval(
         endpoint,
         config_overrides,
         prompt.to_string(),
-        true,
-        None,
-        None,
-        dynamic_tools,
+        SendMessagePolicies {
+            command_name: "no-trigger-cmd-approval",
+            experimental_api: true,
+            approval_policy: None,
+            sandbox_policy: None,
+            dynamic_tools,
+        },
     )
+    .await
 }
 
-fn send_message_v2_with_policies(
+async fn send_message_v2_with_policies(
     endpoint: &Endpoint,
     config_overrides: &[String],
     user_message: String,
-    experimental_api: bool,
-    approval_policy: Option<AskForApproval>,
-    sandbox_policy: Option<SandboxPolicy>,
-    dynamic_tools: &Option<Vec<DynamicToolSpec>>,
+    policies: SendMessagePolicies<'_>,
 ) -> Result<()> {
-    with_client(endpoint, config_overrides, |client| {
-        let initialize = client.initialize_with_experimental_api(experimental_api)?;
-        println!("< initialize response: {initialize:?}");
+    with_client(
+        policies.command_name,
+        endpoint,
+        config_overrides,
+        |client| {
+            let initialize = client.initialize_with_experimental_api(policies.experimental_api)?;
+            println!("< initialize response: {initialize:?}");
 
-        let thread_response = client.thread_start(ThreadStartParams {
-            dynamic_tools: dynamic_tools.clone(),
-            ..Default::default()
-        })?;
-        println!("< thread/start response: {thread_response:?}");
-        let mut turn_params = TurnStartParams {
-            thread_id: thread_response.thread.id.clone(),
-            input: vec![V2UserInput::Text {
-                text: user_message,
-                // Test client sends plain text without UI element ranges.
-                text_elements: Vec::new(),
-            }],
-            ..Default::default()
-        };
-        turn_params.approval_policy = approval_policy;
-        turn_params.sandbox_policy = sandbox_policy;
+            let thread_response = client.thread_start(ThreadStartParams {
+                dynamic_tools: policies.dynamic_tools.clone(),
+                ..Default::default()
+            })?;
+            println!("< thread/start response: {thread_response:?}");
+            let mut turn_params = TurnStartParams {
+                thread_id: thread_response.thread.id.clone(),
+                input: vec![V2UserInput::Text {
+                    text: user_message,
+                    // Test client sends plain text without UI element ranges.
+                    text_elements: Vec::new(),
+                }],
+                ..Default::default()
+            };
+            turn_params.approval_policy = policies.approval_policy;
+            turn_params.sandbox_policy = policies.sandbox_policy;
 
-        let turn_response = client.turn_start(turn_params)?;
-        println!("< turn/start response: {turn_response:?}");
+            let turn_response = client.turn_start(turn_params)?;
+            println!("< turn/start response: {turn_response:?}");
 
-        client.stream_turn(&thread_response.thread.id, &turn_response.turn.id)?;
+            client.stream_turn(&thread_response.thread.id, &turn_response.turn.id)?;
 
-        Ok(())
-    })
+            Ok(())
+        },
+    )
+    .await
 }
 
-fn send_follow_up_v2(
+async fn send_follow_up_v2(
     endpoint: &Endpoint,
     config_overrides: &[String],
     first_message: String,
     follow_up_message: String,
     dynamic_tools: &Option<Vec<DynamicToolSpec>>,
 ) -> Result<()> {
-    with_client(endpoint, config_overrides, |client| {
+    with_client("send-follow-up-v2", endpoint, config_overrides, |client| {
         let initialize = client.initialize()?;
         println!("< initialize response: {initialize:?}");
 
@@ -853,10 +910,11 @@ fn send_follow_up_v2(
 
         Ok(())
     })
+    .await
 }
 
-fn test_login(endpoint: &Endpoint, config_overrides: &[String]) -> Result<()> {
-    with_client(endpoint, config_overrides, |client| {
+async fn test_login(endpoint: &Endpoint, config_overrides: &[String]) -> Result<()> {
+    with_client("test-login", endpoint, config_overrides, |client| {
         let initialize = client.initialize()?;
         println!("< initialize response: {initialize:?}");
 
@@ -883,22 +941,29 @@ fn test_login(endpoint: &Endpoint, config_overrides: &[String]) -> Result<()> {
             );
         }
     })
+    .await
 }
 
-fn get_account_rate_limits(endpoint: &Endpoint, config_overrides: &[String]) -> Result<()> {
-    with_client(endpoint, config_overrides, |client| {
-        let initialize = client.initialize()?;
-        println!("< initialize response: {initialize:?}");
+async fn get_account_rate_limits(endpoint: &Endpoint, config_overrides: &[String]) -> Result<()> {
+    with_client(
+        "get-account-rate-limits",
+        endpoint,
+        config_overrides,
+        |client| {
+            let initialize = client.initialize()?;
+            println!("< initialize response: {initialize:?}");
 
-        let response = client.get_account_rate_limits()?;
-        println!("< account/rateLimits/read response: {response:?}");
+            let response = client.get_account_rate_limits()?;
+            println!("< account/rateLimits/read response: {response:?}");
 
-        Ok(())
-    })
+            Ok(())
+        },
+    )
+    .await
 }
 
-fn model_list(endpoint: &Endpoint, config_overrides: &[String]) -> Result<()> {
-    with_client(endpoint, config_overrides, |client| {
+async fn model_list(endpoint: &Endpoint, config_overrides: &[String]) -> Result<()> {
+    with_client("model-list", endpoint, config_overrides, |client| {
         let initialize = client.initialize()?;
         println!("< initialize response: {initialize:?}");
 
@@ -907,10 +972,11 @@ fn model_list(endpoint: &Endpoint, config_overrides: &[String]) -> Result<()> {
 
         Ok(())
     })
+    .await
 }
 
-fn thread_list(endpoint: &Endpoint, config_overrides: &[String], limit: u32) -> Result<()> {
-    with_client(endpoint, config_overrides, |client| {
+async fn thread_list(endpoint: &Endpoint, config_overrides: &[String], limit: u32) -> Result<()> {
+    with_client("thread-list", endpoint, config_overrides, |client| {
         let initialize = client.initialize()?;
         println!("< initialize response: {initialize:?}");
 
@@ -928,16 +994,28 @@ fn thread_list(endpoint: &Endpoint, config_overrides: &[String], limit: u32) ->
 
         Ok(())
     })
+    .await
 }
 
-fn with_client<T>(
+async fn with_client<T>(
+    command_name: &'static str,
     endpoint: &Endpoint,
     config_overrides: &[String],
     f: impl FnOnce(&mut CodexClient) -> Result<T>,
 ) -> Result<T> {
-    let mut client = CodexClient::connect(endpoint, config_overrides)?;
-    let result = f(&mut client);
-    client.print_trace_summary();
+    let tracing = TestClientTracing::initialize(config_overrides).await?;
+    let command_span = info_span!(
+        "app_server_test_client.command",
+        otel.kind = "client",
+        otel.name = command_name,
+        app_server_test_client.command = command_name,
+    );
+    let trace_summary = command_span.in_scope(|| TraceSummary::capture(tracing.traces_enabled));
+    let result = command_span.in_scope(|| {
+        let mut client = CodexClient::connect(endpoint, config_overrides)?;
+        f(&mut client)
+    });
+    print_trace_summary(&trace_summary);
     result
 }
 
@@ -995,8 +1073,6 @@ struct CodexClient {
     command_approval_item_ids: Vec<String>,
     command_execution_statuses: Vec<CommandExecutionStatus>,
     last_turn_status: Option<TurnStatus>,
-    trace_id: String,
-    trace_root_span_id: String,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -1056,8 +1132,6 @@ impl CodexClient {
             command_approval_item_ids: Vec::new(),
             command_execution_statuses: Vec::new(),
             last_turn_status: None,
-            trace_id: generate_trace_id(),
-            trace_root_span_id: generate_parent_span_id(),
         })
     }
 
@@ -1079,8 +1153,6 @@ impl CodexClient {
             command_approval_item_ids: Vec::new(),
             command_execution_statuses: Vec::new(),
             last_turn_status: None,
-            trace_id: generate_trace_id(),
-            trace_root_span_id: generate_parent_span_id(),
         })
     }
 
@@ -1302,37 +1374,31 @@ impl CodexClient {
     where
         T: DeserializeOwned,
     {
-        self.write_request(&request)?;
-        self.wait_for_response(request_id, method)
+        let request_span = info_span!(
+            "app_server_test_client.request",
+            otel.kind = "client",
+            otel.name = method,
+            rpc.system = "jsonrpc",
+            rpc.method = method,
+            rpc.request_id = ?request_id,
+        );
+        request_span.in_scope(|| {
+            self.write_request(&request)?;
+            self.wait_for_response(request_id, method)
+        })
     }
 
     fn write_request(&mut self, request: &ClientRequest) -> Result<()> {
-        let request = self.jsonrpc_request_with_trace(request)?;
+        let request_value = serde_json::to_value(request)?;
+        let mut request: JSONRPCRequest = serde_json::from_value(request_value)
+            .context("client request was not a valid JSON-RPC request")?;
+        request.trace = current_span_w3c_trace_context();
         let request_json = serde_json::to_string(&request)?;
         let request_pretty = serde_json::to_string_pretty(&request)?;
         print_multiline_with_prefix("> ", &request_pretty);
         self.write_payload(&request_json)
     }
 
-    fn jsonrpc_request_with_trace(&self, request: &ClientRequest) -> Result<JSONRPCRequest> {
-        let request_value = serde_json::to_value(request)?;
-        let mut request: JSONRPCRequest = serde_json::from_value(request_value)
-            .context("client request was not a valid JSON-RPC request")?;
-        request.trace = Some(W3cTraceContext {
-            traceparent: Some(format!(
-                "00-{}-{}-01",
-                self.trace_id, self.trace_root_span_id
-            )),
-            tracestate: None,
-        });
-        Ok(request)
-    }
-
-    fn print_trace_summary(&self) {
-        println!("\n[Datadog trace]");
-        println!("go/trace/{}\n", self.trace_id);
-    }
-
     fn wait_for_response<T>(&mut self, request_id: RequestId, method: &str) -> Result<T>
     where
         T: DeserializeOwned,
@@ -1598,21 +1664,91 @@ impl CodexClient {
     }
 }
 
-fn generate_trace_id() -> String {
-    Uuid::new_v4().simple().to_string()
-}
-
-fn generate_parent_span_id() -> String {
-    let uuid = Uuid::new_v4().simple().to_string();
-    uuid[..16].to_string()
-}
-
 fn print_multiline_with_prefix(prefix: &str, payload: &str) {
     for line in payload.lines() {
         println!("{prefix}{line}");
     }
 }
 
+struct TestClientTracing {
+    _otel_provider: Option<OtelProvider>,
+    traces_enabled: bool,
+}
+
+impl TestClientTracing {
+    async fn initialize(config_overrides: &[String]) -> Result<Self> {
+        let cli_kv_overrides = CliConfigOverrides {
+            raw_overrides: config_overrides.to_vec(),
+        }
+        .parse_overrides()
+        .map_err(|e| anyhow::anyhow!("error parsing -c overrides: {e}"))?;
+        let config = Config::load_with_cli_overrides(cli_kv_overrides)
+            .await
+            .context("error loading config")?;
+        let otel_provider = codex_core::otel_init::build_provider(
+            &config,
+            env!("CARGO_PKG_VERSION"),
+            Some(OTEL_SERVICE_NAME),
+            DEFAULT_ANALYTICS_ENABLED,
+        )
+        .map_err(|e| anyhow::anyhow!("error loading otel config: {e}"))?;
+        let traces_enabled = otel_provider
+            .as_ref()
+            .and_then(|provider| provider.tracer_provider.as_ref())
+            .is_some();
+        if let Some(provider) = otel_provider.as_ref()
+            && traces_enabled
+        {
+            let _ = tracing_subscriber::registry()
+                .with(provider.tracing_layer())
+                .try_init();
+        }
+        Ok(Self {
+            traces_enabled,
+            _otel_provider: otel_provider,
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum TraceSummary {
+    Enabled { url: String },
+    Disabled,
+}
+
+impl TraceSummary {
+    fn capture(traces_enabled: bool) -> Self {
+        if !traces_enabled {
+            return Self::Disabled;
+        }
+        current_span_w3c_trace_context()
+            .as_ref()
+            .and_then(trace_url_from_context)
+            .map_or(Self::Disabled, |url| Self::Enabled { url })
+    }
+}
+
+fn trace_url_from_context(trace: &W3cTraceContext) -> Option<String> {
+    let traceparent = trace.traceparent.as_deref()?;
+    let mut parts = traceparent.split('-');
+    match (parts.next(), parts.next(), parts.next(), parts.next()) {
+        (Some(_version), Some(trace_id), Some(_span_id), Some(_trace_flags))
+            if trace_id.len() == 32 =>
+        {
+            Some(format!("go/trace/{trace_id}"))
+        }
+        _ => None,
+    }
+}
+
+fn print_trace_summary(trace_summary: &TraceSummary) {
+    println!("\n[Datadog trace]");
+    match trace_summary {
+        TraceSummary::Enabled { url } => println!("{url}\n"),
+        TraceSummary::Disabled => println!("{TRACE_DISABLED_MESSAGE}\n"),
+    }
+}
+
 impl Drop for CodexClient {
     fn drop(&mut self) {
         let ClientTransport::Stdio { child, stdin, .. } = &mut self.transport else {

codex-rs/app-server-test-client/src/main.rs

@@ -1,5 +1,7 @@
 use anyhow::Result;
+use tokio::runtime::Builder;
 
 fn main() -> Result<()> {
-    codex_app_server_test_client::run()
+    let runtime = Builder::new_current_thread().enable_all().build()?;
+    runtime.block_on(codex_app_server_test_client::run())
 }

codex-rs/app-server/Cargo.toml

@@ -69,6 +69,7 @@ core_test_support = { workspace = true }
 codex-utils-cargo-bin = { workspace = true }
 pretty_assertions = { workspace = true }
 rmcp = { workspace = true, default-features = false, features = [
+    "elicitation",
     "server",
     "transport-streamable-http-server",
 ] }

codex-rs/app-server/README.md

@@ -153,11 +153,12 @@ Example with notification opt-out:
 - `skills/remote/export` — download a remote skill by `hazelnutId` into `skills` under `codex_home` (**under development; do not call from production clients yet**).
 - `app/list` — list available apps.
 - `skills/config/write` — write user-level skill config by path.
+- `plugin/install` — install a plugin from a discovered marketplace entry by `pluginName` and `marketplaceName` (**under development; do not call from production clients yet**).
 - `mcpServer/oauth/login` — start an OAuth login for a configured MCP server; returns an `authorization_url` and later emits `mcpServer/oauthLogin/completed` once the browser flow finishes.
 - `tool/requestUserInput` — prompt the user with 1–3 short questions for a tool call and return their answers (experimental).
 - `config/mcpServer/reload` — reload MCP server config from disk and queue a refresh for loaded threads (applied on each thread's next active turn); returns `{}`. Use this after editing `config.toml` without restarting the server.
 - `mcpServerStatus/list` — enumerate configured MCP servers with their tools, resources, resource templates, and auth status; supports cursor+limit pagination.
-- `windowsSandbox/setupStart` — start Windows sandbox setup for the selected mode (`elevated` or `unelevated`); returns `{ started: true }` immediately and later emits `windowsSandbox/setupCompleted`.
+- `windowsSandbox/setupStart` — start Windows sandbox setup for the selected mode (`elevated` or `unelevated`); accepts an optional `cwd` to target setup for a specific workspace, returns `{ started: true }` immediately, and later emits `windowsSandbox/setupCompleted`.
 - `feedback/upload` — submit a feedback report (classification + optional reason/logs, conversation_id, and optional `extraLogFiles` attachments array); returns the tracking thread id.
 - `command/exec` — run a single command under the server sandbox without starting a thread/turn (handy for utilities and validation).
 - `config/read` — fetch the effective config on disk after resolving config layering.
@@ -763,6 +764,20 @@ UI guidance for IDEs: surface an approval dialog as soon as the request arrives.
 
 When the client responds to `item/tool/requestUserInput`, the server emits `serverRequest/resolved` with `{ threadId, requestId }`. If the pending request is cleared by turn start, turn completion, or turn interruption before the client answers, the server emits the same notification for that cleanup.
 
+### MCP server elicitations
+
+MCP servers can interrupt a turn and ask the client for structured input via `mcpServer/elicitation/request`.
+
+Order of messages:
+
+1. `mcpServer/elicitation/request` (request) — includes `threadId`, nullable `turnId`, `serverName`, and either:
+   - a form request: `{ "mode": "form", "message": "...", "requestedSchema": { ... } }`
+   - a URL request: `{ "mode": "url", "message": "...", "url": "...", "elicitationId": "..." }`
+2. Client response — `{ "action": "accept", "content": ... }`, `{ "action": "decline", "content": null }`, or `{ "action": "cancel", "content": null }`.
+3. `serverRequest/resolved` — `{ threadId, requestId }` confirms the pending request has been resolved or cleared, including lifecycle cleanup on turn start/complete/interrupt.
+
+`turnId` is best-effort. When the elicitation is correlated with an active turn, the request includes that turn id; otherwise it is `null`.
+
 ### Dynamic tool calls (experimental)
 
 `dynamicTools` on `thread/start` and the corresponding `item/tool/call` request/response flow are experimental APIs. To enable them, set `initialize.params.capabilities.experimentalApi = true`.

codex-rs/app-server/src/bespoke_event_handling.rs

@@ -45,6 +45,9 @@ use codex_app_server_protocol::InterruptConversationResponse;
 use codex_app_server_protocol::ItemCompletedNotification;
 use codex_app_server_protocol::ItemStartedNotification;
 use codex_app_server_protocol::JSONRPCErrorError;
+use codex_app_server_protocol::McpServerElicitationAction;
+use codex_app_server_protocol::McpServerElicitationRequestParams;
+use codex_app_server_protocol::McpServerElicitationRequestResponse;
 use codex_app_server_protocol::McpToolCallError;
 use codex_app_server_protocol::McpToolCallResult;
 use codex_app_server_protocol::McpToolCallStatus;
@@ -609,6 +612,38 @@ pub(crate) async fn apply_bespoke_event_handling(
                 }
             }
         }
+        EventMsg::ElicitationRequest(request) => {
+            if matches!(api_version, ApiVersion::V2) {
+                let permission_guard = thread_watch_manager
+                    .note_permission_requested(&conversation_id.to_string())
+                    .await;
+                let turn_id = {
+                    let state = thread_state.lock().await;
+                    state.active_turn_snapshot().map(|turn| turn.id)
+                };
+                let params = McpServerElicitationRequestParams {
+                    thread_id: conversation_id.to_string(),
+                    turn_id,
+                    server_name: request.server_name.clone(),
+                    request: request.request.into(),
+                };
+                let (pending_request_id, rx) = outgoing
+                    .send_request(ServerRequestPayload::McpServerElicitationRequest(params))
+                    .await;
+                tokio::spawn(async move {
+                    on_mcp_server_elicitation_response(
+                        request.server_name,
+                        request.id,
+                        pending_request_id,
+                        rx,
+                        conversation,
+                        thread_state,
+                        permission_guard,
+                    )
+                    .await;
+                });
+            }
+        }
         EventMsg::DynamicToolCallRequest(request) => {
             if matches!(api_version, ApiVersion::V2) {
                 let call_id = request.call_id;
@@ -1989,6 +2024,68 @@ async fn on_request_user_input_response(
     }
 }
 
+async fn on_mcp_server_elicitation_response(
+    server_name: String,
+    request_id: codex_protocol::mcp::RequestId,
+    pending_request_id: RequestId,
+    receiver: oneshot::Receiver<ClientRequestResult>,
+    conversation: Arc<CodexThread>,
+    thread_state: Arc<Mutex<ThreadState>>,
+    permission_guard: ThreadWatchActiveGuard,
+) {
+    let response = receiver.await;
+    resolve_server_request_on_thread_listener(&thread_state, pending_request_id).await;
+    drop(permission_guard);
+    let response = mcp_server_elicitation_response_from_client_result(response);
+
+    if let Err(err) = conversation
+        .submit(Op::ResolveElicitation {
+            server_name,
+            request_id,
+            decision: response.action.to_core(),
+            content: response.content,
+        })
+        .await
+    {
+        error!("failed to submit ResolveElicitation: {err}");
+    }
+}
+
+fn mcp_server_elicitation_response_from_client_result(
+    response: std::result::Result<ClientRequestResult, oneshot::error::RecvError>,
+) -> McpServerElicitationRequestResponse {
+    match response {
+        Ok(Ok(value)) => serde_json::from_value::<McpServerElicitationRequestResponse>(value)
+            .unwrap_or_else(|err| {
+                error!("failed to deserialize McpServerElicitationRequestResponse: {err}");
+                McpServerElicitationRequestResponse {
+                    action: McpServerElicitationAction::Decline,
+                    content: None,
+                }
+            }),
+        Ok(Err(err)) if is_turn_transition_server_request_error(&err) => {
+            McpServerElicitationRequestResponse {
+                action: McpServerElicitationAction::Cancel,
+                content: None,
+            }
+        }
+        Ok(Err(err)) => {
+            error!("request failed with client error: {err:?}");
+            McpServerElicitationRequestResponse {
+                action: McpServerElicitationAction::Decline,
+                content: None,
+            }
+        }
+        Err(err) => {
+            error!("request failed: {err:?}");
+            McpServerElicitationRequestResponse {
+                action: McpServerElicitationAction::Decline,
+                content: None,
+            }
+        }
+    }
+}
+
 const REVIEW_FALLBACK_MESSAGE: &str = "Reviewer failed to output a response.";
 
 fn render_review_output_text(output: &ReviewOutputEvent) -> String {
@@ -2334,6 +2431,7 @@ mod tests {
     use anyhow::Result;
     use anyhow::anyhow;
     use anyhow::bail;
+    use codex_app_server_protocol::JSONRPCErrorError;
     use codex_app_server_protocol::TurnPlanStepStatus;
     use codex_protocol::mcp::CallToolResult;
     use codex_protocol::plan_tool::PlanItemArg;
@@ -2378,6 +2476,25 @@ mod tests {
         assert_eq!(completion_status, None);
     }
 
+    #[test]
+    fn mcp_server_elicitation_turn_transition_error_maps_to_cancel() {
+        let error = JSONRPCErrorError {
+            code: -1,
+            message: "client request resolved because the turn state was changed".to_string(),
+            data: Some(serde_json::json!({ "reason": "turnTransition" })),
+        };
+
+        let response = mcp_server_elicitation_response_from_client_result(Ok(Err(error)));
+
+        assert_eq!(
+            response,
+            McpServerElicitationRequestResponse {
+                action: McpServerElicitationAction::Cancel,
+                content: None,
+            }
+        );
+    }
+
     #[test]
     fn collab_resume_begin_maps_to_item_started_resume_agent() {
         let event = CollabResumeBeginEvent {

codex-rs/app-server/src/codex_message_processor.rs

@@ -77,6 +77,8 @@ use codex_app_server_protocol::MockExperimentalMethodParams;
 use codex_app_server_protocol::MockExperimentalMethodResponse;
 use codex_app_server_protocol::ModelListParams;
 use codex_app_server_protocol::ModelListResponse;
+use codex_app_server_protocol::PluginInstallParams;
+use codex_app_server_protocol::PluginInstallResponse;
 use codex_app_server_protocol::ProductSurface as ApiProductSurface;
 use codex_app_server_protocol::RequestId;
 use codex_app_server_protocol::ReviewDelivery as ApiReviewDelivery;
@@ -196,6 +198,8 @@ use codex_core::mcp::collect_mcp_snapshot;
 use codex_core::mcp::group_tools_by_server;
 use codex_core::models_manager::collaboration_mode_presets::CollaborationModesConfig;
 use codex_core::parse_cursor;
+use codex_core::plugins::PluginInstallError as CorePluginInstallError;
+use codex_core::plugins::PluginInstallRequest;
 use codex_core::read_head_for_summary;
 use codex_core::read_session_meta_line;
 use codex_core::rollout_date_parts;
@@ -658,6 +662,10 @@ impl CodexMessageProcessor {
                 self.skills_config_write(to_connection_request_id(request_id), params)
                     .await;
             }
+            ClientRequest::PluginInstall { request_id, params } => {
+                self.plugin_install(to_connection_request_id(request_id), params)
+                    .await;
+            }
             ClientRequest::TurnStart { request_id, params } => {
                 self.turn_start(
                     to_connection_request_id(request_id),
@@ -2693,7 +2701,13 @@ impl CodexMessageProcessor {
             }
         };
 
-        let db_summary = read_summary_from_state_db_by_thread_id(&self.config, thread_uuid).await;
+        let loaded_thread = self.thread_manager.get_thread(thread_uuid).await.ok();
+        let loaded_thread_state_db = loaded_thread.as_ref().and_then(|thread| thread.state_db());
+        let db_summary = if let Some(state_db_ctx) = loaded_thread_state_db.as_ref() {
+            read_summary_from_state_db_context_by_thread_id(Some(state_db_ctx), thread_uuid).await
+        } else {
+            read_summary_from_state_db_by_thread_id(&self.config, thread_uuid).await
+        };
         let mut rollout_path = db_summary.as_ref().map(|summary| summary.path.clone());
         if rollout_path.is_none() || include_turns {
             rollout_path =
@@ -2747,7 +2761,7 @@ impl CodexMessageProcessor {
                 }
             }
         } else {
-            let Ok(thread) = self.thread_manager.get_thread(thread_uuid).await else {
+            let Some(thread) = loaded_thread else {
                 self.send_invalid_request_error(
                     request_id,
                     format!("thread not loaded: {thread_uuid}"),
@@ -2952,6 +2966,7 @@ impl CodexMessageProcessor {
         };
 
         let fallback_model_provider = config.model_provider_id.clone();
+        let response_history = thread_history.clone();
 
         match self
             .thread_manager
@@ -2965,8 +2980,8 @@ impl CodexMessageProcessor {
         {
             Ok(NewThread {
                 thread_id,
+                thread,
                 session_configured,
-                ..
             }) => {
                 let SessionConfiguredEvent { rollout_path, .. } = session_configured;
                 let Some(rollout_path) = rollout_path else {
@@ -2992,9 +3007,11 @@ impl CodexMessageProcessor {
                 );
 
                 let Some(mut thread) = self
-                    .load_thread_from_rollout_or_send_internal(
+                    .load_thread_from_resume_source_or_send_internal(
                         request_id.clone(),
                         thread_id,
+                        thread.as_ref(),
+                        &response_history,
                         rollout_path.as_path(),
                         fallback_model_provider.as_str(),
                     )
@@ -3149,6 +3166,20 @@ impl CodexMessageProcessor {
                     mismatch_details.join("; ")
                 );
             }
+            let thread_summary = match load_thread_summary_for_rollout(
+                &self.config,
+                existing_thread_id,
+                rollout_path.as_path(),
+                config_snapshot.model_provider_id.as_str(),
+            )
+            .await
+            {
+                Ok(thread) => thread,
+                Err(message) => {
+                    self.send_internal_error(request_id, message).await;
+                    return true;
+                }
+            };
 
             let listener_command_tx = {
                 let thread_state = thread_state.lock().await;
@@ -3169,8 +3200,9 @@ impl CodexMessageProcessor {
             let command = crate::thread_state::ThreadListenerCommand::SendThreadResumeResponse(
                 Box::new(crate::thread_state::PendingThreadResumeRequest {
                     request_id: request_id.clone(),
-                    rollout_path,
+                    rollout_path: rollout_path.clone(),
                     config_snapshot,
+                    thread_summary,
                 }),
             );
             if listener_command_tx.send(command).is_err() {
@@ -3268,45 +3300,61 @@ impl CodexMessageProcessor {
         }
     }
 
-    async fn load_thread_from_rollout_or_send_internal(
+    async fn load_thread_from_resume_source_or_send_internal(
         &self,
         request_id: ConnectionRequestId,
         thread_id: ThreadId,
+        thread: &CodexThread,
+        thread_history: &InitialHistory,
         rollout_path: &Path,
         fallback_provider: &str,
     ) -> Option<Thread> {
-        let mut thread = match read_summary_from_rollout(rollout_path, fallback_provider).await {
-            Ok(summary) => summary_to_thread(summary),
-            Err(err) => {
-                self.send_internal_error(
-                    request_id,
-                    format!(
-                        "failed to load rollout `{}` for thread {thread_id}: {err}",
-                        rollout_path.display()
-                    ),
+        let thread = match thread_history {
+            InitialHistory::Resumed(resumed) => {
+                load_thread_summary_for_rollout(
+                    &self.config,
+                    resumed.conversation_id,
+                    resumed.rollout_path.as_path(),
+                    fallback_provider,
                 )
-                .await;
+                .await
+            }
+            InitialHistory::Forked(items) => {
+                let config_snapshot = thread.config_snapshot().await;
+                let mut thread = build_thread_from_snapshot(
+                    thread_id,
+                    &config_snapshot,
+                    Some(rollout_path.into()),
+                );
+                thread.preview = preview_from_rollout_items(items);
+                Ok(thread)
+            }
+            InitialHistory::New => Err(format!(
+                "failed to build resume response for thread {thread_id}: initial history missing"
+            )),
+        };
+        let mut thread = match thread {
+            Ok(thread) => thread,
+            Err(message) => {
+                self.send_internal_error(request_id, message).await;
                 return None;
             }
         };
-        match read_rollout_items_from_rollout(rollout_path).await {
-            Ok(items) => {
-                thread.turns = build_turns_from_rollout_items(&items);
-                self.attach_thread_name(thread_id, &mut thread).await;
-                Some(thread)
-            }
-            Err(err) => {
-                self.send_internal_error(
-                    request_id,
-                    format!(
-                        "failed to load rollout `{}` for thread {thread_id}: {err}",
-                        rollout_path.display()
-                    ),
-                )
-                .await;
-                None
-            }
+        thread.id = thread_id.to_string();
+        thread.path = Some(rollout_path.to_path_buf());
+        let history_items = thread_history.get_rollout_items();
+        if let Err(message) = populate_resume_turns(
+            &mut thread,
+            ResumeTurnSource::HistoryItems(&history_items),
+            None,
+        )
+        .await
+        {
+            self.send_internal_error(request_id, message).await;
+            return None;
         }
+        self.attach_thread_name(thread_id, &mut thread).await;
+        Some(thread)
     }
 
     async fn attach_thread_name(&self, thread_id: ThreadId, thread: &mut Thread) {
@@ -4984,6 +5032,56 @@ impl CodexMessageProcessor {
         }
     }
 
+    async fn plugin_install(&self, request_id: ConnectionRequestId, params: PluginInstallParams) {
+        let PluginInstallParams {
+            marketplace_name,
+            plugin_name,
+            cwd,
+        } = params;
+
+        let plugins_manager = self.thread_manager.plugins_manager();
+        let request = PluginInstallRequest {
+            plugin_name,
+            marketplace_name,
+            cwd: cwd.unwrap_or_else(|| self.config.cwd.clone()),
+        };
+
+        match plugins_manager.install_plugin(request).await {
+            Ok(_) => {
+                plugins_manager.clear_cache();
+                self.thread_manager.skills_manager().clear_cache();
+                self.outgoing
+                    .send_response(request_id, PluginInstallResponse {})
+                    .await;
+            }
+            Err(err) => {
+                if err.is_invalid_request() {
+                    self.send_invalid_request_error(request_id, err.to_string())
+                        .await;
+                    return;
+                }
+
+                match err {
+                    CorePluginInstallError::Config(err) => {
+                        self.send_internal_error(
+                            request_id,
+                            format!("failed to persist installed plugin config: {err}"),
+                        )
+                        .await;
+                    }
+                    CorePluginInstallError::Join(err) => {
+                        self.send_internal_error(
+                            request_id,
+                            format!("failed to install plugin: {err}"),
+                        )
+                        .await;
+                    }
+                    CorePluginInstallError::Marketplace(_) | CorePluginInstallError::Store(_) => {}
+                }
+            }
+        }
+    }
+
     async fn turn_start(
         &self,
         request_id: ConnectionRequestId,
@@ -6119,21 +6217,39 @@ impl CodexMessageProcessor {
             WindowsSandboxSetupMode::Unelevated => CoreWindowsSandboxSetupMode::Unelevated,
         };
         let config = Arc::clone(&self.config);
+        let cli_overrides = self.cli_overrides.clone();
+        let cloud_requirements = self.current_cloud_requirements();
+        let command_cwd = params.cwd.unwrap_or_else(|| config.cwd.clone());
         let outgoing = Arc::clone(&self.outgoing);
         let connection_id = request_id.connection_id;
 
         tokio::spawn(async move {
-            let setup_request = WindowsSandboxSetupRequest {
-                mode,
-                policy: config.permissions.sandbox_policy.get().clone(),
-                policy_cwd: config.cwd.clone(),
-                command_cwd: config.cwd.clone(),
-                env_map: std::env::vars().collect(),
-                codex_home: config.codex_home.clone(),
-                active_profile: config.active_profile.clone(),
+            let derived_config = derive_config_for_cwd(
+                &cli_overrides,
+                None,
+                ConfigOverrides {
+                    cwd: Some(command_cwd.clone()),
+                    ..Default::default()
+                },
+                Some(command_cwd.clone()),
+                &cloud_requirements,
+            )
+            .await;
+            let setup_result = match derived_config {
+                Ok(config) => {
+                    let setup_request = WindowsSandboxSetupRequest {
+                        mode,
+                        policy: config.permissions.sandbox_policy.get().clone(),
+                        policy_cwd: config.cwd.clone(),
+                        command_cwd,
+                        env_map: std::env::vars().collect(),
+                        codex_home: config.codex_home.clone(),
+                        active_profile: config.active_profile.clone(),
+                    };
+                    codex_core::windows_sandbox::run_windows_sandbox_setup(setup_request).await
+                }
+                Err(err) => Err(err.into()),
             };
-            let setup_result =
-                codex_core::windows_sandbox::run_windows_sandbox_setup(setup_request).await;
             let notification = WindowsSandboxSetupCompletedNotification {
                 mode: match mode {
                     CoreWindowsSandboxSetupMode::Elevated => WindowsSandboxSetupMode::Elevated,
@@ -6224,29 +6340,26 @@ async fn handle_pending_thread_resume_request(
 
     let request_id = pending.request_id;
     let connection_id = request_id.connection_id;
-    let mut thread = match load_thread_for_running_resume_response(
-        conversation_id,
-        pending.rollout_path.as_path(),
-        pending.config_snapshot.model_provider_id.as_str(),
+    let mut thread = pending.thread_summary;
+    if let Err(message) = populate_resume_turns(
+        &mut thread,
+        ResumeTurnSource::RolloutPath(pending.rollout_path.as_path()),
         active_turn.as_ref(),
     )
     .await
     {
-        Ok(thread) => thread,
-        Err(message) => {
-            outgoing
-                .send_error(
-                    request_id,
-                    JSONRPCErrorError {
-                        code: INTERNAL_ERROR_CODE,
-                        message,
-                        data: None,
-                    },
-                )
-                .await;
-            return;
-        }
-    };
+        outgoing
+            .send_error(
+                request_id,
+                JSONRPCErrorError {
+                    code: INTERNAL_ERROR_CODE,
+                    message,
+                    data: None,
+                },
+            )
+            .await;
+        return;
+    }
 
     has_in_progress_turn = has_in_progress_turn
         || thread
@@ -6296,6 +6409,38 @@ async fn handle_pending_thread_resume_request(
         .await;
 }
 
+enum ResumeTurnSource<'a> {
+    RolloutPath(&'a Path),
+    HistoryItems(&'a [RolloutItem]),
+}
+
+async fn populate_resume_turns(
+    thread: &mut Thread,
+    turn_source: ResumeTurnSource<'_>,
+    active_turn: Option<&Turn>,
+) -> std::result::Result<(), String> {
+    let mut turns = match turn_source {
+        ResumeTurnSource::RolloutPath(rollout_path) => {
+            read_rollout_items_from_rollout(rollout_path)
+                .await
+                .map(|items| build_turns_from_rollout_items(&items))
+                .map_err(|err| {
+                    format!(
+                        "failed to load rollout `{}` for thread {}: {err}",
+                        rollout_path.display(),
+                        thread.id
+                    )
+                })?
+        }
+        ResumeTurnSource::HistoryItems(items) => build_turns_from_rollout_items(items),
+    };
+    if let Some(active_turn) = active_turn {
+        merge_turn_history_with_active_turn(&mut turns, active_turn.clone());
+    }
+    thread.turns = turns;
+    Ok(())
+}
+
 async fn resolve_pending_server_request(
     conversation_id: ThreadId,
     thread_state_manager: &ThreadStateManager,
@@ -6321,38 +6466,6 @@ async fn resolve_pending_server_request(
         .await;
 }
 
-async fn load_thread_for_running_resume_response(
-    conversation_id: ThreadId,
-    rollout_path: &Path,
-    fallback_provider: &str,
-    active_turn: Option<&Turn>,
-) -> std::result::Result<Thread, String> {
-    let mut thread = read_summary_from_rollout(rollout_path, fallback_provider)
-        .await
-        .map(summary_to_thread)
-        .map_err(|err| {
-            format!(
-                "failed to load rollout `{}` for thread {conversation_id}: {err}",
-                rollout_path.display()
-            )
-        })?;
-
-    let mut turns = read_rollout_items_from_rollout(rollout_path)
-        .await
-        .map(|items| build_turns_from_rollout_items(&items))
-        .map_err(|err| {
-            format!(
-                "failed to load rollout `{}` for thread {conversation_id}: {err}",
-                rollout_path.display()
-            )
-        })?;
-    if let Some(active_turn) = active_turn {
-        merge_turn_history_with_active_turn(&mut turns, active_turn.clone());
-    }
-    thread.turns = turns;
-    Ok(thread)
-}
-
 fn merge_turn_history_with_active_turn(turns: &mut Vec<Turn>, active_turn: Turn) {
     turns.retain(|turn| turn.id != active_turn.id);
     turns.push(active_turn);
@@ -6380,6 +6493,14 @@ fn collect_resume_override_mismatches(
             config_snapshot.model_provider_id
         ));
     }
+    if let Some(requested_service_tier) = request.service_tier.as_ref()
+        && requested_service_tier != &config_snapshot.service_tier
+    {
+        mismatch_details.push(format!(
+            "service_tier requested={requested_service_tier:?} active={:?}",
+            config_snapshot.service_tier
+        ));
+    }
     if let Some(requested_cwd) = request.cwd.as_deref() {
         let requested_cwd_path = std::path::PathBuf::from(requested_cwd);
         if requested_cwd_path != config_snapshot.cwd {
@@ -6950,6 +7071,48 @@ fn map_git_info(git_info: &CoreGitInfo) -> ConversationGitInfo {
     }
 }
 
+async fn load_thread_summary_for_rollout(
+    config: &Config,
+    thread_id: ThreadId,
+    rollout_path: &Path,
+    fallback_provider: &str,
+) -> std::result::Result<Thread, String> {
+    let mut thread = read_summary_from_rollout(rollout_path, fallback_provider)
+        .await
+        .map(summary_to_thread)
+        .map_err(|err| {
+            format!(
+                "failed to load rollout `{}` for thread {thread_id}: {err}",
+                rollout_path.display()
+            )
+        })?;
+    if let Some(summary) = read_summary_from_state_db_by_thread_id(config, thread_id).await {
+        merge_mutable_thread_metadata(&mut thread, summary_to_thread(summary));
+    }
+    Ok(thread)
+}
+
+fn merge_mutable_thread_metadata(thread: &mut Thread, persisted_thread: Thread) {
+    thread.git_info = persisted_thread.git_info;
+}
+
+fn preview_from_rollout_items(items: &[RolloutItem]) -> String {
+    items
+        .iter()
+        .find_map(|item| match item {
+            RolloutItem::ResponseItem(item) => match codex_core::parse_turn_item(item) {
+                Some(codex_protocol::items::TurnItem::UserMessage(user)) => Some(user.message()),
+                _ => None,
+            },
+            _ => None,
+        })
+        .map(|preview| match preview.find(USER_MESSAGE_BEGIN) {
+            Some(idx) => preview[idx + USER_MESSAGE_BEGIN.len()..].trim().to_string(),
+            None => preview,
+        })
+        .unwrap_or_default()
+}
+
 fn with_thread_spawn_agent_metadata(
     source: codex_protocol::protocol::SessionSource,
     agent_nickname: Option<String>,
@@ -7104,6 +7267,43 @@ mod tests {
         validate_dynamic_tools(&tools).expect("valid schema");
     }
 
+    #[test]
+    fn collect_resume_override_mismatches_includes_service_tier() {
+        let request = ThreadResumeParams {
+            thread_id: "thread-1".to_string(),
+            history: None,
+            path: None,
+            model: None,
+            model_provider: None,
+            service_tier: Some(Some(codex_protocol::config_types::ServiceTier::Fast)),
+            cwd: None,
+            approval_policy: None,
+            sandbox: None,
+            config: None,
+            base_instructions: None,
+            developer_instructions: None,
+            personality: None,
+            persist_extended_history: false,
+        };
+        let config_snapshot = ThreadConfigSnapshot {
+            model: "gpt-5".to_string(),
+            model_provider_id: "openai".to_string(),
+            service_tier: Some(codex_protocol::config_types::ServiceTier::Flex),
+            approval_policy: codex_protocol::protocol::AskForApproval::OnRequest,
+            sandbox_policy: codex_protocol::protocol::SandboxPolicy::DangerFullAccess,
+            cwd: PathBuf::from("/tmp"),
+            ephemeral: false,
+            reasoning_effort: None,
+            personality: None,
+            session_source: SessionSource::Cli,
+        };
+
+        assert_eq!(
+            collect_resume_override_mismatches(&request, &config_snapshot),
+            vec!["service_tier requested=Some(Fast) active=Some(Flex)".to_string()]
+        );
+    }
+
     #[test]
     fn extract_conversation_summary_prefers_plain_user_messages() -> Result<()> {
         let conversation_id = ThreadId::from_string("3f941c35-29b3-493b-b0a4-e25800d9aeb0")?;

codex-rs/app-server/src/thread_state.rs

@@ -26,6 +26,7 @@ pub(crate) struct PendingThreadResumeRequest {
     pub(crate) request_id: ConnectionRequestId,
     pub(crate) rollout_path: PathBuf,
     pub(crate) config_snapshot: ThreadConfigSnapshot,
+    pub(crate) thread_summary: codex_app_server_protocol::Thread,
 }
 
 // ThreadListenerCommand is used to perform operations in the context of the thread listener, for serialization purposes.

codex-rs/app-server/tests/common/models_cache.rs

@@ -36,6 +36,7 @@ fn preset_to_info(preset: &ModelPreset, priority: i32) -> ModelInfo {
         default_verbosity: None,
         availability_nux: None,
         apply_patch_tool_type: None,
+        web_search_tool_type: Default::default(),
         truncation_policy: TruncationPolicyConfig::bytes(10_000),
         supports_parallel_tool_calls: false,
         supports_image_detail_original: false,

codex-rs/app-server/tests/suite/v2/mcp_server_elicitation.rs

@@ -0,0 +1,477 @@
+use std::borrow::Cow;
+use std::sync::Arc;
+
+use anyhow::Result;
+use app_test_support::ChatGptAuthFixture;
+use app_test_support::McpProcess;
+use app_test_support::to_response;
+use app_test_support::write_chatgpt_auth;
+use axum::Json;
+use axum::Router;
+use axum::extract::State;
+use axum::http::HeaderMap;
+use axum::http::StatusCode;
+use axum::http::Uri;
+use axum::http::header::AUTHORIZATION;
+use axum::routing::get;
+use codex_app_server_protocol::JSONRPCMessage;
+use codex_app_server_protocol::JSONRPCResponse;
+use codex_app_server_protocol::McpServerElicitationAction;
+use codex_app_server_protocol::McpServerElicitationRequest;
+use codex_app_server_protocol::McpServerElicitationRequestParams;
+use codex_app_server_protocol::McpServerElicitationRequestResponse;
+use codex_app_server_protocol::RequestId;
+use codex_app_server_protocol::ServerRequest;
+use codex_app_server_protocol::ServerRequestResolvedNotification;
+use codex_app_server_protocol::ThreadStartParams;
+use codex_app_server_protocol::ThreadStartResponse;
+use codex_app_server_protocol::TurnCompletedNotification;
+use codex_app_server_protocol::TurnStartParams;
+use codex_app_server_protocol::TurnStartResponse;
+use codex_app_server_protocol::TurnStatus;
+use codex_app_server_protocol::UserInput as V2UserInput;
+use codex_core::auth::AuthCredentialsStoreMode;
+use core_test_support::responses;
+use pretty_assertions::assert_eq;
+use rmcp::handler::server::ServerHandler;
+use rmcp::model::BooleanSchema;
+use rmcp::model::CallToolRequestParams;
+use rmcp::model::CallToolResult;
+use rmcp::model::Content;
+use rmcp::model::CreateElicitationRequestParams;
+use rmcp::model::ElicitationAction;
+use rmcp::model::ElicitationSchema;
+use rmcp::model::JsonObject;
+use rmcp::model::ListToolsResult;
+use rmcp::model::Meta;
+use rmcp::model::PrimitiveSchema;
+use rmcp::model::ServerCapabilities;
+use rmcp::model::ServerInfo;
+use rmcp::model::Tool;
+use rmcp::model::ToolAnnotations;
+use rmcp::service::RequestContext;
+use rmcp::service::RoleServer;
+use rmcp::transport::StreamableHttpServerConfig;
+use rmcp::transport::StreamableHttpService;
+use rmcp::transport::streamable_http_server::session::local::LocalSessionManager;
+use serde_json::Value;
+use serde_json::json;
+use tempfile::TempDir;
+use tokio::net::TcpListener;
+use tokio::task::JoinHandle;
+use tokio::time::timeout;
+
+const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
+const CONNECTOR_ID: &str = "calendar";
+const CONNECTOR_NAME: &str = "Calendar";
+const TOOL_NAME: &str = "calendar_confirm_action";
+const QUALIFIED_TOOL_NAME: &str = "mcp__codex_apps__calendar_confirm_action";
+const TOOL_CALL_ID: &str = "call-calendar-confirm";
+const ELICITATION_MESSAGE: &str = "Allow this request?";
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn mcp_server_elicitation_round_trip() -> Result<()> {
+    let responses_server = responses::start_mock_server().await;
+    let tool_call_arguments = serde_json::to_string(&json!({}))?;
+    let response_mock = responses::mount_sse_sequence(
+        &responses_server,
+        vec![
+            responses::sse(vec![
+                responses::ev_response_created("resp-0"),
+                responses::ev_assistant_message("msg-0", "Warmup"),
+                responses::ev_completed("resp-0"),
+            ]),
+            responses::sse(vec![
+                responses::ev_response_created("resp-1"),
+                responses::ev_function_call(
+                    TOOL_CALL_ID,
+                    QUALIFIED_TOOL_NAME,
+                    &tool_call_arguments,
+                ),
+                responses::ev_completed("resp-1"),
+            ]),
+            responses::sse(vec![
+                responses::ev_response_created("resp-2"),
+                responses::ev_assistant_message("msg-1", "Done"),
+                responses::ev_completed("resp-2"),
+            ]),
+        ],
+    )
+    .await;
+
+    let (apps_server_url, apps_server_handle) = start_apps_server().await?;
+
+    let codex_home = TempDir::new()?;
+    write_config_toml(codex_home.path(), &responses_server.uri(), &apps_server_url)?;
+    write_chatgpt_auth(
+        codex_home.path(),
+        ChatGptAuthFixture::new("chatgpt-token")
+            .account_id("account-123")
+            .chatgpt_user_id("user-123")
+            .chatgpt_account_id("account-123"),
+        AuthCredentialsStoreMode::File,
+    )?;
+
+    let mut mcp = McpProcess::new(codex_home.path()).await?;
+    timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
+
+    let thread_start_id = mcp
+        .send_thread_start_request(ThreadStartParams {
+            model: Some("mock-model".to_string()),
+            ..Default::default()
+        })
+        .await?;
+    let thread_start_resp: JSONRPCResponse = timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_response_message(RequestId::Integer(thread_start_id)),
+    )
+    .await??;
+    let ThreadStartResponse { thread, .. } = to_response(thread_start_resp)?;
+
+    let warmup_turn_start_id = mcp
+        .send_turn_start_request(TurnStartParams {
+            thread_id: thread.id.clone(),
+            input: vec![V2UserInput::Text {
+                text: "Warm up connectors.".to_string(),
+                text_elements: Vec::new(),
+            }],
+            model: Some("mock-model".to_string()),
+            ..Default::default()
+        })
+        .await?;
+    let warmup_turn_start_resp: JSONRPCResponse = timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_response_message(RequestId::Integer(warmup_turn_start_id)),
+    )
+    .await??;
+    let _: TurnStartResponse = to_response(warmup_turn_start_resp)?;
+
+    let warmup_completed = timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_notification_message("turn/completed"),
+    )
+    .await??;
+    let warmup_completed: TurnCompletedNotification = serde_json::from_value(
+        warmup_completed
+            .params
+            .clone()
+            .expect("warmup turn/completed params"),
+    )?;
+    assert_eq!(warmup_completed.thread_id, thread.id);
+    assert_eq!(warmup_completed.turn.status, TurnStatus::Completed);
+
+    let turn_start_id = mcp
+        .send_turn_start_request(TurnStartParams {
+            thread_id: thread.id.clone(),
+            input: vec![V2UserInput::Text {
+                text: "Use [$calendar](app://calendar) to run the calendar tool.".to_string(),
+                text_elements: Vec::new(),
+            }],
+            model: Some("mock-model".to_string()),
+            ..Default::default()
+        })
+        .await?;
+    let turn_start_resp: JSONRPCResponse = timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_response_message(RequestId::Integer(turn_start_id)),
+    )
+    .await??;
+    let TurnStartResponse { turn } = to_response(turn_start_resp)?;
+
+    let server_req = timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_request_message(),
+    )
+    .await??;
+    let ServerRequest::McpServerElicitationRequest { request_id, params } = server_req else {
+        panic!("expected McpServerElicitationRequest request, got: {server_req:?}");
+    };
+    let requested_schema = serde_json::to_value(
+        ElicitationSchema::builder()
+            .required_property("confirmed", PrimitiveSchema::Boolean(BooleanSchema::new()))
+            .build()
+            .map_err(anyhow::Error::msg)?,
+    )?;
+
+    assert_eq!(
+        params,
+        McpServerElicitationRequestParams {
+            thread_id: thread.id.clone(),
+            turn_id: Some(turn.id.clone()),
+            server_name: "codex_apps".to_string(),
+            request: McpServerElicitationRequest::Form {
+                message: ELICITATION_MESSAGE.to_string(),
+                requested_schema,
+            },
+        }
+    );
+
+    let resolved_request_id = request_id.clone();
+    mcp.send_response(
+        request_id,
+        serde_json::to_value(McpServerElicitationRequestResponse {
+            action: McpServerElicitationAction::Accept,
+            content: Some(json!({
+                "confirmed": true,
+            })),
+        })?,
+    )
+    .await?;
+
+    let mut saw_resolved = false;
+    loop {
+        let message = timeout(DEFAULT_READ_TIMEOUT, mcp.read_next_message()).await??;
+        let JSONRPCMessage::Notification(notification) = message else {
+            continue;
+        };
+
+        match notification.method.as_str() {
+            "serverRequest/resolved" => {
+                let resolved: ServerRequestResolvedNotification = serde_json::from_value(
+                    notification
+                        .params
+                        .clone()
+                        .expect("serverRequest/resolved params"),
+                )?;
+                assert_eq!(
+                    resolved,
+                    ServerRequestResolvedNotification {
+                        thread_id: thread.id.clone(),
+                        request_id: resolved_request_id.clone(),
+                    }
+                );
+                saw_resolved = true;
+            }
+            "turn/completed" => {
+                let completed: TurnCompletedNotification = serde_json::from_value(
+                    notification.params.clone().expect("turn/completed params"),
+                )?;
+                assert!(saw_resolved, "serverRequest/resolved should arrive first");
+                assert_eq!(completed.thread_id, thread.id);
+                assert_eq!(completed.turn.id, turn.id);
+                assert_eq!(completed.turn.status, TurnStatus::Completed);
+                break;
+            }
+            _ => {}
+        }
+    }
+
+    let requests = response_mock.requests();
+    assert_eq!(requests.len(), 3);
+    let function_call_output = requests[2].function_call_output(TOOL_CALL_ID);
+    assert_eq!(
+        function_call_output.get("type"),
+        Some(&Value::String("function_call_output".to_string()))
+    );
+    assert_eq!(
+        function_call_output.get("call_id"),
+        Some(&Value::String(TOOL_CALL_ID.to_string()))
+    );
+    let output = function_call_output
+        .get("output")
+        .and_then(Value::as_str)
+        .expect("function_call_output output should be a JSON string");
+    assert_eq!(
+        serde_json::from_str::<Value>(output)?,
+        json!([{
+            "type": "text",
+            "text": "accepted"
+        }])
+    );
+
+    apps_server_handle.abort();
+    let _ = apps_server_handle.await;
+    Ok(())
+}
+
+#[derive(Clone)]
+struct AppsServerState {
+    expected_bearer: String,
+    expected_account_id: String,
+}
+
+#[derive(Clone, Default)]
+struct ElicitationAppsMcpServer;
+
+impl ServerHandler for ElicitationAppsMcpServer {
+    fn get_info(&self) -> ServerInfo {
+        ServerInfo {
+            protocol_version: rmcp::model::ProtocolVersion::V_2025_06_18,
+            capabilities: ServerCapabilities::builder().enable_tools().build(),
+            ..ServerInfo::default()
+        }
+    }
+
+    async fn list_tools(
+        &self,
+        _request: Option<rmcp::model::PaginatedRequestParams>,
+        _context: RequestContext<RoleServer>,
+    ) -> Result<ListToolsResult, rmcp::ErrorData> {
+        let input_schema: JsonObject = serde_json::from_value(json!({
+            "type": "object",
+            "additionalProperties": false
+        }))
+        .map_err(|err| rmcp::ErrorData::internal_error(err.to_string(), None))?;
+
+        let mut tool = Tool::new(
+            Cow::Borrowed(TOOL_NAME),
+            Cow::Borrowed("Confirm a calendar action."),
+            Arc::new(input_schema),
+        );
+        tool.annotations = Some(ToolAnnotations::new().read_only(true));
+
+        let mut meta = Meta::new();
+        meta.0
+            .insert("connector_id".to_string(), json!(CONNECTOR_ID));
+        meta.0
+            .insert("connector_name".to_string(), json!(CONNECTOR_NAME));
+        tool.meta = Some(meta);
+
+        Ok(ListToolsResult {
+            tools: vec![tool],
+            next_cursor: None,
+            meta: None,
+        })
+    }
+
+    async fn call_tool(
+        &self,
+        _request: CallToolRequestParams,
+        context: RequestContext<RoleServer>,
+    ) -> Result<CallToolResult, rmcp::ErrorData> {
+        let requested_schema = ElicitationSchema::builder()
+            .required_property("confirmed", PrimitiveSchema::Boolean(BooleanSchema::new()))
+            .build()
+            .map_err(|err| rmcp::ErrorData::internal_error(err.to_string(), None))?;
+
+        let result = context
+            .peer
+            .create_elicitation(CreateElicitationRequestParams::FormElicitationParams {
+                meta: None,
+                message: ELICITATION_MESSAGE.to_string(),
+                requested_schema,
+            })
+            .await
+            .map_err(|err| rmcp::ErrorData::internal_error(err.to_string(), None))?;
+
+        let output = match result.action {
+            ElicitationAction::Accept => {
+                assert_eq!(
+                    result.content,
+                    Some(json!({
+                        "confirmed": true,
+                    }))
+                );
+                "accepted"
+            }
+            ElicitationAction::Decline => "declined",
+            ElicitationAction::Cancel => "cancelled",
+        };
+
+        Ok(CallToolResult::success(vec![Content::text(output)]))
+    }
+}
+
+async fn start_apps_server() -> Result<(String, JoinHandle<()>)> {
+    let state = Arc::new(AppsServerState {
+        expected_bearer: "Bearer chatgpt-token".to_string(),
+        expected_account_id: "account-123".to_string(),
+    });
+
+    let listener = TcpListener::bind("127.0.0.1:0").await?;
+    let addr = listener.local_addr()?;
+
+    let mcp_service = StreamableHttpService::new(
+        move || Ok(ElicitationAppsMcpServer),
+        Arc::new(LocalSessionManager::default()),
+        StreamableHttpServerConfig::default(),
+    );
+
+    let router = Router::new()
+        .route("/connectors/directory/list", get(list_directory_connectors))
+        .route(
+            "/connectors/directory/list_workspace",
+            get(list_directory_connectors),
+        )
+        .with_state(state)
+        .nest_service("/api/codex/apps", mcp_service);
+
+    let handle = tokio::spawn(async move {
+        let _ = axum::serve(listener, router).await;
+    });
+
+    Ok((format!("http://{addr}"), handle))
+}
+
+async fn list_directory_connectors(
+    State(state): State<Arc<AppsServerState>>,
+    headers: HeaderMap,
+    uri: Uri,
+) -> Result<Json<serde_json::Value>, StatusCode> {
+    let bearer_ok = headers
+        .get(AUTHORIZATION)
+        .and_then(|value| value.to_str().ok())
+        .is_some_and(|value| value == state.expected_bearer);
+    let account_ok = headers
+        .get("chatgpt-account-id")
+        .and_then(|value| value.to_str().ok())
+        .is_some_and(|value| value == state.expected_account_id);
+    let external_logos_ok = uri
+        .query()
+        .is_some_and(|query| query.split('&').any(|pair| pair == "external_logos=true"));
+
+    if !bearer_ok || !account_ok {
+        Err(StatusCode::UNAUTHORIZED)
+    } else if !external_logos_ok {
+        Err(StatusCode::BAD_REQUEST)
+    } else {
+        Ok(Json(json!({
+            "apps": [{
+                "id": CONNECTOR_ID,
+                "name": CONNECTOR_NAME,
+                "description": "Calendar connector",
+                "logo_url": null,
+                "logo_url_dark": null,
+                "distribution_channel": null,
+                "branding": null,
+                "app_metadata": null,
+                "labels": null,
+                "install_url": null,
+                "is_accessible": false,
+                "is_enabled": true
+            }],
+            "next_token": null
+        })))
+    }
+}
+
+fn write_config_toml(
+    codex_home: &std::path::Path,
+    responses_server_uri: &str,
+    apps_server_url: &str,
+) -> std::io::Result<()> {
+    std::fs::write(
+        codex_home.join("config.toml"),
+        format!(
+            r#"
+model = "mock-model"
+approval_policy = "untrusted"
+sandbox_mode = "read-only"
+
+model_provider = "mock_provider"
+chatgpt_base_url = "{apps_server_url}"
+mcp_oauth_credentials_store = "file"
+
+[features]
+apps = true
+
+[model_providers.mock_provider]
+name = "Mock provider for test"
+base_url = "{responses_server_uri}/v1"
+wire_api = "responses"
+request_max_retries = 0
+stream_max_retries = 0
+"#
+        ),
+    )
+}

codex-rs/app-server/tests/suite/v2/mod.rs

@@ -11,6 +11,7 @@ mod dynamic_tools;
 mod experimental_api;
 mod experimental_feature_list;
 mod initialize;
+mod mcp_server_elicitation;
 mod model_list;
 mod output_schema;
 mod plan_item;

codex-rs/app-server/tests/suite/v2/thread_resume.rs

@@ -23,6 +23,8 @@ use codex_app_server_protocol::RequestId;
 use codex_app_server_protocol::ServerRequest;
 use codex_app_server_protocol::SessionSource;
 use codex_app_server_protocol::ThreadItem;
+use codex_app_server_protocol::ThreadMetadataGitInfoUpdateParams;
+use codex_app_server_protocol::ThreadMetadataUpdateParams;
 use codex_app_server_protocol::ThreadResumeParams;
 use codex_app_server_protocol::ThreadResumeResponse;
 use codex_app_server_protocol::ThreadStartParams;
@@ -32,19 +34,27 @@ use codex_app_server_protocol::TurnStartParams;
 use codex_app_server_protocol::TurnStartResponse;
 use codex_app_server_protocol::TurnStatus;
 use codex_app_server_protocol::UserInput;
+use codex_protocol::ThreadId;
 use codex_protocol::config_types::Personality;
 use codex_protocol::models::ContentItem;
 use codex_protocol::models::ResponseItem;
+use codex_protocol::protocol::SessionMeta;
+use codex_protocol::protocol::SessionMetaLine;
+use codex_protocol::protocol::SessionSource as RolloutSessionSource;
 use codex_protocol::user_input::ByteRange;
 use codex_protocol::user_input::TextElement;
+use codex_state::StateRuntime;
 use core_test_support::responses;
 use core_test_support::skip_if_no_network;
 use pretty_assertions::assert_eq;
+use serde_json::json;
 use std::fs::FileTimes;
 use std::path::Path;
 use std::path::PathBuf;
+use std::process::Command;
 use tempfile::TempDir;
 use tokio::time::timeout;
+use uuid::Uuid;
 
 const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
 const CODEX_5_2_INSTRUCTIONS_TEMPLATE_DEFAULT: &str = "You are Codex, a coding agent based on GPT-5. You and the user share the same workspace and collaborate to achieve the user's goals.";
@@ -170,6 +180,198 @@ async fn thread_resume_returns_rollout_history() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn thread_resume_prefers_persisted_git_metadata_for_local_threads() -> Result<()> {
+    let server = create_mock_responses_server_repeating_assistant("Done").await;
+    let codex_home = TempDir::new()?;
+    let config_toml = codex_home.path().join("config.toml");
+    std::fs::write(
+        &config_toml,
+        format!(
+            r#"
+model = "gpt-5.2-codex"
+approval_policy = "never"
+sandbox_mode = "read-only"
+
+model_provider = "mock_provider"
+
+[features]
+personality = true
+sqlite = true
+
+[model_providers.mock_provider]
+name = "Mock provider for test"
+base_url = "{}/v1"
+wire_api = "responses"
+request_max_retries = 0
+stream_max_retries = 0
+"#,
+            server.uri()
+        ),
+    )?;
+
+    let repo_path = codex_home.path().join("repo");
+    std::fs::create_dir_all(&repo_path)?;
+    assert!(
+        Command::new("git")
+            .args(["init"])
+            .arg(&repo_path)
+            .status()?
+            .success()
+    );
+    assert!(
+        Command::new("git")
+            .current_dir(&repo_path)
+            .args(["checkout", "-B", "master"])
+            .status()?
+            .success()
+    );
+    assert!(
+        Command::new("git")
+            .current_dir(&repo_path)
+            .args(["config", "user.name", "Test User"])
+            .status()?
+            .success()
+    );
+    assert!(
+        Command::new("git")
+            .current_dir(&repo_path)
+            .args(["config", "user.email", "test@example.com"])
+            .status()?
+            .success()
+    );
+    std::fs::write(repo_path.join("README.md"), "test\n")?;
+    assert!(
+        Command::new("git")
+            .current_dir(&repo_path)
+            .args(["add", "README.md"])
+            .status()?
+            .success()
+    );
+    assert!(
+        Command::new("git")
+            .current_dir(&repo_path)
+            .args(["commit", "-m", "initial"])
+            .status()?
+            .success()
+    );
+    let head_branch = Command::new("git")
+        .current_dir(&repo_path)
+        .args(["branch", "--show-current"])
+        .output()?;
+    assert_eq!(
+        String::from_utf8(head_branch.stdout)?.trim(),
+        "master",
+        "test repo should stay on master to verify resume ignores live HEAD"
+    );
+
+    let thread_id = Uuid::new_v4().to_string();
+    let conversation_id = ThreadId::from_string(&thread_id)?;
+    let rollout_path = rollout_path(codex_home.path(), "2025-01-05T12-00-00", &thread_id);
+    let rollout_dir = rollout_path.parent().expect("rollout parent directory");
+    std::fs::create_dir_all(rollout_dir)?;
+    let session_meta = SessionMeta {
+        id: conversation_id,
+        forked_from_id: None,
+        timestamp: "2025-01-05T12:00:00Z".to_string(),
+        cwd: repo_path.clone(),
+        originator: "codex".to_string(),
+        cli_version: "0.0.0".to_string(),
+        source: RolloutSessionSource::Cli,
+        agent_nickname: None,
+        agent_role: None,
+        model_provider: Some("mock_provider".to_string()),
+        base_instructions: None,
+        dynamic_tools: None,
+        memory_mode: None,
+    };
+    std::fs::write(
+        &rollout_path,
+        [
+            json!({
+                "timestamp": "2025-01-05T12:00:00Z",
+                "type": "session_meta",
+                "payload": serde_json::to_value(SessionMetaLine {
+                    meta: session_meta,
+                    git: None,
+                })?,
+            })
+            .to_string(),
+            json!({
+                "timestamp": "2025-01-05T12:00:00Z",
+                "type": "response_item",
+                "payload": {
+                    "type": "message",
+                    "role": "user",
+                    "content": [{"type": "input_text", "text": "Saved user message"}]
+                }
+            })
+            .to_string(),
+            json!({
+                "timestamp": "2025-01-05T12:00:00Z",
+                "type": "event_msg",
+                "payload": {
+                    "type": "user_message",
+                    "message": "Saved user message",
+                    "kind": "plain"
+                }
+            })
+            .to_string(),
+        ]
+        .join("\n")
+            + "\n",
+    )?;
+    let state_db = StateRuntime::init(
+        codex_home.path().to_path_buf(),
+        "mock_provider".into(),
+        None,
+    )
+    .await?;
+    state_db.mark_backfill_complete(None).await?;
+
+    let mut mcp = McpProcess::new(codex_home.path()).await?;
+    timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
+
+    let update_id = mcp
+        .send_thread_metadata_update_request(ThreadMetadataUpdateParams {
+            thread_id: thread_id.clone(),
+            git_info: Some(ThreadMetadataGitInfoUpdateParams {
+                sha: None,
+                branch: Some(Some("feature/pr-branch".to_string())),
+                origin_url: None,
+            }),
+        })
+        .await?;
+    timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_response_message(RequestId::Integer(update_id)),
+    )
+    .await??;
+
+    let resume_id = mcp
+        .send_thread_resume_request(ThreadResumeParams {
+            thread_id,
+            ..Default::default()
+        })
+        .await?;
+    let resume_resp: JSONRPCResponse = timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_response_message(RequestId::Integer(resume_id)),
+    )
+    .await??;
+    let ThreadResumeResponse { thread, .. } = to_response::<ThreadResumeResponse>(resume_resp)?;
+
+    assert_eq!(
+        thread
+            .git_info
+            .as_ref()
+            .and_then(|git| git.branch.as_deref()),
+        Some("feature/pr-branch")
+    );
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn thread_resume_without_overrides_does_not_change_updated_at_or_mtime() -> Result<()> {
     let server = create_mock_responses_server_repeating_assistant("Done").await;

codex-rs/app-server/tests/suite/v2/thread_start.rs

@@ -12,6 +12,7 @@ use codex_app_server_protocol::ThreadStartedNotification;
 use codex_app_server_protocol::ThreadStatus;
 use codex_app_server_protocol::ThreadStatusChangedNotification;
 use codex_core::config::set_project_trust_level;
+use codex_protocol::config_types::ServiceTier;
 use codex_protocol::config_types::TrustLevel;
 use codex_protocol::openai_models::ReasoningEffort;
 use pretty_assertions::assert_eq;
@@ -180,6 +181,34 @@ model_reasoning_effort = "high"
     Ok(())
 }
 
+#[tokio::test]
+async fn thread_start_accepts_flex_service_tier() -> Result<()> {
+    let server = create_mock_responses_server_repeating_assistant("Done").await;
+
+    let codex_home = TempDir::new()?;
+    create_config_toml(codex_home.path(), &server.uri())?;
+
+    let mut mcp = McpProcess::new(codex_home.path()).await?;
+    timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
+
+    let req_id = mcp
+        .send_thread_start_request(ThreadStartParams {
+            service_tier: Some(Some(ServiceTier::Flex)),
+            ..Default::default()
+        })
+        .await?;
+
+    let resp: JSONRPCResponse = timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_response_message(RequestId::Integer(req_id)),
+    )
+    .await??;
+    let ThreadStartResponse { service_tier, .. } = to_response::<ThreadStartResponse>(resp)?;
+
+    assert_eq!(service_tier, Some(ServiceTier::Flex));
+    Ok(())
+}
+
 #[tokio::test]
 async fn thread_start_accepts_metrics_service_name() -> Result<()> {
     let server = create_mock_responses_server_repeating_assistant("Done").await;

codex-rs/app-server/tests/suite/v2/windows_sandbox_setup.rs

@@ -37,6 +37,7 @@ async fn windows_sandbox_setup_start_emits_completion_notification() -> Result<(
     let request_id = mcp
         .send_windows_sandbox_setup_start_request(WindowsSandboxSetupStartParams {
             mode: WindowsSandboxSetupMode::Unelevated,
+            cwd: None,
         })
         .await?;
     let response: JSONRPCResponse = timeout(

codex-rs/artifact-presentation/BUILD.bazel

@@ -1,6 +0,0 @@
-load("//:defs.bzl", "codex_rust_crate")
-
-codex_rust_crate(
-    name = "artifact-presentation",
-    crate_name = "codex_artifact_presentation",
-)

codex-rs/artifact-presentation/Cargo.toml

@@ -1,28 +0,0 @@
-[package]
-name = "codex-artifact-presentation"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-
-[lib]
-name = "codex_artifact_presentation"
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-base64 = { workspace = true }
-image = { workspace = true, features = ["jpeg", "png"] }
-ppt-rs = { workspace = true }
-reqwest = { workspace = true, features = ["blocking"] }
-serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
-thiserror = { workspace = true }
-uuid = { workspace = true, features = ["v4"] }
-zip = { workspace = true }
-
-[dev-dependencies]
-pretty_assertions = { workspace = true }
-tempfile = { workspace = true }
-tiny_http = { workspace = true }

codex-rs/artifact-presentation/src/lib.rs

@@ -1,6 +0,0 @@
-mod presentation_artifact;
-
-#[cfg(test)]
-mod tests;
-
-pub use presentation_artifact::*;

codex-rs/artifact-presentation/src/presentation_artifact/api.rs

@@ -1,249 +0,0 @@
-use base64::Engine;
-use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
-use image::GenericImageView;
-use image::ImageFormat;
-use image::codecs::jpeg::JpegEncoder;
-use image::imageops::FilterType;
-use ppt_rs::Chart;
-use ppt_rs::ChartSeries;
-use ppt_rs::ChartType;
-use ppt_rs::Hyperlink as PptHyperlink;
-use ppt_rs::HyperlinkAction as PptHyperlinkAction;
-use ppt_rs::Image;
-use ppt_rs::Presentation;
-use ppt_rs::Shape;
-use ppt_rs::ShapeFill;
-use ppt_rs::ShapeLine;
-use ppt_rs::ShapeType;
-use ppt_rs::SlideContent;
-use ppt_rs::SlideLayout;
-use ppt_rs::TableBuilder;
-use ppt_rs::TableCell;
-use ppt_rs::TableRow;
-use ppt_rs::generator::ArrowSize;
-use ppt_rs::generator::ArrowType;
-use ppt_rs::generator::CellAlign;
-use ppt_rs::generator::Connector;
-use ppt_rs::generator::ConnectorLine;
-use ppt_rs::generator::ConnectorType;
-use ppt_rs::generator::LineDash;
-use ppt_rs::generator::generate_image_content_type;
-use serde::Deserialize;
-use serde::Serialize;
-use serde_json::Value;
-use std::collections::BTreeSet;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::io::Cursor;
-use std::io::Read;
-use std::io::Seek;
-use std::io::Write;
-use std::path::Path;
-use std::path::PathBuf;
-use std::process::Command;
-use thiserror::Error;
-use uuid::Uuid;
-use zip::ZipArchive;
-use zip::ZipWriter;
-use zip::write::SimpleFileOptions;
-
-const POINT_TO_EMU: u32 = 12_700;
-const DEFAULT_SLIDE_WIDTH_POINTS: u32 = 720;
-const DEFAULT_SLIDE_HEIGHT_POINTS: u32 = 540;
-const DEFAULT_IMPORTED_TITLE_LEFT: u32 = 36;
-const DEFAULT_IMPORTED_TITLE_TOP: u32 = 24;
-const DEFAULT_IMPORTED_TITLE_WIDTH: u32 = 648;
-const DEFAULT_IMPORTED_TITLE_HEIGHT: u32 = 48;
-const DEFAULT_IMPORTED_CONTENT_LEFT: u32 = 48;
-const DEFAULT_IMPORTED_CONTENT_TOP: u32 = 96;
-const DEFAULT_IMPORTED_CONTENT_WIDTH: u32 = 624;
-const DEFAULT_IMPORTED_CONTENT_HEIGHT: u32 = 324;
-
-#[derive(Debug, Error)]
-pub enum PresentationArtifactError {
-    #[error("missing `artifact_id` for action `{action}`")]
-    MissingArtifactId { action: String },
-    #[error("unknown artifact id `{artifact_id}` for action `{action}`")]
-    UnknownArtifactId { action: String, artifact_id: String },
-    #[error("unknown action `{0}`")]
-    UnknownAction(String),
-    #[error("invalid args for action `{action}`: {message}")]
-    InvalidArgs { action: String, message: String },
-    #[error("unsupported feature for action `{action}`: {message}")]
-    UnsupportedFeature { action: String, message: String },
-    #[error("failed to import PPTX `{path}`: {message}")]
-    ImportFailed { path: PathBuf, message: String },
-    #[error("failed to export PPTX `{path}`: {message}")]
-    ExportFailed { path: PathBuf, message: String },
-}
-
-#[derive(Debug, Clone, Deserialize)]
-pub struct PresentationArtifactRequest {
-    pub artifact_id: Option<String>,
-    pub action: String,
-    #[serde(default)]
-    pub args: Value,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct PresentationArtifactToolRequest {
-    pub artifact_id: Option<String>,
-    pub actions: Vec<PresentationArtifactToolAction>,
-}
-
-#[derive(Debug, Clone)]
-pub struct PresentationArtifactExecutionRequest {
-    pub artifact_id: Option<String>,
-    pub requests: Vec<PresentationArtifactRequest>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct PresentationArtifactToolAction {
-    pub action: String,
-    #[serde(default)]
-    pub args: Value,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum PathAccessKind {
-    Read,
-    Write,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct PathAccessRequirement {
-    pub action: String,
-    pub kind: PathAccessKind,
-    pub path: PathBuf,
-}
-
-impl PresentationArtifactRequest {
-    pub fn is_mutating(&self) -> bool {
-        !is_read_only_action(&self.action)
-    }
-
-    pub fn required_path_accesses(
-        &self,
-        cwd: &Path,
-    ) -> Result<Vec<PathAccessRequirement>, PresentationArtifactError> {
-        let access = match self.action.as_str() {
-            "import_pptx" => {
-                let args: ImportPptxArgs = parse_args(&self.action, &self.args)?;
-                vec![PathAccessRequirement {
-                    action: self.action.clone(),
-                    kind: PathAccessKind::Read,
-                    path: resolve_path(cwd, &args.path),
-                }]
-            }
-            "export_pptx" => {
-                let args: ExportPptxArgs = parse_args(&self.action, &self.args)?;
-                vec![PathAccessRequirement {
-                    action: self.action.clone(),
-                    kind: PathAccessKind::Write,
-                    path: resolve_path(cwd, &args.path),
-                }]
-            }
-            "export_preview" => {
-                let args: ExportPreviewArgs = parse_args(&self.action, &self.args)?;
-                vec![PathAccessRequirement {
-                    action: self.action.clone(),
-                    kind: PathAccessKind::Write,
-                    path: resolve_path(cwd, &args.path),
-                }]
-            }
-            "add_image" => {
-                let args: AddImageArgs = parse_args(&self.action, &self.args)?;
-                match args.image_source()? {
-                    ImageInputSource::Path(path) => vec![PathAccessRequirement {
-                        action: self.action.clone(),
-                        kind: PathAccessKind::Read,
-                        path: resolve_path(cwd, &path),
-                    }],
-                    ImageInputSource::DataUrl(_)
-                    | ImageInputSource::Blob(_)
-                    | ImageInputSource::Uri(_)
-                    | ImageInputSource::Placeholder => Vec::new(),
-                }
-            }
-            "replace_image" => {
-                let args: ReplaceImageArgs = parse_args(&self.action, &self.args)?;
-                match (
-                    &args.path,
-                    &args.data_url,
-                    &args.blob,
-                    &args.uri,
-                    &args.prompt,
-                ) {
-                    (Some(path), None, None, None, None) => vec![PathAccessRequirement {
-                        action: self.action.clone(),
-                        kind: PathAccessKind::Read,
-                        path: resolve_path(cwd, path),
-                    }],
-                    (None, Some(_), None, None, None)
-                    | (None, None, Some(_), None, None)
-                    | (None, None, None, Some(_), None)
-                    | (None, None, None, None, Some(_)) => Vec::new(),
-                    _ => {
-                        return Err(PresentationArtifactError::InvalidArgs {
-                            action: self.action.clone(),
-                            message:
-                                "provide exactly one of `path`, `data_url`, `blob`, or `uri`, or provide `prompt` for a placeholder image"
-                                    .to_string(),
-                        });
-                    }
-                }
-            }
-            _ => Vec::new(),
-        };
-        Ok(access)
-    }
-}
-
-impl PresentationArtifactToolRequest {
-    pub fn is_mutating(&self) -> Result<bool, PresentationArtifactError> {
-        Ok(self.actions.iter().any(|request| !is_read_only_action(&request.action)))
-    }
-
-    pub fn into_execution_request(
-        self,
-    ) -> Result<PresentationArtifactExecutionRequest, PresentationArtifactError> {
-        if self.actions.is_empty() {
-            return Err(PresentationArtifactError::InvalidArgs {
-                action: "presentation_artifact".to_string(),
-                message: "`actions` must contain at least one item".to_string(),
-            });
-        }
-        Ok(PresentationArtifactExecutionRequest {
-            artifact_id: self.artifact_id,
-            requests: self
-                .actions
-                .into_iter()
-                .map(|request| PresentationArtifactRequest {
-                    artifact_id: None,
-                    action: request.action,
-                    args: request.args,
-                })
-                .collect(),
-        })
-    }
-
-    pub fn required_path_accesses(
-        &self,
-        cwd: &Path,
-    ) -> Result<Vec<PathAccessRequirement>, PresentationArtifactError> {
-        let mut accesses = Vec::new();
-        for request in &self.actions {
-            accesses.extend(
-                PresentationArtifactRequest {
-                    artifact_id: None,
-                    action: request.action.clone(),
-                    args: request.args.clone(),
-                }
-                .required_path_accesses(cwd)?,
-            );
-        }
-        Ok(accesses)
-    }
-}

codex-rs/artifact-presentation/src/presentation_artifact/args.rs

@@ -1,729 +0,0 @@
-#[derive(Debug, Deserialize)]
-struct CreateArgs {
-    name: Option<String>,
-    slide_size: Option<Value>,
-    theme: Option<ThemeArgs>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ImportPptxArgs {
-    path: PathBuf,
-}
-
-#[derive(Debug, Deserialize)]
-struct ExportPptxArgs {
-    path: PathBuf,
-}
-
-#[derive(Debug, Deserialize)]
-struct ExportPreviewArgs {
-    path: PathBuf,
-    slide_index: Option<u32>,
-    format: Option<String>,
-    scale: Option<f32>,
-    quality: Option<u8>,
-}
-
-#[derive(Debug, Default, Deserialize)]
-struct AddSlideArgs {
-    layout: Option<String>,
-    notes: Option<String>,
-    background_fill: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct CreateLayoutArgs {
-    name: String,
-    kind: Option<String>,
-    parent_layout_id: Option<String>,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum PreviewOutputFormat {
-    Png,
-    Jpeg,
-    Svg,
-}
-
-impl PreviewOutputFormat {
-    fn extension(self) -> &'static str {
-        match self {
-            Self::Png => "png",
-            Self::Jpeg => "jpg",
-            Self::Svg => "svg",
-        }
-    }
-}
-
-#[derive(Debug, Deserialize)]
-struct AddLayoutPlaceholderArgs {
-    layout_id: String,
-    name: String,
-    placeholder_type: String,
-    index: Option<u32>,
-    text: Option<String>,
-    geometry: Option<String>,
-    position: Option<PositionArgs>,
-}
-
-#[derive(Debug, Deserialize)]
-struct LayoutIdArgs {
-    layout_id: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct SetSlideLayoutArgs {
-    slide_index: u32,
-    layout_id: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct UpdatePlaceholderTextArgs {
-    slide_index: u32,
-    name: String,
-    text: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct NotesArgs {
-    slide_index: u32,
-    text: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct NotesVisibilityArgs {
-    slide_index: u32,
-    visible: bool,
-}
-
-#[derive(Debug, Deserialize)]
-struct ThemeArgs {
-    color_scheme: HashMap<String, String>,
-    major_font: Option<String>,
-    minor_font: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct StyleNameArgs {
-    name: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct AddStyleArgs {
-    name: String,
-    #[serde(flatten)]
-    styling: TextStylingArgs,
-}
-
-#[derive(Debug, Deserialize)]
-struct InspectArgs {
-    kind: Option<String>,
-    include: Option<String>,
-    exclude: Option<String>,
-    search: Option<String>,
-    target_id: Option<String>,
-    target: Option<InspectTargetArgs>,
-    max_chars: Option<usize>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct InspectTargetArgs {
-    id: String,
-    before_lines: Option<usize>,
-    after_lines: Option<usize>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ResolveArgs {
-    id: String,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct PatchOperationInput {
-    artifact_id: Option<String>,
-    action: String,
-    #[serde(default)]
-    args: Value,
-}
-
-#[derive(Debug, Deserialize)]
-struct RecordPatchArgs {
-    operations: Vec<PatchOperationInput>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ApplyPatchArgs {
-    operations: Option<Vec<PatchOperationInput>>,
-    patch: Option<PresentationPatch>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct PresentationPatch {
-    version: u32,
-    artifact_id: String,
-    operations: Vec<PatchOperation>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-struct PatchOperation {
-    action: String,
-    #[serde(default)]
-    args: Value,
-}
-
-#[derive(Debug, Default, Deserialize)]
-struct InsertSlideArgs {
-    index: Option<u32>,
-    after_slide_index: Option<u32>,
-    layout: Option<String>,
-    notes: Option<String>,
-    background_fill: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct SlideIndexArgs {
-    slide_index: u32,
-}
-
-#[derive(Debug, Deserialize)]
-struct MoveSlideArgs {
-    from_index: u32,
-    to_index: u32,
-}
-
-#[derive(Debug, Deserialize)]
-struct SetActiveSlideArgs {
-    slide_index: u32,
-}
-
-#[derive(Debug, Deserialize)]
-struct SetSlideBackgroundArgs {
-    slide_index: u32,
-    fill: String,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct PositionArgs {
-    left: u32,
-    top: u32,
-    width: u32,
-    height: u32,
-    rotation: Option<i32>,
-    flip_horizontal: Option<bool>,
-    flip_vertical: Option<bool>,
-}
-
-#[derive(Debug, Clone, Default, Deserialize)]
-struct PartialPositionArgs {
-    left: Option<u32>,
-    top: Option<u32>,
-    width: Option<u32>,
-    height: Option<u32>,
-    rotation: Option<i32>,
-    flip_horizontal: Option<bool>,
-    flip_vertical: Option<bool>,
-}
-
-#[derive(Debug, Clone, Default, Deserialize)]
-struct TextStylingArgs {
-    style: Option<String>,
-    font_size: Option<u32>,
-    font_family: Option<String>,
-    color: Option<String>,
-    fill: Option<String>,
-    alignment: Option<String>,
-    bold: Option<bool>,
-    italic: Option<bool>,
-    underline: Option<bool>,
-}
-
-#[derive(Debug, Clone, Default, Deserialize)]
-struct TextLayoutArgs {
-    insets: Option<TextInsetsArgs>,
-    wrap: Option<String>,
-    auto_fit: Option<String>,
-    vertical_alignment: Option<String>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct TextInsetsArgs {
-    left: u32,
-    right: u32,
-    top: u32,
-    bottom: u32,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-#[serde(untagged)]
-enum RichTextInput {
-    Plain(String),
-    Paragraphs(Vec<RichParagraphInput>),
-}
-
-#[derive(Debug, Clone, Deserialize)]
-#[serde(untagged)]
-enum RichParagraphInput {
-    Plain(String),
-    Runs(Vec<RichRunInput>),
-}
-
-#[derive(Debug, Clone, Deserialize)]
-#[serde(untagged)]
-enum RichRunInput {
-    Plain(String),
-    Styled(RichRunObjectInput),
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct RichRunObjectInput {
-    run: String,
-    #[serde(default)]
-    text_style: TextStylingArgs,
-    link: Option<RichTextLinkInput>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct RichTextLinkInput {
-    uri: Option<String>,
-    is_external: Option<bool>,
-}
-
-#[derive(Debug, Deserialize)]
-struct AddTextShapeArgs {
-    slide_index: u32,
-    text: String,
-    position: PositionArgs,
-    #[serde(flatten)]
-    styling: TextStylingArgs,
-    #[serde(default)]
-    text_layout: TextLayoutArgs,
-}
-
-#[derive(Debug, Clone, Default, Deserialize)]
-struct StrokeArgs {
-    color: String,
-    width: u32,
-    style: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct AddShapeArgs {
-    slide_index: u32,
-    geometry: String,
-    position: PositionArgs,
-    fill: Option<String>,
-    stroke: Option<StrokeArgs>,
-    text: Option<String>,
-    rotation: Option<i32>,
-    flip_horizontal: Option<bool>,
-    flip_vertical: Option<bool>,
-    #[serde(default)]
-    text_style: TextStylingArgs,
-    #[serde(default)]
-    text_layout: TextLayoutArgs,
-}
-
-#[derive(Debug, Clone, Default, Deserialize)]
-struct ConnectorLineArgs {
-    color: Option<String>,
-    width: Option<u32>,
-    style: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-struct PointArgs {
-    left: u32,
-    top: u32,
-}
-
-#[derive(Debug, Deserialize)]
-struct AddConnectorArgs {
-    slide_index: u32,
-    connector_type: String,
-    start: PointArgs,
-    end: PointArgs,
-    line: Option<ConnectorLineArgs>,
-    start_arrow: Option<String>,
-    end_arrow: Option<String>,
-    arrow_size: Option<String>,
-    label: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct AddImageArgs {
-    slide_index: u32,
-    path: Option<PathBuf>,
-    data_url: Option<String>,
-    blob: Option<String>,
-    uri: Option<String>,
-    position: PositionArgs,
-    fit: Option<ImageFitMode>,
-    crop: Option<ImageCropArgs>,
-    rotation: Option<i32>,
-    flip_horizontal: Option<bool>,
-    flip_vertical: Option<bool>,
-    lock_aspect_ratio: Option<bool>,
-    alt: Option<String>,
-    prompt: Option<String>,
-}
-
-impl AddImageArgs {
-    fn image_source(&self) -> Result<ImageInputSource, PresentationArtifactError> {
-        match (&self.path, &self.data_url, &self.blob, &self.uri) {
-            (Some(path), None, None, None) => Ok(ImageInputSource::Path(path.clone())),
-            (None, Some(data_url), None, None) => Ok(ImageInputSource::DataUrl(data_url.clone())),
-            (None, None, Some(blob), None) => Ok(ImageInputSource::Blob(blob.clone())),
-            (None, None, None, Some(uri)) => Ok(ImageInputSource::Uri(uri.clone())),
-            (None, None, None, None) if self.prompt.is_some() => Ok(ImageInputSource::Placeholder),
-            _ => Err(PresentationArtifactError::InvalidArgs {
-                action: "add_image".to_string(),
-                message:
-                    "provide exactly one of `path`, `data_url`, `blob`, or `uri`, or provide `prompt` for a placeholder image"
-                        .to_string(),
-            }),
-        }
-    }
-}
-
-enum ImageInputSource {
-    Path(PathBuf),
-    DataUrl(String),
-    Blob(String),
-    Uri(String),
-    Placeholder,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct ImageCropArgs {
-    left: f64,
-    top: f64,
-    right: f64,
-    bottom: f64,
-}
-
-#[derive(Debug, Deserialize)]
-struct AddTableArgs {
-    slide_index: u32,
-    position: PositionArgs,
-    rows: Vec<Vec<Value>>,
-    column_widths: Option<Vec<u32>>,
-    row_heights: Option<Vec<u32>>,
-    style: Option<String>,
-    style_options: Option<TableStyleOptionsArgs>,
-    borders: Option<TableBordersArgs>,
-    right_to_left: Option<bool>,
-}
-
-#[derive(Debug, Deserialize)]
-struct AddChartArgs {
-    slide_index: u32,
-    position: PositionArgs,
-    chart_type: String,
-    categories: Vec<String>,
-    series: Vec<ChartSeriesArgs>,
-    title: Option<String>,
-    style_index: Option<u32>,
-    has_legend: Option<bool>,
-    legend_position: Option<String>,
-    #[serde(default)]
-    legend_text_style: TextStylingArgs,
-    x_axis_title: Option<String>,
-    y_axis_title: Option<String>,
-    data_labels: Option<ChartDataLabelsArgs>,
-    chart_fill: Option<String>,
-    plot_area_fill: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ChartSeriesArgs {
-    name: String,
-    values: Vec<f64>,
-    categories: Option<Vec<String>>,
-    x_values: Option<Vec<f64>>,
-    fill: Option<String>,
-    stroke: Option<StrokeArgs>,
-    marker: Option<ChartMarkerArgs>,
-    data_label_overrides: Option<Vec<ChartDataLabelOverrideArgs>>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct ChartMarkerArgs {
-    symbol: Option<String>,
-    size: Option<u32>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct ChartDataLabelsArgs {
-    show_value: Option<bool>,
-    show_category_name: Option<bool>,
-    show_leader_lines: Option<bool>,
-    position: Option<String>,
-    #[serde(default)]
-    text_style: TextStylingArgs,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct ChartDataLabelOverrideArgs {
-    idx: u32,
-    text: Option<String>,
-    position: Option<String>,
-    #[serde(default)]
-    text_style: TextStylingArgs,
-    fill: Option<String>,
-    stroke: Option<StrokeArgs>,
-}
-
-#[derive(Debug, Deserialize)]
-struct UpdateTextArgs {
-    element_id: String,
-    text: String,
-    #[serde(default)]
-    styling: TextStylingArgs,
-    #[serde(default)]
-    text_layout: TextLayoutArgs,
-}
-
-#[derive(Debug, Deserialize)]
-struct SetRichTextArgs {
-    element_id: Option<String>,
-    slide_index: Option<u32>,
-    row: Option<u32>,
-    column: Option<u32>,
-    notes: Option<bool>,
-    text: RichTextInput,
-    #[serde(default)]
-    styling: TextStylingArgs,
-    #[serde(default)]
-    text_layout: TextLayoutArgs,
-}
-
-#[derive(Debug, Deserialize)]
-struct FormatTextRangeArgs {
-    element_id: Option<String>,
-    slide_index: Option<u32>,
-    row: Option<u32>,
-    column: Option<u32>,
-    notes: Option<bool>,
-    query: Option<String>,
-    occurrence: Option<usize>,
-    start_cp: Option<usize>,
-    length: Option<usize>,
-    #[serde(default)]
-    styling: TextStylingArgs,
-    #[serde(default)]
-    text_layout: TextLayoutArgs,
-    link: Option<RichTextLinkInput>,
-    spacing_before: Option<u32>,
-    spacing_after: Option<u32>,
-    line_spacing: Option<f32>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ReplaceTextArgs {
-    element_id: String,
-    search: String,
-    replace: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct InsertTextAfterArgs {
-    element_id: String,
-    after: String,
-    insert: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct SetHyperlinkArgs {
-    element_id: String,
-    link_type: Option<String>,
-    url: Option<String>,
-    slide_index: Option<u32>,
-    address: Option<String>,
-    subject: Option<String>,
-    path: Option<String>,
-    tooltip: Option<String>,
-    highlight_click: Option<bool>,
-    clear: Option<bool>,
-}
-
-#[derive(Debug, Deserialize)]
-struct UpdateShapeStyleArgs {
-    element_id: String,
-    position: Option<PartialPositionArgs>,
-    fill: Option<String>,
-    stroke: Option<StrokeArgs>,
-    rotation: Option<i32>,
-    flip_horizontal: Option<bool>,
-    flip_vertical: Option<bool>,
-    fit: Option<ImageFitMode>,
-    crop: Option<ImageCropArgs>,
-    lock_aspect_ratio: Option<bool>,
-    z_order: Option<u32>,
-    #[serde(default)]
-    text_layout: TextLayoutArgs,
-}
-
-#[derive(Debug, Deserialize)]
-struct ElementIdArgs {
-    element_id: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct ReplaceImageArgs {
-    element_id: String,
-    path: Option<PathBuf>,
-    data_url: Option<String>,
-    blob: Option<String>,
-    uri: Option<String>,
-    fit: Option<ImageFitMode>,
-    crop: Option<ImageCropArgs>,
-    rotation: Option<i32>,
-    flip_horizontal: Option<bool>,
-    flip_vertical: Option<bool>,
-    lock_aspect_ratio: Option<bool>,
-    alt: Option<String>,
-    prompt: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct UpdateTableCellArgs {
-    element_id: String,
-    row: u32,
-    column: u32,
-    value: Value,
-    #[serde(default)]
-    styling: TextStylingArgs,
-    background_fill: Option<String>,
-    alignment: Option<String>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct TableStyleOptionsArgs {
-    header_row: Option<bool>,
-    banded_rows: Option<bool>,
-    banded_columns: Option<bool>,
-    first_column: Option<bool>,
-    last_column: Option<bool>,
-    total_row: Option<bool>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct TableBorderArgs {
-    color: String,
-    width: u32,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct TableBordersArgs {
-    outside: Option<TableBorderArgs>,
-    inside: Option<TableBorderArgs>,
-    top: Option<TableBorderArgs>,
-    bottom: Option<TableBorderArgs>,
-    left: Option<TableBorderArgs>,
-    right: Option<TableBorderArgs>,
-}
-
-#[derive(Debug, Deserialize)]
-struct UpdateTableStyleArgs {
-    element_id: String,
-    style: Option<String>,
-    style_options: Option<TableStyleOptionsArgs>,
-    borders: Option<TableBordersArgs>,
-    right_to_left: Option<bool>,
-}
-
-#[derive(Debug, Deserialize)]
-struct StyleTableBlockArgs {
-    element_id: String,
-    row: u32,
-    column: u32,
-    row_count: u32,
-    column_count: u32,
-    #[serde(default)]
-    styling: TextStylingArgs,
-    background_fill: Option<String>,
-    alignment: Option<String>,
-    borders: Option<TableBordersArgs>,
-}
-
-#[derive(Debug, Deserialize)]
-struct MergeTableCellsArgs {
-    element_id: String,
-    start_row: u32,
-    end_row: u32,
-    start_column: u32,
-    end_column: u32,
-}
-
-#[derive(Debug, Deserialize)]
-struct UpdateChartArgs {
-    element_id: String,
-    title: Option<String>,
-    categories: Option<Vec<String>>,
-    style_index: Option<u32>,
-    has_legend: Option<bool>,
-    legend_position: Option<String>,
-    #[serde(default)]
-    legend_text_style: TextStylingArgs,
-    x_axis_title: Option<String>,
-    y_axis_title: Option<String>,
-    data_labels: Option<ChartDataLabelsArgs>,
-    chart_fill: Option<String>,
-    plot_area_fill: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct AddChartSeriesArgs {
-    element_id: String,
-    name: String,
-    values: Vec<f64>,
-    categories: Option<Vec<String>>,
-    x_values: Option<Vec<f64>>,
-    fill: Option<String>,
-    stroke: Option<StrokeArgs>,
-    marker: Option<ChartMarkerArgs>,
-}
-
-#[derive(Debug, Deserialize)]
-struct SetCommentAuthorArgs {
-    display_name: String,
-    initials: String,
-    email: Option<String>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct CommentPositionArgs {
-    x: u32,
-    y: u32,
-}
-
-#[derive(Debug, Deserialize)]
-struct AddCommentThreadArgs {
-    slide_index: Option<u32>,
-    element_id: Option<String>,
-    query: Option<String>,
-    occurrence: Option<usize>,
-    start_cp: Option<usize>,
-    length: Option<usize>,
-    text: String,
-    position: Option<CommentPositionArgs>,
-}
-
-#[derive(Debug, Deserialize)]
-struct AddCommentReplyArgs {
-    thread_id: String,
-    text: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct ToggleCommentReactionArgs {
-    thread_id: String,
-    message_id: Option<String>,
-    emoji: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct CommentThreadIdArgs {
-    thread_id: String,
-}

codex-rs/artifact-presentation/src/presentation_artifact/inspect.rs

@@ -1,871 +0,0 @@
-fn inspect_document(document: &PresentationDocument, args: &InspectArgs) -> String {
-    let include_kinds = args
-        .include
-        .as_deref()
-        .or(args.kind.as_deref())
-        .unwrap_or(
-            "deck,slide,textbox,shape,connector,table,chart,image,notes,layoutList,textRange,comment",
-        );
-    let included_kinds = include_kinds
-        .split(',')
-        .map(str::trim)
-        .filter(|entry| !entry.is_empty())
-        .collect::<HashSet<_>>();
-    let excluded_kinds = args
-        .exclude
-        .as_deref()
-        .unwrap_or_default()
-        .split(',')
-        .map(str::trim)
-        .filter(|entry| !entry.is_empty())
-        .collect::<HashSet<_>>();
-    let include = |name: &str| included_kinds.contains(name) && !excluded_kinds.contains(name);
-    let mut records: Vec<(Value, Option<String>)> = Vec::new();
-    if include("deck") {
-        records.push((
-            serde_json::json!({
-                "kind": "deck",
-                "id": format!("pr/{}", document.artifact_id),
-                "name": document.name,
-                "slides": document.slides.len(),
-                "styleIds": document
-                    .named_text_styles()
-                    .iter()
-                    .map(|style| format!("st/{}", style.name))
-                    .collect::<Vec<_>>(),
-                "activeSlideIndex": document.active_slide_index,
-                "activeSlideId": document.active_slide_index.and_then(|index| document.slides.get(index)).map(|slide| format!("sl/{}", slide.slide_id)),
-                "commentThreadIds": document
-                    .comment_threads
-                    .iter()
-                    .map(|thread| format!("th/{}", thread.thread_id))
-                    .collect::<Vec<_>>(),
-            }),
-            None,
-        ));
-    }
-    if include("styleList") {
-        for style in document.named_text_styles() {
-            records.push((named_text_style_to_json(&style, "st"), None));
-        }
-    }
-    if include("layoutList") {
-        for layout in &document.layouts {
-            let placeholders = resolved_layout_placeholders(document, &layout.layout_id, "inspect")
-                .unwrap_or_default()
-                .into_iter()
-                .map(|placeholder| {
-                    serde_json::json!({
-                        "name": placeholder.definition.name,
-                        "type": placeholder.definition.placeholder_type,
-                        "sourceLayoutId": placeholder.source_layout_id,
-                        "textPreview": placeholder.definition.text,
-                    })
-                })
-                .collect::<Vec<_>>();
-            records.push((
-                serde_json::json!({
-                    "kind": "layout",
-                    "id": format!("ly/{}", layout.layout_id),
-                    "layoutId": layout.layout_id,
-                    "name": layout.name,
-                    "type": match layout.kind { LayoutKind::Layout => "layout", LayoutKind::Master => "master" },
-                    "parentLayoutId": layout.parent_layout_id,
-                    "placeholders": placeholders,
-                }),
-                None,
-            ));
-        }
-    }
-    for (index, slide) in document.slides.iter().enumerate() {
-        let slide_id = format!("sl/{}", slide.slide_id);
-        if include("slide") {
-            records.push((
-                serde_json::json!({
-                    "kind": "slide",
-                    "id": slide_id,
-                    "slide": index + 1,
-                    "slideIndex": index,
-                    "isActive": document.active_slide_index == Some(index),
-                    "layoutId": slide.layout_id,
-                    "elements": slide.elements.len(),
-                }),
-                Some(slide_id.clone()),
-            ));
-        }
-        if include("notes") && !slide.notes.text.is_empty() {
-            records.push((
-                serde_json::json!({
-                    "kind": "notes",
-                    "id": format!("nt/{}", slide.slide_id),
-                    "slide": index + 1,
-                    "visible": slide.notes.visible,
-                    "text": slide.notes.text,
-                    "textPreview": slide.notes.text.replace('\n', " | "),
-                    "textChars": slide.notes.text.chars().count(),
-                    "textLines": slide.notes.text.lines().count(),
-                    "richText": rich_text_to_proto(&slide.notes.text, &slide.notes.rich_text),
-                }),
-                Some(slide_id.clone()),
-            ));
-        }
-        if include("textRange") {
-            records.extend(
-                slide
-                    .notes
-                    .rich_text
-                    .ranges
-                    .iter()
-                    .map(|range| {
-                        let mut record = text_range_to_proto(&slide.notes.text, range);
-                        record["kind"] = Value::String("textRange".to_string());
-                        record["slide"] = Value::from(index + 1);
-                        record["slideIndex"] = Value::from(index);
-                        record["hostAnchor"] = Value::String(format!("nt/{}", slide.slide_id));
-                        record["hostKind"] = Value::String("notes".to_string());
-                        (record, Some(slide_id.clone()))
-                    }),
-            );
-        }
-        for element in &slide.elements {
-            let mut record = match element {
-                PresentationElement::Text(text) => {
-                    if !include("textbox") {
-                        continue;
-                    }
-                    serde_json::json!({
-                        "kind": "textbox",
-                        "id": format!("sh/{}", text.element_id),
-                        "slide": index + 1,
-                        "text": text.text,
-                        "textStyle": text_style_to_proto(&text.style),
-                        "textPreview": text.text.replace('\n', " | "),
-                        "textChars": text.text.chars().count(),
-                        "textLines": text.text.lines().count(),
-                        "richText": rich_text_to_proto(&text.text, &text.rich_text),
-                        "bbox": [text.frame.left, text.frame.top, text.frame.width, text.frame.height],
-                        "bboxUnit": "points",
-                    })
-                }
-                PresentationElement::Shape(shape) => {
-                    if !(include("shape") || include("textbox") && shape.text.is_some()) {
-                        continue;
-                    }
-                    let kind = if shape.text.is_some() && include("textbox") {
-                        "textbox"
-                    } else {
-                        "shape"
-                    };
-                    let mut record = serde_json::json!({
-                        "kind": kind,
-                        "id": format!("sh/{}", shape.element_id),
-                        "slide": index + 1,
-                        "geometry": format!("{:?}", shape.geometry),
-                        "text": shape.text,
-                        "textStyle": text_style_to_proto(&shape.text_style),
-                        "richText": shape
-                            .text
-                            .as_ref()
-                            .zip(shape.rich_text.as_ref())
-                            .map(|(text, rich_text)| rich_text_to_proto(text, rich_text))
-                            .unwrap_or(Value::Null),
-                        "rotation": shape.rotation_degrees,
-                        "flipHorizontal": shape.flip_horizontal,
-                        "flipVertical": shape.flip_vertical,
-                        "bbox": [shape.frame.left, shape.frame.top, shape.frame.width, shape.frame.height],
-                        "bboxUnit": "points",
-                    });
-                    if let Some(text) = &shape.text {
-                        record["textPreview"] = Value::String(text.replace('\n', " | "));
-                        record["textChars"] = Value::from(text.chars().count());
-                        record["textLines"] = Value::from(text.lines().count());
-                    }
-                    record
-                }
-                PresentationElement::Connector(connector) => {
-                    if !include("shape") && !include("connector") {
-                        continue;
-                    }
-                    serde_json::json!({
-                        "kind": "connector",
-                        "id": format!("cn/{}", connector.element_id),
-                        "slide": index + 1,
-                        "connectorType": format!("{:?}", connector.connector_type),
-                        "start": [connector.start.left, connector.start.top],
-                        "end": [connector.end.left, connector.end.top],
-                        "lineStyle": format!("{:?}", connector.line_style),
-                        "label": connector.label,
-                    })
-                }
-                PresentationElement::Table(table) => {
-                    if !include("table") {
-                        continue;
-                    }
-                    serde_json::json!({
-                        "kind": "table",
-                        "id": format!("tb/{}", table.element_id),
-                        "slide": index + 1,
-                        "rows": table.rows.len(),
-                        "cols": table.rows.iter().map(std::vec::Vec::len).max().unwrap_or(0),
-                        "columnWidths": table.column_widths,
-                        "rowHeights": table.row_heights,
-                        "preview": table.rows.first().map(|row| row.iter().map(|cell| cell.text.clone()).collect::<Vec<_>>().join(" | ")),
-                        "style": table.style,
-                        "styleOptions": table_style_options_to_proto(&table.style_options),
-                        "borders": table.borders.as_ref().map(table_borders_to_proto),
-                        "rightToLeft": table.right_to_left,
-                        "cellTextStyles": table
-                            .rows
-                            .iter()
-                            .map(|row| row.iter().map(|cell| text_style_to_proto(&cell.text_style)).collect::<Vec<_>>())
-                            .collect::<Vec<_>>(),
-                        "rowsData": table
-                            .rows
-                            .iter()
-                            .map(|row| row.iter().map(table_cell_to_proto).collect::<Vec<_>>())
-                            .collect::<Vec<_>>(),
-                        "bbox": [table.frame.left, table.frame.top, table.frame.width, table.frame.height],
-                        "bboxUnit": "points",
-                    })
-                }
-                PresentationElement::Chart(chart) => {
-                    if !include("chart") {
-                        continue;
-                    }
-                    serde_json::json!({
-                        "kind": "chart",
-                        "id": format!("ch/{}", chart.element_id),
-                        "slide": index + 1,
-                        "chartType": format!("{:?}", chart.chart_type),
-                        "title": chart.title,
-                        "styleIndex": chart.style_index,
-                        "hasLegend": chart.has_legend,
-                        "legend": chart.legend.as_ref().map(chart_legend_to_proto),
-                        "xAxis": chart.x_axis.as_ref().map(chart_axis_to_proto),
-                        "yAxis": chart.y_axis.as_ref().map(chart_axis_to_proto),
-                        "dataLabels": chart.data_labels.as_ref().map(chart_data_labels_to_proto),
-                        "chartFill": chart.chart_fill,
-                        "plotAreaFill": chart.plot_area_fill,
-                        "series": chart
-                            .series
-                            .iter()
-                            .map(|series| serde_json::json!({
-                                "name": series.name,
-                                "values": series.values,
-                                "categories": series.categories,
-                                "xValues": series.x_values,
-                                "fill": series.fill,
-                                "stroke": series.stroke.as_ref().map(stroke_to_proto),
-                                "marker": series.marker.as_ref().map(chart_marker_to_proto),
-                                "dataLabelOverrides": series
-                                    .data_label_overrides
-                                    .iter()
-                                    .map(chart_data_label_override_to_proto)
-                                    .collect::<Vec<_>>(),
-                            }))
-                            .collect::<Vec<_>>(),
-                        "bbox": [chart.frame.left, chart.frame.top, chart.frame.width, chart.frame.height],
-                        "bboxUnit": "points",
-                    })
-                }
-                PresentationElement::Image(image) => {
-                    if !include("image") {
-                        continue;
-                    }
-                    serde_json::json!({
-                        "kind": "image",
-                        "id": format!("im/{}", image.element_id),
-                        "slide": index + 1,
-                        "alt": image.alt_text,
-                        "prompt": image.prompt,
-                        "fit": format!("{:?}", image.fit_mode),
-                        "rotation": image.rotation_degrees,
-                        "flipHorizontal": image.flip_horizontal,
-                        "flipVertical": image.flip_vertical,
-                        "crop": image.crop.map(|(left, top, right, bottom)| serde_json::json!({
-                            "left": left,
-                            "top": top,
-                            "right": right,
-                            "bottom": bottom,
-                        })),
-                        "isPlaceholder": image.is_placeholder,
-                        "lockAspectRatio": image.lock_aspect_ratio,
-                        "bbox": [image.frame.left, image.frame.top, image.frame.width, image.frame.height],
-                        "bboxUnit": "points",
-                    })
-                }
-            };
-            if let Some(placeholder) = match element {
-                PresentationElement::Text(text) => text.placeholder.as_ref(),
-                PresentationElement::Shape(shape) => shape.placeholder.as_ref(),
-                PresentationElement::Connector(_)
-                | PresentationElement::Table(_)
-                | PresentationElement::Chart(_) => None,
-                PresentationElement::Image(image) => image.placeholder.as_ref(),
-            } {
-                record["placeholder"] = Value::String(placeholder.placeholder_type.clone());
-                record["placeholderName"] = Value::String(placeholder.name.clone());
-                record["placeholderIndex"] =
-                    placeholder.index.map(Value::from).unwrap_or(Value::Null);
-            }
-            if let PresentationElement::Shape(shape) = element
-                && let Some(stroke) = &shape.stroke
-            {
-                record["stroke"] = serde_json::json!({
-                    "color": stroke.color,
-                    "width": stroke.width,
-                    "style": stroke.style.as_api_str(),
-                });
-            }
-            if let Some(hyperlink) = match element {
-                PresentationElement::Text(text) => text.hyperlink.as_ref(),
-                PresentationElement::Shape(shape) => shape.hyperlink.as_ref(),
-                PresentationElement::Connector(_)
-                | PresentationElement::Image(_)
-                | PresentationElement::Table(_)
-                | PresentationElement::Chart(_) => None,
-            } {
-                record["hyperlink"] = hyperlink.to_json();
-            }
-            records.push((record, Some(slide_id.clone())));
-            if include("textRange") {
-                match element {
-                    PresentationElement::Text(text) => {
-                        records.extend(text.rich_text.ranges.iter().map(|range| {
-                            let mut record = text_range_to_proto(&text.text, range);
-                            record["kind"] = Value::String("textRange".to_string());
-                            record["slide"] = Value::from(index + 1);
-                            record["slideIndex"] = Value::from(index);
-                            record["hostAnchor"] = Value::String(format!("sh/{}", text.element_id));
-                            record["hostKind"] = Value::String("textbox".to_string());
-                            (record, Some(slide_id.clone()))
-                        }));
-                    }
-                    PresentationElement::Shape(shape) => {
-                        if let Some((text, rich_text)) = shape.text.as_ref().zip(shape.rich_text.as_ref()) {
-                            records.extend(rich_text.ranges.iter().map(|range| {
-                                let mut record = text_range_to_proto(text, range);
-                                record["kind"] = Value::String("textRange".to_string());
-                                record["slide"] = Value::from(index + 1);
-                                record["slideIndex"] = Value::from(index);
-                                record["hostAnchor"] = Value::String(format!("sh/{}", shape.element_id));
-                                record["hostKind"] = Value::String("textbox".to_string());
-                                (record, Some(slide_id.clone()))
-                            }));
-                        }
-                    }
-                    PresentationElement::Table(table) => {
-                        for (row_index, row) in table.rows.iter().enumerate() {
-                            for (column_index, cell) in row.iter().enumerate() {
-                                records.extend(cell.rich_text.ranges.iter().map(|range| {
-                                    let mut record = text_range_to_proto(&cell.text, range);
-                                    record["kind"] = Value::String("textRange".to_string());
-                                    record["slide"] = Value::from(index + 1);
-                                    record["slideIndex"] = Value::from(index);
-                                    record["hostAnchor"] = Value::String(format!(
-                                        "tb/{}#cell/{row_index}/{column_index}",
-                                        table.element_id
-                                    ));
-                                    record["hostKind"] = Value::String("tableCell".to_string());
-                                    (record, Some(slide_id.clone()))
-                                }));
-                            }
-                        }
-                    }
-                    PresentationElement::Connector(_)
-                    | PresentationElement::Image(_)
-                    | PresentationElement::Chart(_) => {}
-                }
-            }
-        }
-    }
-    if include("comment") {
-        records.extend(document.comment_threads.iter().map(|thread| {
-            let mut record = comment_thread_to_proto(thread);
-            record["id"] = Value::String(format!("th/{}", thread.thread_id));
-            (record, None)
-        }));
-    }
-
-    if let Some(target_id) = args.target_id.as_deref() {
-        records.retain(|(record, slide_id)| {
-            legacy_target_matches(target_id, record, slide_id.as_deref())
-        });
-        if records.is_empty() {
-            records.push((
-                serde_json::json!({
-                    "kind": "notice",
-                    "noticeType": "targetNotFound",
-                    "target": { "id": target_id },
-                    "message": format!("No inspect records matched target `{target_id}`."),
-                }),
-                None,
-            ));
-        }
-    }
-
-    if let Some(search) = args.search.as_deref() {
-        let search_lowercase = search.to_ascii_lowercase();
-        records.retain(|(record, _)| {
-            record
-                .to_string()
-                .to_ascii_lowercase()
-                .contains(&search_lowercase)
-        });
-        if records.is_empty() {
-            records.push((
-                serde_json::json!({
-                    "kind": "notice",
-                    "noticeType": "noMatches",
-                    "search": search,
-                    "message": format!("No inspect records matched search `{search}`."),
-                }),
-                None,
-            ));
-        }
-    }
-
-    if let Some(target) = args.target.as_ref() {
-        if let Some(target_index) = records.iter().position(|(record, _)| {
-            record.get("id").and_then(Value::as_str) == Some(target.id.as_str())
-        }) {
-            let start = target_index.saturating_sub(target.before_lines.unwrap_or(0));
-            let end = (target_index + target.after_lines.unwrap_or(0) + 1).min(records.len());
-            records = records.into_iter().skip(start).take(end - start).collect();
-        } else {
-            records = vec![(
-                serde_json::json!({
-                    "kind": "notice",
-                    "noticeType": "targetNotFound",
-                    "target": {
-                        "id": target.id,
-                        "beforeLines": target.before_lines,
-                        "afterLines": target.after_lines,
-                    },
-                    "message": format!("No inspect records matched target `{}`.", target.id),
-                }),
-                None,
-            )];
-        }
-    }
-
-    let mut lines = Vec::new();
-    let mut omitted_lines = 0usize;
-    let mut omitted_chars = 0usize;
-    for line in records.into_iter().map(|(record, _)| record.to_string()) {
-        let separator_len = usize::from(!lines.is_empty());
-        if let Some(max_chars) = args.max_chars
-            && lines.iter().map(String::len).sum::<usize>() + separator_len + line.len() > max_chars
-        {
-            omitted_lines += 1;
-            omitted_chars += line.len();
-            continue;
-        }
-        lines.push(line);
-    }
-    if omitted_lines > 0 {
-        lines.push(
-            serde_json::json!({
-                "kind": "notice",
-                "noticeType": "truncation",
-                "maxChars": args.max_chars,
-                "omittedLines": omitted_lines,
-                "omittedChars": omitted_chars,
-                "message": format!(
-                    "Truncated inspect output by omitting {omitted_lines} lines. Increase maxChars or narrow the filter."
-                ),
-            })
-            .to_string(),
-        );
-    }
-    lines.join("\n")
-}
-
-fn legacy_target_matches(target_id: &str, record: &Value, slide_id: Option<&str>) -> bool {
-    record.get("id").and_then(Value::as_str) == Some(target_id) || slide_id == Some(target_id)
-}
-
-fn add_text_metadata(record: &mut Value, text: &str) {
-    record["textPreview"] = Value::String(text.replace('\n', " | "));
-    record["textChars"] = Value::from(text.chars().count());
-    record["textLines"] = Value::from(text.lines().count());
-}
-
-fn normalize_element_lookup_id(element_id: &str) -> &str {
-    element_id
-        .split_once('/')
-        .map(|(_, normalized)| normalized)
-        .unwrap_or(element_id)
-}
-
-fn resolve_anchor(
-    document: &PresentationDocument,
-    id: &str,
-    action: &str,
-) -> Result<Value, PresentationArtifactError> {
-    if id == format!("pr/{}", document.artifact_id) {
-        return Ok(serde_json::json!({
-            "kind": "deck",
-            "id": id,
-            "artifactId": document.artifact_id,
-            "name": document.name,
-            "slideCount": document.slides.len(),
-            "styleIds": document
-                .named_text_styles()
-                .iter()
-                .map(|style| format!("st/{}", style.name))
-                .collect::<Vec<_>>(),
-            "activeSlideIndex": document.active_slide_index,
-            "activeSlideId": document.active_slide_index.and_then(|index| document.slides.get(index)).map(|slide| format!("sl/{}", slide.slide_id)),
-        }));
-    }
-    if let Some(style_name) = id.strip_prefix("st/") {
-        let named_style = document
-            .named_text_styles()
-            .into_iter()
-            .find(|style| style.name == style_name)
-            .ok_or_else(|| PresentationArtifactError::UnsupportedFeature {
-                action: action.to_string(),
-                message: format!("unknown style id `{id}`"),
-            })?;
-        return Ok(named_text_style_to_json(&named_style, "st"));
-    }
-
-    for (slide_index, slide) in document.slides.iter().enumerate() {
-        let slide_id = format!("sl/{}", slide.slide_id);
-        if id == slide_id {
-            return Ok(serde_json::json!({
-                "kind": "slide",
-                "id": slide_id,
-                "slide": slide_index + 1,
-                "slideIndex": slide_index,
-                "isActive": document.active_slide_index == Some(slide_index),
-                "layoutId": slide.layout_id,
-                "notesId": (!slide.notes.text.is_empty()).then(|| format!("nt/{}", slide.slide_id)),
-                "elementIds": slide.elements.iter().map(|element| {
-                    let prefix = match element {
-                        PresentationElement::Text(_) | PresentationElement::Shape(_) => "sh",
-                        PresentationElement::Connector(_) => "cn",
-                        PresentationElement::Image(_) => "im",
-                        PresentationElement::Table(_) => "tb",
-                        PresentationElement::Chart(_) => "ch",
-                    };
-                    format!("{prefix}/{}", element.element_id())
-                }).collect::<Vec<_>>(),
-            }));
-        }
-        let notes_id = format!("nt/{}", slide.slide_id);
-        if id == notes_id {
-            let mut record = serde_json::json!({
-                "kind": "notes",
-                "id": notes_id,
-                "slide": slide_index + 1,
-                "slideIndex": slide_index,
-                "visible": slide.notes.visible,
-                "text": slide.notes.text,
-            });
-            add_text_metadata(&mut record, &slide.notes.text);
-            record["richText"] = rich_text_to_proto(&slide.notes.text, &slide.notes.rich_text);
-            return Ok(record);
-        }
-        if let Some(range_id) = id.strip_prefix("tr/")
-            && let Some(record) = slide
-                .notes
-                .rich_text
-                .ranges
-                .iter()
-                .find(|range| range.range_id == range_id)
-                .map(|range| {
-                    let mut record = text_range_to_proto(&slide.notes.text, range);
-                    record["kind"] = Value::String("textRange".to_string());
-                    record["id"] = Value::String(id.to_string());
-                    record["slide"] = Value::from(slide_index + 1);
-                    record["slideIndex"] = Value::from(slide_index);
-                    record["hostAnchor"] = Value::String(notes_id.clone());
-                    record["hostKind"] = Value::String("notes".to_string());
-                    record
-                })
-        {
-            return Ok(record);
-        }
-        for element in &slide.elements {
-            let mut record = match element {
-                PresentationElement::Text(text) => {
-                    let mut record = serde_json::json!({
-                        "kind": "textbox",
-                        "id": format!("sh/{}", text.element_id),
-                        "elementId": text.element_id,
-                        "slide": slide_index + 1,
-                        "slideIndex": slide_index,
-                        "text": text.text,
-                        "textStyle": text_style_to_proto(&text.style),
-                        "richText": rich_text_to_proto(&text.text, &text.rich_text),
-                        "bbox": [text.frame.left, text.frame.top, text.frame.width, text.frame.height],
-                        "bboxUnit": "points",
-                    });
-                    add_text_metadata(&mut record, &text.text);
-                    record
-                }
-                PresentationElement::Shape(shape) => {
-                    let mut record = serde_json::json!({
-                        "kind": if shape.text.is_some() { "textbox" } else { "shape" },
-                        "id": format!("sh/{}", shape.element_id),
-                        "elementId": shape.element_id,
-                        "slide": slide_index + 1,
-                        "slideIndex": slide_index,
-                        "geometry": format!("{:?}", shape.geometry),
-                        "text": shape.text,
-                        "textStyle": text_style_to_proto(&shape.text_style),
-                        "richText": shape
-                            .text
-                            .as_ref()
-                            .zip(shape.rich_text.as_ref())
-                            .map(|(text, rich_text)| rich_text_to_proto(text, rich_text))
-                            .unwrap_or(Value::Null),
-                        "rotation": shape.rotation_degrees,
-                        "flipHorizontal": shape.flip_horizontal,
-                        "flipVertical": shape.flip_vertical,
-                        "bbox": [shape.frame.left, shape.frame.top, shape.frame.width, shape.frame.height],
-                        "bboxUnit": "points",
-                    });
-                    if let Some(text) = &shape.text {
-                        add_text_metadata(&mut record, text);
-                    }
-                    record
-                }
-                PresentationElement::Connector(connector) => serde_json::json!({
-                    "kind": "connector",
-                    "id": format!("cn/{}", connector.element_id),
-                    "elementId": connector.element_id,
-                    "slide": slide_index + 1,
-                    "slideIndex": slide_index,
-                    "connectorType": format!("{:?}", connector.connector_type),
-                    "start": [connector.start.left, connector.start.top],
-                    "end": [connector.end.left, connector.end.top],
-                    "lineStyle": format!("{:?}", connector.line_style),
-                    "label": connector.label,
-                }),
-                PresentationElement::Image(image) => serde_json::json!({
-                    "kind": "image",
-                    "id": format!("im/{}", image.element_id),
-                    "elementId": image.element_id,
-                    "slide": slide_index + 1,
-                    "slideIndex": slide_index,
-                    "alt": image.alt_text,
-                    "prompt": image.prompt,
-                    "fit": format!("{:?}", image.fit_mode),
-                    "rotation": image.rotation_degrees,
-                    "flipHorizontal": image.flip_horizontal,
-                    "flipVertical": image.flip_vertical,
-                    "crop": image.crop.map(|(left, top, right, bottom)| serde_json::json!({
-                        "left": left,
-                        "top": top,
-                        "right": right,
-                        "bottom": bottom,
-                    })),
-                    "isPlaceholder": image.is_placeholder,
-                    "lockAspectRatio": image.lock_aspect_ratio,
-                    "bbox": [image.frame.left, image.frame.top, image.frame.width, image.frame.height],
-                    "bboxUnit": "points",
-                }),
-                PresentationElement::Table(table) => serde_json::json!({
-                    "kind": "table",
-                    "id": format!("tb/{}", table.element_id),
-                    "elementId": table.element_id,
-                    "slide": slide_index + 1,
-                    "slideIndex": slide_index,
-                    "rows": table.rows.len(),
-                    "cols": table.rows.iter().map(std::vec::Vec::len).max().unwrap_or(0),
-                    "columnWidths": table.column_widths,
-                    "rowHeights": table.row_heights,
-                    "style": table.style,
-                    "styleOptions": table_style_options_to_proto(&table.style_options),
-                    "borders": table.borders.as_ref().map(table_borders_to_proto),
-                    "rightToLeft": table.right_to_left,
-                    "cellTextStyles": table
-                        .rows
-                        .iter()
-                        .map(|row| row.iter().map(|cell| text_style_to_proto(&cell.text_style)).collect::<Vec<_>>())
-                        .collect::<Vec<_>>(),
-                    "rowsData": table
-                        .rows
-                        .iter()
-                        .map(|row| row.iter().map(table_cell_to_proto).collect::<Vec<_>>())
-                        .collect::<Vec<_>>(),
-                    "bbox": [table.frame.left, table.frame.top, table.frame.width, table.frame.height],
-                    "bboxUnit": "points",
-                }),
-                PresentationElement::Chart(chart) => serde_json::json!({
-                    "kind": "chart",
-                    "id": format!("ch/{}", chart.element_id),
-                    "elementId": chart.element_id,
-                    "slide": slide_index + 1,
-                    "slideIndex": slide_index,
-                    "chartType": format!("{:?}", chart.chart_type),
-                    "title": chart.title,
-                    "styleIndex": chart.style_index,
-                    "hasLegend": chart.has_legend,
-                    "legend": chart.legend.as_ref().map(chart_legend_to_proto),
-                    "xAxis": chart.x_axis.as_ref().map(chart_axis_to_proto),
-                    "yAxis": chart.y_axis.as_ref().map(chart_axis_to_proto),
-                    "dataLabels": chart.data_labels.as_ref().map(chart_data_labels_to_proto),
-                    "chartFill": chart.chart_fill,
-                    "plotAreaFill": chart.plot_area_fill,
-                    "series": chart
-                        .series
-                        .iter()
-                        .map(|series| serde_json::json!({
-                            "name": series.name,
-                            "values": series.values,
-                            "categories": series.categories,
-                            "xValues": series.x_values,
-                            "fill": series.fill,
-                            "stroke": series.stroke.as_ref().map(stroke_to_proto),
-                            "marker": series.marker.as_ref().map(chart_marker_to_proto),
-                            "dataLabelOverrides": series
-                                .data_label_overrides
-                                .iter()
-                                .map(chart_data_label_override_to_proto)
-                                .collect::<Vec<_>>(),
-                        }))
-                        .collect::<Vec<_>>(),
-                    "bbox": [chart.frame.left, chart.frame.top, chart.frame.width, chart.frame.height],
-                    "bboxUnit": "points",
-                }),
-            };
-            if let Some(hyperlink) = match element {
-                PresentationElement::Text(text) => text.hyperlink.as_ref(),
-                PresentationElement::Shape(shape) => shape.hyperlink.as_ref(),
-                PresentationElement::Connector(_)
-                | PresentationElement::Image(_)
-                | PresentationElement::Table(_)
-                | PresentationElement::Chart(_) => None,
-            } {
-                record["hyperlink"] = hyperlink.to_json();
-            }
-            if let PresentationElement::Shape(shape) = element
-                && let Some(stroke) = &shape.stroke
-            {
-                record["stroke"] = serde_json::json!({
-                    "color": stroke.color,
-                    "width": stroke.width,
-                    "style": stroke.style.as_api_str(),
-                });
-            }
-            if let Some(placeholder) = match element {
-                PresentationElement::Text(text) => text.placeholder.as_ref(),
-                PresentationElement::Shape(shape) => shape.placeholder.as_ref(),
-                PresentationElement::Image(image) => image.placeholder.as_ref(),
-                PresentationElement::Connector(_)
-                | PresentationElement::Table(_)
-                | PresentationElement::Chart(_) => None,
-            } {
-                record["placeholder"] = Value::String(placeholder.placeholder_type.clone());
-                record["placeholderName"] = Value::String(placeholder.name.clone());
-                record["placeholderIndex"] =
-                    placeholder.index.map(Value::from).unwrap_or(Value::Null);
-            }
-            if record.get("id").and_then(Value::as_str) == Some(id) {
-                return Ok(record);
-            }
-            if let Some(range_id) = id.strip_prefix("tr/") {
-                match element {
-                    PresentationElement::Text(text) => {
-                        if let Some(range) =
-                            text.rich_text.ranges.iter().find(|range| range.range_id == range_id)
-                        {
-                            let mut range_record = text_range_to_proto(&text.text, range);
-                            range_record["kind"] = Value::String("textRange".to_string());
-                            range_record["id"] = Value::String(id.to_string());
-                            range_record["slide"] = Value::from(slide_index + 1);
-                            range_record["slideIndex"] = Value::from(slide_index);
-                            range_record["hostAnchor"] =
-                                Value::String(format!("sh/{}", text.element_id));
-                            range_record["hostKind"] = Value::String("textbox".to_string());
-                            return Ok(range_record);
-                        }
-                    }
-                    PresentationElement::Shape(shape) => {
-                        if let Some((text, rich_text)) =
-                            shape.text.as_ref().zip(shape.rich_text.as_ref())
-                            && let Some(range) =
-                                rich_text.ranges.iter().find(|range| range.range_id == range_id)
-                        {
-                            let mut range_record = text_range_to_proto(text, range);
-                            range_record["kind"] = Value::String("textRange".to_string());
-                            range_record["id"] = Value::String(id.to_string());
-                            range_record["slide"] = Value::from(slide_index + 1);
-                            range_record["slideIndex"] = Value::from(slide_index);
-                            range_record["hostAnchor"] =
-                                Value::String(format!("sh/{}", shape.element_id));
-                            range_record["hostKind"] = Value::String("textbox".to_string());
-                            return Ok(range_record);
-                        }
-                    }
-                    PresentationElement::Table(table) => {
-                        for (row_index, row) in table.rows.iter().enumerate() {
-                            for (column_index, cell) in row.iter().enumerate() {
-                                if let Some(range) = cell
-                                    .rich_text
-                                    .ranges
-                                    .iter()
-                                    .find(|range| range.range_id == range_id)
-                                {
-                                    let mut range_record = text_range_to_proto(&cell.text, range);
-                                    range_record["kind"] = Value::String("textRange".to_string());
-                                    range_record["id"] = Value::String(id.to_string());
-                                    range_record["slide"] = Value::from(slide_index + 1);
-                                    range_record["slideIndex"] = Value::from(slide_index);
-                                    range_record["hostAnchor"] = Value::String(format!(
-                                        "tb/{}#cell/{row_index}/{column_index}",
-                                        table.element_id
-                                    ));
-                                    range_record["hostKind"] =
-                                        Value::String("tableCell".to_string());
-                                    return Ok(range_record);
-                                }
-                            }
-                        }
-                    }
-                    PresentationElement::Connector(_)
-                    | PresentationElement::Image(_)
-                    | PresentationElement::Chart(_) => {}
-                }
-            }
-        }
-    }
-
-    if let Some(thread_id) = id.strip_prefix("th/")
-        && let Some(thread) = document
-            .comment_threads
-            .iter()
-            .find(|thread| thread.thread_id == thread_id)
-    {
-        let mut record = comment_thread_to_proto(thread);
-        record["id"] = Value::String(id.to_string());
-        return Ok(record);
-    }
-
-    for layout in &document.layouts {
-        let layout_id = format!("ly/{}", layout.layout_id);
-        if id == layout_id {
-            return Ok(serde_json::json!({
-                "kind": "layout",
-                "id": layout_id,
-                "layoutId": layout.layout_id,
-                "name": layout.name,
-                "type": match layout.kind {
-                    LayoutKind::Layout => "layout",
-                    LayoutKind::Master => "master",
-                },
-                "parentLayoutId": layout.parent_layout_id,
-                "placeholders": layout_placeholder_list(document, &layout.layout_id, action)?,
-            }));
-        }
-    }
-
-    Err(PresentationArtifactError::UnsupportedFeature {
-        action: action.to_string(),
-        message: format!("unknown resolve id `{id}`"),
-    })
-}

codex-rs/artifact-presentation/src/presentation_artifact/mod.rs

@@ -1,10 +0,0 @@
-include!("api.rs");
-include!("manager.rs");
-include!("response.rs");
-include!("model.rs");
-include!("args.rs");
-include!("parsing.rs");
-include!("proto.rs");
-include!("inspect.rs");
-include!("pptx.rs");
-include!("snapshot.rs");

codex-rs/artifact-presentation/src/presentation_artifact/pptx.rs

@@ -1,951 +0,0 @@
-const CODEX_METADATA_ENTRY: &str = "ppt/codex-document.json";
-
-fn import_codex_metadata_document(path: &Path) -> Result<Option<PresentationDocument>, String> {
-    let file = std::fs::File::open(path).map_err(|error| error.to_string())?;
-    let mut archive = ZipArchive::new(file).map_err(|error| error.to_string())?;
-    let mut entry = match archive.by_name(CODEX_METADATA_ENTRY) {
-        Ok(entry) => entry,
-        Err(zip::result::ZipError::FileNotFound) => return Ok(None),
-        Err(error) => return Err(error.to_string()),
-    };
-    let mut bytes = Vec::new();
-    entry.read_to_end(&mut bytes)
-        .map_err(|error| error.to_string())?;
-    serde_json::from_slice(&bytes)
-        .map(Some)
-        .map_err(|error| error.to_string())
-}
-
-fn build_pptx_bytes(document: &PresentationDocument, action: &str) -> Result<Vec<u8>, String> {
-    let bytes = document
-        .to_ppt_rs()
-        .build()
-        .map_err(|error| format!("{action}: {error}"))?;
-    patch_pptx_package(bytes, document).map_err(|error| format!("{action}: {error}"))
-}
-
-struct SlideImageAsset {
-    xml: String,
-    relationship_xml: String,
-    media_path: String,
-    media_bytes: Vec<u8>,
-    extension: String,
-}
-
-fn normalized_image_extension(format: &str) -> String {
-    match format.to_ascii_lowercase().as_str() {
-        "jpeg" => "jpg".to_string(),
-        other => other.to_string(),
-    }
-}
-
-fn image_relationship_xml(relationship_id: &str, target: &str) -> String {
-    format!(
-        r#"<Relationship Id="{relationship_id}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="{}"/>"#,
-        ppt_rs::escape_xml(target)
-    )
-}
-
-fn image_picture_xml(
-    image: &ImageElement,
-    shape_id: usize,
-    relationship_id: &str,
-    frame: Rect,
-    crop: Option<ImageCrop>,
-) -> String {
-    let blip_fill = if let Some((crop_left, crop_top, crop_right, crop_bottom)) = crop {
-        format!(
-            r#"<p:blipFill>
-<a:blip r:embed="{relationship_id}"/>
-<a:srcRect l="{}" t="{}" r="{}" b="{}"/>
-<a:stretch>
-<a:fillRect/>
-</a:stretch>
-</p:blipFill>"#,
-            (crop_left * 100_000.0).round() as u32,
-            (crop_top * 100_000.0).round() as u32,
-            (crop_right * 100_000.0).round() as u32,
-            (crop_bottom * 100_000.0).round() as u32,
-        )
-    } else {
-        format!(
-            r#"<p:blipFill>
-<a:blip r:embed="{relationship_id}"/>
-<a:stretch>
-<a:fillRect/>
-</a:stretch>
-</p:blipFill>"#
-        )
-    };
-    let descr = image
-        .alt_text
-        .as_deref()
-        .map(|alt| format!(r#" descr="{}""#, ppt_rs::escape_xml(alt)))
-        .unwrap_or_default();
-    let no_change_aspect = if image.lock_aspect_ratio { 1 } else { 0 };
-    let rotation = image
-        .rotation_degrees
-        .map(|rotation| format!(r#" rot="{}""#, i64::from(rotation) * 60_000))
-        .unwrap_or_default();
-    let flip_horizontal = if image.flip_horizontal {
-        r#" flipH="1""#
-    } else {
-        ""
-    };
-    let flip_vertical = if image.flip_vertical {
-        r#" flipV="1""#
-    } else {
-        ""
-    };
-    format!(
-        r#"<p:pic>
-<p:nvPicPr>
-<p:cNvPr id="{shape_id}" name="Picture {shape_id}"{descr}/>
-<p:cNvPicPr>
-<a:picLocks noChangeAspect="{no_change_aspect}"/>
-</p:cNvPicPr>
-<p:nvPr/>
-</p:nvPicPr>
-{blip_fill}
-<p:spPr>
-<a:xfrm{rotation}{flip_horizontal}{flip_vertical}>
-<a:off x="{}" y="{}"/>
-<a:ext cx="{}" cy="{}"/>
-</a:xfrm>
-<a:prstGeom prst="rect">
-<a:avLst/>
-</a:prstGeom>
-</p:spPr>
-</p:pic>"#,
-        points_to_emu(frame.left),
-        points_to_emu(frame.top),
-        points_to_emu(frame.width),
-        points_to_emu(frame.height),
-    )
-}
-
-fn slide_image_assets(
-    slide: &PresentationSlide,
-    next_media_index: &mut usize,
-) -> Vec<SlideImageAsset> {
-    let mut ordered = slide.elements.iter().collect::<Vec<_>>();
-    ordered.sort_by_key(|element| element.z_order());
-    let shape_count = ordered
-        .iter()
-        .filter(|element| {
-            matches!(
-                element,
-                PresentationElement::Text(_)
-                    | PresentationElement::Shape(_)
-                    | PresentationElement::Image(ImageElement { payload: None, .. })
-            )
-        })
-        .count()
-        + usize::from(slide.background_fill.is_some());
-    let mut image_index = 0_usize;
-    let mut assets = Vec::new();
-    for element in ordered {
-        let PresentationElement::Image(image) = element else {
-            continue;
-        };
-        let Some(payload) = &image.payload else {
-            continue;
-        };
-        let (left, top, width, height, fitted_crop) = if image.fit_mode != ImageFitMode::Stretch {
-            fit_image(image)
-        } else {
-            (
-                image.frame.left,
-                image.frame.top,
-                image.frame.width,
-                image.frame.height,
-                None,
-            )
-        };
-        image_index += 1;
-        let relationship_id = format!("rIdImage{image_index}");
-        let extension = normalized_image_extension(&payload.format);
-        let media_name = format!("image{next_media_index}.{extension}");
-        *next_media_index += 1;
-        assets.push(SlideImageAsset {
-            xml: image_picture_xml(
-                image,
-                20 + shape_count + image_index - 1,
-                &relationship_id,
-                Rect {
-                    left,
-                    top,
-                    width,
-                    height,
-                },
-                image.crop.or(fitted_crop),
-            ),
-            relationship_xml: image_relationship_xml(
-                &relationship_id,
-                &format!("../media/{media_name}"),
-            ),
-            media_path: format!("ppt/media/{media_name}"),
-            media_bytes: payload.bytes.clone(),
-            extension,
-        });
-    }
-    assets
-}
-
-fn patch_pptx_package(
-    source_bytes: Vec<u8>,
-    document: &PresentationDocument,
-) -> Result<Vec<u8>, String> {
-    let mut archive =
-        ZipArchive::new(Cursor::new(source_bytes)).map_err(|error| error.to_string())?;
-    let mut writer = ZipWriter::new(Cursor::new(Vec::new()));
-    let mut next_media_index = 1_usize;
-    let mut pending_slide_relationships = HashMap::new();
-    let mut pending_slide_images = HashMap::new();
-    let mut pending_media = Vec::new();
-    let mut image_extensions = BTreeSet::new();
-    for (slide_index, slide) in document.slides.iter().enumerate() {
-        let slide_number = slide_index + 1;
-        let images = slide_image_assets(slide, &mut next_media_index);
-        let mut relationships = slide_hyperlink_relationships(slide);
-        relationships.extend(images.iter().map(|image| image.relationship_xml.clone()));
-        if !relationships.is_empty() {
-            pending_slide_relationships.insert(slide_number, relationships);
-        }
-        if !images.is_empty() {
-            image_extensions.extend(images.iter().map(|image| image.extension.clone()));
-            pending_media.extend(
-                images
-                    .iter()
-                    .map(|image| (image.media_path.clone(), image.media_bytes.clone())),
-            );
-            pending_slide_images.insert(slide_number, images);
-        }
-    }
-
-    for index in 0..archive.len() {
-        let mut file = archive.by_index(index).map_err(|error| error.to_string())?;
-        if file.is_dir() {
-            continue;
-        }
-        let name = file.name().to_string();
-        if name == CODEX_METADATA_ENTRY {
-            continue;
-        }
-        let options = file.options();
-        let mut bytes = Vec::new();
-        file.read_to_end(&mut bytes)
-            .map_err(|error| error.to_string())?;
-        writer
-            .start_file(&name, options)
-            .map_err(|error| error.to_string())?;
-        if name == "[Content_Types].xml" {
-            writer
-                .write_all(update_content_types_xml(bytes, &image_extensions)?.as_bytes())
-                .map_err(|error| error.to_string())?;
-            continue;
-        }
-        if name == "ppt/presentation.xml" {
-            writer
-                .write_all(
-                    update_presentation_xml_dimensions(bytes, document.slide_size)?.as_bytes(),
-                )
-                .map_err(|error| error.to_string())?;
-            continue;
-        }
-        if let Some(slide_number) = parse_slide_xml_path(&name) {
-            writer
-                .write_all(
-                    update_slide_xml(
-                        bytes,
-                        &document.slides[slide_number - 1],
-                        pending_slide_images
-                            .get(&slide_number)
-                            .map(std::vec::Vec::as_slice)
-                            .unwrap_or(&[]),
-                    )?
-                    .as_bytes(),
-                )
-                .map_err(|error| error.to_string())?;
-            continue;
-        }
-        if let Some(slide_number) = parse_slide_relationships_path(&name)
-            && let Some(relationships) = pending_slide_relationships.remove(&slide_number)
-        {
-            writer
-                .write_all(update_slide_relationships_xml(bytes, &relationships)?.as_bytes())
-                .map_err(|error| error.to_string())?;
-            continue;
-        }
-        writer
-            .write_all(&bytes)
-            .map_err(|error| error.to_string())?;
-    }
-
-    for (slide_number, relationships) in pending_slide_relationships {
-        writer
-            .start_file(
-                format!("ppt/slides/_rels/slide{slide_number}.xml.rels"),
-                SimpleFileOptions::default(),
-            )
-            .map_err(|error| error.to_string())?;
-        writer
-            .write_all(slide_relationships_xml(&relationships).as_bytes())
-            .map_err(|error| error.to_string())?;
-    }
-
-    for (path, bytes) in pending_media {
-        writer
-            .start_file(path, SimpleFileOptions::default())
-            .map_err(|error| error.to_string())?;
-        writer
-            .write_all(&bytes)
-            .map_err(|error| error.to_string())?;
-    }
-
-    writer
-        .start_file(CODEX_METADATA_ENTRY, SimpleFileOptions::default())
-        .map_err(|error| error.to_string())?;
-    writer
-        .write_all(
-            &serde_json::to_vec(document).map_err(|error| error.to_string())?,
-        )
-        .map_err(|error| error.to_string())?;
-
-    writer
-        .finish()
-        .map_err(|error| error.to_string())
-        .map(Cursor::into_inner)
-}
-
-fn update_presentation_xml_dimensions(
-    existing_bytes: Vec<u8>,
-    slide_size: Rect,
-) -> Result<String, String> {
-    let existing = String::from_utf8(existing_bytes).map_err(|error| error.to_string())?;
-    let updated = replace_self_closing_xml_tag(
-        &existing,
-        "p:sldSz",
-        &format!(
-            r#"<p:sldSz cx="{}" cy="{}" type="screen4x3"/>"#,
-            points_to_emu(slide_size.width),
-            points_to_emu(slide_size.height)
-        ),
-    )?;
-    replace_self_closing_xml_tag(
-        &updated,
-        "p:notesSz",
-        &format!(
-            r#"<p:notesSz cx="{}" cy="{}"/>"#,
-            points_to_emu(slide_size.height),
-            points_to_emu(slide_size.width)
-        ),
-    )
-}
-
-fn replace_self_closing_xml_tag(xml: &str, tag: &str, replacement: &str) -> Result<String, String> {
-    let start = xml
-        .find(&format!("<{tag} "))
-        .ok_or_else(|| format!("presentation xml is missing `<{tag} .../>`"))?;
-    let end = xml[start..]
-        .find("/>")
-        .map(|offset| start + offset + 2)
-        .ok_or_else(|| format!("presentation xml tag `{tag}` is not self-closing"))?;
-    Ok(format!("{}{replacement}{}", &xml[..start], &xml[end..]))
-}
-
-fn slide_hyperlink_relationships(slide: &PresentationSlide) -> Vec<String> {
-    let mut ordered = slide.elements.iter().collect::<Vec<_>>();
-    ordered.sort_by_key(|element| element.z_order());
-    let mut hyperlink_index = 1_u32;
-    let mut relationships = Vec::new();
-    for element in ordered {
-        let Some(hyperlink) = (match element {
-            PresentationElement::Text(text) => text.hyperlink.as_ref(),
-            PresentationElement::Shape(shape) => shape.hyperlink.as_ref(),
-            PresentationElement::Connector(_)
-            | PresentationElement::Image(_)
-            | PresentationElement::Table(_)
-            | PresentationElement::Chart(_) => None,
-        }) else {
-            continue;
-        };
-        let relationship_id = format!("rIdHyperlink{hyperlink_index}");
-        hyperlink_index += 1;
-        relationships.push(hyperlink.relationship_xml(&relationship_id));
-    }
-    relationships
-}
-
-fn parse_slide_relationships_path(path: &str) -> Option<usize> {
-    path.strip_prefix("ppt/slides/_rels/slide")?
-        .strip_suffix(".xml.rels")?
-        .parse::<usize>()
-        .ok()
-}
-
-fn parse_slide_xml_path(path: &str) -> Option<usize> {
-    path.strip_prefix("ppt/slides/slide")?
-        .strip_suffix(".xml")?
-        .parse::<usize>()
-        .ok()
-}
-
-fn update_slide_relationships_xml(
-    existing_bytes: Vec<u8>,
-    relationships: &[String],
-) -> Result<String, String> {
-    let existing = String::from_utf8(existing_bytes).map_err(|error| error.to_string())?;
-    let injected = relationships.join("\n");
-    existing
-        .contains("</Relationships>")
-        .then(|| existing.replace("</Relationships>", &format!("{injected}\n</Relationships>")))
-        .ok_or_else(|| {
-            "slide relationships xml is missing a closing `</Relationships>`".to_string()
-        })
-}
-
-fn slide_relationships_xml(relationships: &[String]) -> String {
-    let body = relationships.join("\n");
-    format!(
-        r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
-{body}
-</Relationships>"#
-    )
-}
-
-fn update_content_types_xml(
-    existing_bytes: Vec<u8>,
-    image_extensions: &BTreeSet<String>,
-) -> Result<String, String> {
-    let existing = String::from_utf8(existing_bytes).map_err(|error| error.to_string())?;
-    if image_extensions.is_empty() {
-        return Ok(existing);
-    }
-    let existing_lower = existing.to_ascii_lowercase();
-    let additions = image_extensions
-        .iter()
-        .filter(|extension| {
-            !existing_lower.contains(&format!(
-                r#"extension="{}""#,
-                extension.to_ascii_lowercase()
-            ))
-        })
-        .map(|extension| generate_image_content_type(extension))
-        .collect::<Vec<_>>();
-    if additions.is_empty() {
-        return Ok(existing);
-    }
-    existing
-        .contains("</Types>")
-        .then(|| existing.replace("</Types>", &format!("{}\n</Types>", additions.join("\n"))))
-        .ok_or_else(|| "content types xml is missing a closing `</Types>`".to_string())
-}
-
-fn update_slide_xml(
-    existing_bytes: Vec<u8>,
-    slide: &PresentationSlide,
-    slide_images: &[SlideImageAsset],
-) -> Result<String, String> {
-    let existing = String::from_utf8(existing_bytes).map_err(|error| error.to_string())?;
-    let existing = replace_image_placeholders(existing, slide_images)?;
-    let existing = apply_shape_block_patches(existing, slide)?;
-    let table_xml = slide_table_xml(slide);
-    if table_xml.is_empty() {
-        return Ok(existing);
-    }
-    existing
-        .contains("</p:spTree>")
-        .then(|| existing.replace("</p:spTree>", &format!("{table_xml}\n</p:spTree>")))
-        .ok_or_else(|| "slide xml is missing a closing `</p:spTree>`".to_string())
-}
-
-fn replace_image_placeholders(
-    existing: String,
-    slide_images: &[SlideImageAsset],
-) -> Result<String, String> {
-    if slide_images.is_empty() {
-        return Ok(existing);
-    }
-    let mut updated = String::with_capacity(existing.len());
-    let mut remaining = existing.as_str();
-    for image in slide_images {
-        let marker = remaining
-            .find("name=\"Image Placeholder: ")
-            .ok_or_else(|| {
-                "slide xml is missing an image placeholder block for exported images".to_string()
-            })?;
-        let start = remaining[..marker].rfind("<p:sp>").ok_or_else(|| {
-            "slide xml is missing an opening `<p:sp>` for image placeholder".to_string()
-        })?;
-        let end = remaining[marker..]
-            .find("</p:sp>")
-            .map(|offset| marker + offset + "</p:sp>".len())
-            .ok_or_else(|| {
-                "slide xml is missing a closing `</p:sp>` for image placeholder".to_string()
-            })?;
-        updated.push_str(&remaining[..start]);
-        updated.push_str(&image.xml);
-        remaining = &remaining[end..];
-    }
-    updated.push_str(remaining);
-    Ok(updated)
-}
-
-#[derive(Clone, Copy)]
-struct ShapeXmlPatch {
-    line_style: Option<LineStyle>,
-    flip_horizontal: bool,
-    flip_vertical: bool,
-}
-
-fn apply_shape_block_patches(
-    existing: String,
-    slide: &PresentationSlide,
-) -> Result<String, String> {
-    let mut patches = Vec::new();
-    if slide.background_fill.is_some() {
-        patches.push(None);
-    }
-    let mut ordered = slide.elements.iter().collect::<Vec<_>>();
-    ordered.sort_by_key(|element| element.z_order());
-    for element in ordered {
-        match element {
-            PresentationElement::Text(_) => patches.push(None),
-            PresentationElement::Shape(shape) => patches.push(Some(ShapeXmlPatch {
-                line_style: shape
-                    .stroke
-                    .as_ref()
-                    .map(|stroke| stroke.style)
-                    .filter(|style| *style != LineStyle::Solid),
-                flip_horizontal: shape.flip_horizontal,
-                flip_vertical: shape.flip_vertical,
-            })),
-            PresentationElement::Image(ImageElement { payload: None, .. }) => patches.push(None),
-            PresentationElement::Connector(_)
-            | PresentationElement::Image(_)
-            | PresentationElement::Table(_)
-            | PresentationElement::Chart(_) => {}
-        }
-    }
-    if patches.iter().all(|patch| {
-        patch.is_none_or(|patch| {
-            patch.line_style.is_none() && !patch.flip_horizontal && !patch.flip_vertical
-        })
-    }) {
-        return Ok(existing);
-    }
-
-    let mut updated = String::with_capacity(existing.len());
-    let mut remaining = existing.as_str();
-    for patch in patches {
-        let Some(start) = remaining.find("<p:sp>") else {
-            return Err("slide xml is missing an expected `<p:sp>` block".to_string());
-        };
-        let end = remaining[start..]
-            .find("</p:sp>")
-            .map(|offset| start + offset + "</p:sp>".len())
-            .ok_or_else(|| "slide xml is missing a closing `</p:sp>` block".to_string())?;
-        updated.push_str(&remaining[..start]);
-        let block = &remaining[start..end];
-        if let Some(patch) = patch {
-            updated.push_str(&patch_shape_block(block, patch)?);
-        } else {
-            updated.push_str(block);
-        }
-        remaining = &remaining[end..];
-    }
-    updated.push_str(remaining);
-    Ok(updated)
-}
-
-fn patch_shape_block(block: &str, patch: ShapeXmlPatch) -> Result<String, String> {
-    let block = if let Some(line_style) = patch.line_style {
-        patch_shape_block_dash(block, line_style)?
-    } else {
-        block.to_string()
-    };
-    if patch.flip_horizontal || patch.flip_vertical {
-        patch_shape_block_flip(&block, patch.flip_horizontal, patch.flip_vertical)
-    } else {
-        Ok(block)
-    }
-}
-
-fn patch_shape_block_dash(block: &str, line_style: LineStyle) -> Result<String, String> {
-    let Some(line_start) = block.find("<a:ln") else {
-        return Err("shape block is missing an `<a:ln>` entry for stroke styling".to_string());
-    };
-    if let Some(dash_start) = block[line_start..].find("<a:prstDash") {
-        let dash_start = line_start + dash_start;
-        let dash_end = block[dash_start..]
-            .find("/>")
-            .map(|offset| dash_start + offset + 2)
-            .ok_or_else(|| "shape line dash entry is missing a closing `/>`".to_string())?;
-        let mut patched = String::with_capacity(block.len() + 32);
-        patched.push_str(&block[..dash_start]);
-        patched.push_str(&format!(
-            r#"<a:prstDash val="{}"/>"#,
-            line_style.to_ppt_xml()
-        ));
-        patched.push_str(&block[dash_end..]);
-        return Ok(patched);
-    }
-
-    if let Some(line_end) = block[line_start..].find("</a:ln>") {
-        let line_end = line_start + line_end;
-        let mut patched = String::with_capacity(block.len() + 32);
-        patched.push_str(&block[..line_end]);
-        patched.push_str(&format!(
-            r#"<a:prstDash val="{}"/>"#,
-            line_style.to_ppt_xml()
-        ));
-        patched.push_str(&block[line_end..]);
-        return Ok(patched);
-    }
-
-    let line_end = block[line_start..]
-        .find("/>")
-        .map(|offset| line_start + offset + 2)
-        .ok_or_else(|| "shape line entry is missing a closing marker".to_string())?;
-    let line_tag = &block[line_start..line_end - 2];
-    let mut patched = String::with_capacity(block.len() + 48);
-    patched.push_str(&block[..line_start]);
-    patched.push_str(line_tag);
-    patched.push('>');
-    patched.push_str(&format!(
-        r#"<a:prstDash val="{}"/>"#,
-        line_style.to_ppt_xml()
-    ));
-    patched.push_str("</a:ln>");
-    patched.push_str(&block[line_end..]);
-    Ok(patched)
-}
-
-fn patch_shape_block_flip(
-    block: &str,
-    flip_horizontal: bool,
-    flip_vertical: bool,
-) -> Result<String, String> {
-    let Some(xfrm_start) = block.find("<a:xfrm") else {
-        return Err("shape block is missing an `<a:xfrm>` entry for flip styling".to_string());
-    };
-    let tag_end = block[xfrm_start..]
-        .find('>')
-        .map(|offset| xfrm_start + offset)
-        .ok_or_else(|| "shape transform entry is missing a closing `>`".to_string())?;
-    let tag = &block[xfrm_start..=tag_end];
-    let mut patched_tag = tag.to_string();
-    patched_tag = upsert_xml_attribute(
-        &patched_tag,
-        "flipH",
-        if flip_horizontal { "1" } else { "0" },
-    );
-    patched_tag =
-        upsert_xml_attribute(&patched_tag, "flipV", if flip_vertical { "1" } else { "0" });
-    Ok(format!(
-        "{}{}{}",
-        &block[..xfrm_start],
-        patched_tag,
-        &block[tag_end + 1..]
-    ))
-}
-
-fn upsert_xml_attribute(tag: &str, attribute: &str, value: &str) -> String {
-    let needle = format!(r#"{attribute}=""#);
-    if let Some(start) = tag.find(&needle) {
-        let value_start = start + needle.len();
-        if let Some(end_offset) = tag[value_start..].find('"') {
-            let end = value_start + end_offset;
-            return format!("{}{}{}", &tag[..value_start], value, &tag[end..]);
-        }
-    }
-    let insert_at = tag.len() - 1;
-    format!(r#"{} {attribute}="{value}""#, &tag[..insert_at]) + &tag[insert_at..]
-}
-
-fn slide_table_xml(slide: &PresentationSlide) -> String {
-    let mut ordered = slide.elements.iter().collect::<Vec<_>>();
-    ordered.sort_by_key(|element| element.z_order());
-    let mut table_index = 0_usize;
-    ordered
-        .into_iter()
-        .filter_map(|element| {
-            let PresentationElement::Table(table) = element else {
-                return None;
-            };
-            table_index += 1;
-            let rows = table
-                .rows
-                .clone()
-                .into_iter()
-                .enumerate()
-                .map(|(row_index, row)| {
-                    let cells = row
-                        .into_iter()
-                        .enumerate()
-                        .map(|(column_index, cell)| {
-                            build_table_cell(cell, &table.merges, row_index, column_index)
-                        })
-                        .collect::<Vec<_>>();
-                    let mut table_row = TableRow::new(cells);
-                    if let Some(height) = table.row_heights.get(row_index) {
-                        table_row = table_row.with_height(points_to_emu(*height));
-                    }
-                    Some(table_row)
-                })
-                .collect::<Option<Vec<_>>>()?;
-            Some(ppt_rs::generator::table::generate_table_xml(
-                &ppt_rs::generator::table::Table::new(
-                    rows,
-                    table
-                        .column_widths
-                        .iter()
-                        .copied()
-                        .map(points_to_emu)
-                        .collect(),
-                    points_to_emu(table.frame.left),
-                    points_to_emu(table.frame.top),
-                ),
-                300 + table_index,
-            ))
-        })
-        .collect::<Vec<_>>()
-        .join("\n")
-}
-
-fn write_preview_images(
-    document: &PresentationDocument,
-    output_dir: &Path,
-    action: &str,
-) -> Result<(), PresentationArtifactError> {
-    let pptx_path = output_dir.join("preview.pptx");
-    let bytes = build_pptx_bytes(document, action).map_err(|message| {
-        PresentationArtifactError::ExportFailed {
-            path: pptx_path.clone(),
-            message,
-        }
-    })?;
-    std::fs::write(&pptx_path, bytes).map_err(|error| PresentationArtifactError::ExportFailed {
-        path: pptx_path.clone(),
-        message: error.to_string(),
-    })?;
-    render_pptx_to_pngs(&pptx_path, output_dir, action)
-}
-
-fn render_pptx_to_pngs(
-    pptx_path: &Path,
-    output_dir: &Path,
-    action: &str,
-) -> Result<(), PresentationArtifactError> {
-    let soffice_cmd = if cfg!(target_os = "macos")
-        && Path::new("/Applications/LibreOffice.app/Contents/MacOS/soffice").exists()
-    {
-        "/Applications/LibreOffice.app/Contents/MacOS/soffice"
-    } else {
-        "soffice"
-    };
-    let conversion = Command::new(soffice_cmd)
-        .arg("--headless")
-        .arg("--convert-to")
-        .arg("pdf")
-        .arg(pptx_path)
-        .arg("--outdir")
-        .arg(output_dir)
-        .output()
-        .map_err(|error| PresentationArtifactError::ExportFailed {
-            path: pptx_path.to_path_buf(),
-            message: format!("{action}: failed to execute LibreOffice: {error}"),
-        })?;
-    if !conversion.status.success() {
-        return Err(PresentationArtifactError::ExportFailed {
-            path: pptx_path.to_path_buf(),
-            message: format!(
-                "{action}: LibreOffice conversion failed: {}",
-                String::from_utf8_lossy(&conversion.stderr)
-            ),
-        });
-    }
-
-    let pdf_path = output_dir.join(
-        pptx_path
-            .file_stem()
-            .and_then(|stem| stem.to_str())
-            .map(|stem| format!("{stem}.pdf"))
-            .ok_or_else(|| PresentationArtifactError::ExportFailed {
-                path: pptx_path.to_path_buf(),
-                message: format!("{action}: preview pptx filename is invalid"),
-            })?,
-    );
-    let prefix = output_dir.join("slide");
-    let conversion = Command::new("pdftoppm")
-        .arg("-png")
-        .arg(&pdf_path)
-        .arg(&prefix)
-        .output()
-        .map_err(|error| PresentationArtifactError::ExportFailed {
-            path: pdf_path.clone(),
-            message: format!("{action}: failed to execute pdftoppm: {error}"),
-        })?;
-    std::fs::remove_file(&pdf_path).ok();
-    if !conversion.status.success() {
-        return Err(PresentationArtifactError::ExportFailed {
-            path: output_dir.to_path_buf(),
-            message: format!(
-                "{action}: pdftoppm conversion failed: {}",
-                String::from_utf8_lossy(&conversion.stderr)
-            ),
-        });
-    }
-    Ok(())
-}
-
-pub(crate) fn write_preview_image(
-    source_path: &Path,
-    target_path: &Path,
-    format: PreviewOutputFormat,
-    scale: f32,
-    quality: u8,
-    action: &str,
-) -> Result<(), PresentationArtifactError> {
-    if matches!(format, PreviewOutputFormat::Png) && scale == 1.0 {
-        std::fs::rename(source_path, target_path).map_err(|error| {
-            PresentationArtifactError::ExportFailed {
-                path: target_path.to_path_buf(),
-                message: error.to_string(),
-            }
-        })?;
-        return Ok(());
-    }
-    let mut preview =
-        image::open(source_path).map_err(|error| PresentationArtifactError::ExportFailed {
-            path: source_path.to_path_buf(),
-            message: format!("{action}: {error}"),
-        })?;
-    if scale != 1.0 {
-        let width = (preview.width() as f32 * scale).round().max(1.0) as u32;
-        let height = (preview.height() as f32 * scale).round().max(1.0) as u32;
-        preview = preview.resize_exact(width, height, FilterType::Lanczos3);
-    }
-    let file = std::fs::File::create(target_path).map_err(|error| {
-        PresentationArtifactError::ExportFailed {
-            path: target_path.to_path_buf(),
-            message: error.to_string(),
-        }
-    })?;
-    let mut writer = std::io::BufWriter::new(file);
-    match format {
-        PreviewOutputFormat::Png => {
-            preview
-                .write_to(&mut writer, ImageFormat::Png)
-                .map_err(|error| PresentationArtifactError::ExportFailed {
-                    path: target_path.to_path_buf(),
-                    message: format!("{action}: {error}"),
-                })?
-        }
-        PreviewOutputFormat::Jpeg => {
-            let rgb = preview.to_rgb8();
-            let mut encoder = JpegEncoder::new_with_quality(&mut writer, quality);
-            encoder.encode_image(&rgb).map_err(|error| {
-                PresentationArtifactError::ExportFailed {
-                    path: target_path.to_path_buf(),
-                    message: format!("{action}: {error}"),
-                }
-            })?;
-        }
-        PreviewOutputFormat::Svg => {
-            let mut png_bytes = Cursor::new(Vec::new());
-            preview
-                .write_to(&mut png_bytes, ImageFormat::Png)
-                .map_err(|error| PresentationArtifactError::ExportFailed {
-                    path: target_path.to_path_buf(),
-                    message: format!("{action}: {error}"),
-                })?;
-            let embedded_png = BASE64_STANDARD.encode(png_bytes.into_inner());
-            let svg = format!(
-                r#"<svg xmlns="http://www.w3.org/2000/svg" width="{}" height="{}" viewBox="0 0 {} {}"><image href="data:image/png;base64,{embedded_png}" width="{}" height="{}"/></svg>"#,
-                preview.width(),
-                preview.height(),
-                preview.width(),
-                preview.height(),
-                preview.width(),
-                preview.height(),
-            );
-            writer.write_all(svg.as_bytes()).map_err(|error| {
-                PresentationArtifactError::ExportFailed {
-                    path: target_path.to_path_buf(),
-                    message: format!("{action}: {error}"),
-                }
-            })?;
-        }
-    }
-    std::fs::remove_file(source_path).ok();
-    Ok(())
-}
-
-fn collect_pngs(output_dir: &Path) -> Result<Vec<PathBuf>, PresentationArtifactError> {
-    let mut files = std::fs::read_dir(output_dir)
-        .map_err(|error| PresentationArtifactError::ExportFailed {
-            path: output_dir.to_path_buf(),
-            message: error.to_string(),
-        })?
-        .filter_map(Result::ok)
-        .map(|entry| entry.path())
-        .filter(|path| path.extension().and_then(|ext| ext.to_str()) == Some("png"))
-        .collect::<Vec<_>>();
-    files.sort();
-    Ok(files)
-}
-
-fn parse_preview_output_format(
-    format: Option<&str>,
-    path: &Path,
-    action: &str,
-) -> Result<PreviewOutputFormat, PresentationArtifactError> {
-    let value = format
-        .map(str::to_owned)
-        .or_else(|| {
-            path.extension()
-                .and_then(|extension| extension.to_str())
-                .map(str::to_owned)
-        })
-        .unwrap_or_else(|| "png".to_string());
-    match value.to_ascii_lowercase().as_str() {
-        "png" => Ok(PreviewOutputFormat::Png),
-        "jpg" | "jpeg" => Ok(PreviewOutputFormat::Jpeg),
-        "svg" => Ok(PreviewOutputFormat::Svg),
-        other => Err(PresentationArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: format!("preview format `{other}` is not supported"),
-        }),
-    }
-}
-
-fn normalize_preview_scale(
-    scale: Option<f32>,
-    action: &str,
-) -> Result<f32, PresentationArtifactError> {
-    let scale = scale.unwrap_or(1.0);
-    if !scale.is_finite() || scale <= 0.0 {
-        return Err(PresentationArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: "`scale` must be a positive number".to_string(),
-        });
-    }
-    Ok(scale)
-}
-
-fn normalize_preview_quality(
-    quality: Option<u8>,
-    action: &str,
-) -> Result<u8, PresentationArtifactError> {
-    let quality = quality.unwrap_or(90);
-    if quality == 0 || quality > 100 {
-        return Err(PresentationArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: "`quality` must be between 1 and 100".to_string(),
-        });
-    }
-    Ok(quality)
-}

codex-rs/artifact-presentation/src/presentation_artifact/proto.rs

@@ -1,614 +0,0 @@
-fn document_to_proto(
-    document: &PresentationDocument,
-    action: &str,
-) -> Result<Value, PresentationArtifactError> {
-    let layouts = document
-        .layouts
-        .iter()
-        .map(|layout| layout_to_proto(document, layout, action))
-        .collect::<Result<Vec<_>, _>>()?;
-    let slides = document
-        .slides
-        .iter()
-        .enumerate()
-        .map(|(slide_index, slide)| slide_to_proto(slide, slide_index))
-        .collect::<Vec<_>>();
-    Ok(serde_json::json!({
-        "kind": "presentation",
-        "artifactId": document.artifact_id,
-        "anchor": format!("pr/{}", document.artifact_id),
-        "name": document.name,
-        "slideSize": rect_to_proto(document.slide_size),
-        "activeSlideIndex": document.active_slide_index,
-        "activeSlideId": document.active_slide_index.and_then(|index| document.slides.get(index)).map(|slide| slide.slide_id.clone()),
-        "theme": serde_json::json!({
-            "colorScheme": document.theme.color_scheme,
-            "hexColorMap": document.theme.color_scheme,
-            "majorFont": document.theme.major_font,
-            "minorFont": document.theme.minor_font,
-        }),
-        "styles": document
-            .named_text_styles()
-            .iter()
-            .map(|style| named_text_style_to_json(style, "st"))
-            .collect::<Vec<_>>(),
-        "masters": document.layouts.iter().filter(|layout| layout.kind == LayoutKind::Master).map(|layout| layout.layout_id.clone()).collect::<Vec<_>>(),
-        "layouts": layouts,
-        "slides": slides,
-        "commentAuthor": document.comment_self.as_ref().map(comment_author_to_proto),
-        "commentThreads": document
-            .comment_threads
-            .iter()
-            .map(comment_thread_to_proto)
-            .collect::<Vec<_>>(),
-    }))
-}
-
-fn layout_to_proto(
-    document: &PresentationDocument,
-    layout: &LayoutDocument,
-    action: &str,
-) -> Result<Value, PresentationArtifactError> {
-    let placeholders = layout
-        .placeholders
-        .iter()
-        .map(placeholder_definition_to_proto)
-        .collect::<Vec<_>>();
-    let resolved_placeholders = resolved_layout_placeholders(document, &layout.layout_id, action)?
-        .into_iter()
-        .map(|placeholder| {
-            let mut value = placeholder_definition_to_proto(&placeholder.definition);
-            value["sourceLayoutId"] = Value::String(placeholder.source_layout_id);
-            value
-        })
-        .collect::<Vec<_>>();
-    Ok(serde_json::json!({
-        "layoutId": layout.layout_id,
-        "anchor": format!("ly/{}", layout.layout_id),
-        "name": layout.name,
-        "kind": match layout.kind {
-            LayoutKind::Layout => "layout",
-            LayoutKind::Master => "master",
-        },
-        "parentLayoutId": layout.parent_layout_id,
-        "placeholders": placeholders,
-        "resolvedPlaceholders": resolved_placeholders,
-    }))
-}
-
-fn placeholder_definition_to_proto(placeholder: &PlaceholderDefinition) -> Value {
-    serde_json::json!({
-        "name": placeholder.name,
-        "placeholderType": placeholder.placeholder_type,
-        "index": placeholder.index,
-        "text": placeholder.text,
-        "geometry": format!("{:?}", placeholder.geometry),
-        "frame": rect_to_proto(placeholder.frame),
-    })
-}
-
-fn slide_to_proto(slide: &PresentationSlide, slide_index: usize) -> Value {
-    serde_json::json!({
-        "slideId": slide.slide_id,
-        "anchor": format!("sl/{}", slide.slide_id),
-        "index": slide_index,
-        "layoutId": slide.layout_id,
-        "backgroundFill": slide.background_fill,
-        "notes": serde_json::json!({
-            "anchor": format!("nt/{}", slide.slide_id),
-            "text": slide.notes.text,
-            "visible": slide.notes.visible,
-            "textPreview": slide.notes.text.replace('\n', " | "),
-            "textChars": slide.notes.text.chars().count(),
-            "textLines": slide.notes.text.lines().count(),
-            "richText": rich_text_to_proto(&slide.notes.text, &slide.notes.rich_text),
-        }),
-        "elements": slide.elements.iter().map(element_to_proto).collect::<Vec<_>>(),
-    })
-}
-
-fn element_to_proto(element: &PresentationElement) -> Value {
-    match element {
-        PresentationElement::Text(text) => {
-            let mut record = serde_json::json!({
-                "kind": "text",
-                "elementId": text.element_id,
-                "anchor": format!("sh/{}", text.element_id),
-                "frame": rect_to_proto(text.frame),
-                "text": text.text,
-                "textPreview": text.text.replace('\n', " | "),
-                "textChars": text.text.chars().count(),
-                "textLines": text.text.lines().count(),
-                "fill": text.fill,
-                "style": text_style_to_proto(&text.style),
-                "richText": rich_text_to_proto(&text.text, &text.rich_text),
-                "zOrder": text.z_order,
-            });
-            if let Some(placeholder) = &text.placeholder {
-                record["placeholder"] = placeholder_ref_to_proto(placeholder);
-            }
-            if let Some(hyperlink) = &text.hyperlink {
-                record["hyperlink"] = hyperlink.to_json();
-            }
-            record
-        }
-        PresentationElement::Shape(shape) => {
-            let mut record = serde_json::json!({
-                "kind": "shape",
-                "elementId": shape.element_id,
-                "anchor": format!("sh/{}", shape.element_id),
-                "geometry": format!("{:?}", shape.geometry),
-                "frame": rect_to_proto(shape.frame),
-                "fill": shape.fill,
-                "stroke": shape.stroke.as_ref().map(stroke_to_proto),
-                "text": shape.text,
-                "textStyle": text_style_to_proto(&shape.text_style),
-                "richText": shape
-                    .text
-                    .as_ref()
-                    .zip(shape.rich_text.as_ref())
-                    .map(|(text, rich_text)| rich_text_to_proto(text, rich_text))
-                    .unwrap_or(Value::Null),
-                "rotation": shape.rotation_degrees,
-                "flipHorizontal": shape.flip_horizontal,
-                "flipVertical": shape.flip_vertical,
-                "zOrder": shape.z_order,
-            });
-            if let Some(text) = &shape.text {
-                record["textPreview"] = Value::String(text.replace('\n', " | "));
-                record["textChars"] = Value::from(text.chars().count());
-                record["textLines"] = Value::from(text.lines().count());
-            }
-            if let Some(placeholder) = &shape.placeholder {
-                record["placeholder"] = placeholder_ref_to_proto(placeholder);
-            }
-            if let Some(hyperlink) = &shape.hyperlink {
-                record["hyperlink"] = hyperlink.to_json();
-            }
-            record
-        }
-        PresentationElement::Connector(connector) => serde_json::json!({
-            "kind": "connector",
-            "elementId": connector.element_id,
-            "anchor": format!("cn/{}", connector.element_id),
-            "connectorType": format!("{:?}", connector.connector_type),
-            "start": serde_json::json!({
-                "left": connector.start.left,
-                "top": connector.start.top,
-                "unit": "points",
-            }),
-            "end": serde_json::json!({
-                "left": connector.end.left,
-                "top": connector.end.top,
-                "unit": "points",
-            }),
-            "line": stroke_to_proto(&connector.line),
-            "lineStyle": connector.line_style.as_api_str(),
-            "startArrow": format!("{:?}", connector.start_arrow),
-            "endArrow": format!("{:?}", connector.end_arrow),
-            "arrowSize": format!("{:?}", connector.arrow_size),
-            "label": connector.label,
-            "zOrder": connector.z_order,
-        }),
-        PresentationElement::Image(image) => {
-            let mut record = serde_json::json!({
-                "kind": "image",
-                "elementId": image.element_id,
-                "anchor": format!("im/{}", image.element_id),
-                "frame": rect_to_proto(image.frame),
-                "fit": format!("{:?}", image.fit_mode),
-                "crop": image.crop.map(|(left, top, right, bottom)| serde_json::json!({
-                    "left": left,
-                    "top": top,
-                    "right": right,
-                    "bottom": bottom,
-                })),
-                "rotation": image.rotation_degrees,
-                "flipHorizontal": image.flip_horizontal,
-                "flipVertical": image.flip_vertical,
-                "lockAspectRatio": image.lock_aspect_ratio,
-                "alt": image.alt_text,
-                "prompt": image.prompt,
-                "isPlaceholder": image.is_placeholder,
-                "payload": image.payload.as_ref().map(image_payload_to_proto),
-                "zOrder": image.z_order,
-            });
-            if let Some(placeholder) = &image.placeholder {
-                record["placeholder"] = placeholder_ref_to_proto(placeholder);
-            }
-            record
-        }
-        PresentationElement::Table(table) => serde_json::json!({
-            "kind": "table",
-            "elementId": table.element_id,
-            "anchor": format!("tb/{}", table.element_id),
-            "frame": rect_to_proto(table.frame),
-            "rows": table.rows.iter().map(|row| {
-                row.iter().map(table_cell_to_proto).collect::<Vec<_>>()
-            }).collect::<Vec<_>>(),
-            "columnWidths": table.column_widths,
-            "rowHeights": table.row_heights,
-            "style": table.style,
-            "styleOptions": table_style_options_to_proto(&table.style_options),
-            "borders": table.borders.as_ref().map(table_borders_to_proto),
-            "rightToLeft": table.right_to_left,
-            "merges": table.merges.iter().map(|merge| serde_json::json!({
-                "startRow": merge.start_row,
-                "endRow": merge.end_row,
-                "startColumn": merge.start_column,
-                "endColumn": merge.end_column,
-            })).collect::<Vec<_>>(),
-            "zOrder": table.z_order,
-        }),
-        PresentationElement::Chart(chart) => serde_json::json!({
-            "kind": "chart",
-            "elementId": chart.element_id,
-            "anchor": format!("ch/{}", chart.element_id),
-            "frame": rect_to_proto(chart.frame),
-            "chartType": format!("{:?}", chart.chart_type),
-            "title": chart.title,
-            "categories": chart.categories,
-            "styleIndex": chart.style_index,
-            "hasLegend": chart.has_legend,
-            "legend": chart.legend.as_ref().map(chart_legend_to_proto),
-            "xAxis": chart.x_axis.as_ref().map(chart_axis_to_proto),
-            "yAxis": chart.y_axis.as_ref().map(chart_axis_to_proto),
-            "dataLabels": chart.data_labels.as_ref().map(chart_data_labels_to_proto),
-            "chartFill": chart.chart_fill,
-            "plotAreaFill": chart.plot_area_fill,
-            "series": chart.series.iter().map(|series| serde_json::json!({
-                "name": series.name,
-                "values": series.values,
-                "categories": series.categories,
-                "xValues": series.x_values,
-                "fill": series.fill,
-                "stroke": series.stroke.as_ref().map(stroke_to_proto),
-                "marker": series.marker.as_ref().map(chart_marker_to_proto),
-                "dataLabelOverrides": series
-                    .data_label_overrides
-                    .iter()
-                    .map(chart_data_label_override_to_proto)
-                    .collect::<Vec<_>>(),
-            })).collect::<Vec<_>>(),
-            "zOrder": chart.z_order,
-        }),
-    }
-}
-
-fn rect_to_proto(rect: Rect) -> Value {
-    serde_json::json!({
-        "left": rect.left,
-        "top": rect.top,
-        "width": rect.width,
-        "height": rect.height,
-        "unit": "points",
-    })
-}
-
-fn stroke_to_proto(stroke: &StrokeStyle) -> Value {
-    serde_json::json!({
-        "color": stroke.color,
-        "width": stroke.width,
-        "style": stroke.style.as_api_str(),
-        "unit": "points",
-    })
-}
-
-fn text_style_to_proto(style: &TextStyle) -> Value {
-    serde_json::json!({
-        "styleName": style.style_name,
-        "fontSize": style.font_size,
-        "fontFamily": style.font_family,
-        "color": style.color,
-        "alignment": style.alignment,
-        "bold": style.bold,
-        "italic": style.italic,
-        "underline": style.underline,
-    })
-}
-
-fn rich_text_to_proto(text: &str, rich_text: &RichTextState) -> Value {
-    serde_json::json!({
-        "layout": text_layout_to_proto(&rich_text.layout),
-        "ranges": rich_text
-            .ranges
-            .iter()
-            .map(|range| text_range_to_proto(text, range))
-            .collect::<Vec<_>>(),
-    })
-}
-
-fn text_range_to_proto(text: &str, range: &TextRangeAnnotation) -> Value {
-    serde_json::json!({
-        "rangeId": range.range_id,
-        "anchor": format!("tr/{}", range.range_id),
-        "startCp": range.start_cp,
-        "length": range.length,
-        "text": text_slice_by_codepoint_range(text, range.start_cp, range.length),
-        "style": text_style_to_proto(&range.style),
-        "hyperlink": range.hyperlink.as_ref().map(HyperlinkState::to_json),
-        "spacingBefore": range.spacing_before,
-        "spacingAfter": range.spacing_after,
-        "lineSpacing": range.line_spacing,
-    })
-}
-
-fn text_layout_to_proto(layout: &TextLayoutState) -> Value {
-    serde_json::json!({
-        "insets": layout.insets.map(|insets| serde_json::json!({
-            "left": insets.left,
-            "right": insets.right,
-            "top": insets.top,
-            "bottom": insets.bottom,
-            "unit": "points",
-        })),
-        "wrap": layout.wrap.map(text_wrap_mode_to_proto),
-        "autoFit": layout.auto_fit.map(text_auto_fit_mode_to_proto),
-        "verticalAlignment": layout
-            .vertical_alignment
-            .map(text_vertical_alignment_to_proto),
-    })
-}
-
-fn text_wrap_mode_to_proto(mode: TextWrapMode) -> &'static str {
-    match mode {
-        TextWrapMode::Square => "square",
-        TextWrapMode::None => "none",
-    }
-}
-
-fn text_auto_fit_mode_to_proto(mode: TextAutoFitMode) -> &'static str {
-    match mode {
-        TextAutoFitMode::None => "none",
-        TextAutoFitMode::ShrinkText => "shrinkText",
-        TextAutoFitMode::ResizeShapeToFitText => "resizeShapeToFitText",
-    }
-}
-
-fn text_vertical_alignment_to_proto(alignment: TextVerticalAlignment) -> &'static str {
-    match alignment {
-        TextVerticalAlignment::Top => "top",
-        TextVerticalAlignment::Middle => "middle",
-        TextVerticalAlignment::Bottom => "bottom",
-    }
-}
-
-fn placeholder_ref_to_proto(placeholder: &PlaceholderRef) -> Value {
-    serde_json::json!({
-        "name": placeholder.name,
-        "placeholderType": placeholder.placeholder_type,
-        "index": placeholder.index,
-    })
-}
-
-fn image_payload_to_proto(payload: &ImagePayload) -> Value {
-    serde_json::json!({
-        "format": payload.format,
-        "widthPx": payload.width_px,
-        "heightPx": payload.height_px,
-        "bytesBase64": BASE64_STANDARD.encode(&payload.bytes),
-    })
-}
-
-fn table_cell_to_proto(cell: &TableCellSpec) -> Value {
-    serde_json::json!({
-        "text": cell.text,
-        "textStyle": text_style_to_proto(&cell.text_style),
-        "richText": rich_text_to_proto(&cell.text, &cell.rich_text),
-        "backgroundFill": cell.background_fill,
-        "alignment": cell.alignment,
-        "borders": cell.borders.as_ref().map(table_borders_to_proto),
-    })
-}
-
-fn table_style_options_to_proto(style_options: &TableStyleOptions) -> Value {
-    serde_json::json!({
-        "headerRow": style_options.header_row,
-        "bandedRows": style_options.banded_rows,
-        "bandedColumns": style_options.banded_columns,
-        "firstColumn": style_options.first_column,
-        "lastColumn": style_options.last_column,
-        "totalRow": style_options.total_row,
-    })
-}
-
-fn table_borders_to_proto(borders: &TableBorders) -> Value {
-    serde_json::json!({
-        "outside": borders.outside.as_ref().map(table_border_to_proto),
-        "inside": borders.inside.as_ref().map(table_border_to_proto),
-        "top": borders.top.as_ref().map(table_border_to_proto),
-        "bottom": borders.bottom.as_ref().map(table_border_to_proto),
-        "left": borders.left.as_ref().map(table_border_to_proto),
-        "right": borders.right.as_ref().map(table_border_to_proto),
-    })
-}
-
-fn table_border_to_proto(border: &TableBorder) -> Value {
-    serde_json::json!({
-        "color": border.color,
-        "width": border.width,
-        "unit": "points",
-    })
-}
-
-fn chart_marker_to_proto(marker: &ChartMarkerStyle) -> Value {
-    serde_json::json!({
-        "symbol": marker.symbol,
-        "size": marker.size,
-    })
-}
-
-fn chart_data_labels_to_proto(data_labels: &ChartDataLabels) -> Value {
-    serde_json::json!({
-        "showValue": data_labels.show_value,
-        "showCategoryName": data_labels.show_category_name,
-        "showLeaderLines": data_labels.show_leader_lines,
-        "position": data_labels.position,
-        "textStyle": text_style_to_proto(&data_labels.text_style),
-    })
-}
-
-fn chart_legend_to_proto(legend: &ChartLegend) -> Value {
-    serde_json::json!({
-        "position": legend.position,
-        "textStyle": text_style_to_proto(&legend.text_style),
-    })
-}
-
-fn chart_axis_to_proto(axis: &ChartAxisSpec) -> Value {
-    serde_json::json!({
-        "title": axis.title,
-    })
-}
-
-fn chart_data_label_override_to_proto(override_spec: &ChartDataLabelOverride) -> Value {
-    serde_json::json!({
-        "idx": override_spec.idx,
-        "text": override_spec.text,
-        "position": override_spec.position,
-        "textStyle": text_style_to_proto(&override_spec.text_style),
-        "fill": override_spec.fill,
-        "stroke": override_spec.stroke.as_ref().map(stroke_to_proto),
-    })
-}
-
-fn comment_author_to_proto(author: &CommentAuthorProfile) -> Value {
-    serde_json::json!({
-        "displayName": author.display_name,
-        "initials": author.initials,
-        "email": author.email,
-    })
-}
-
-fn comment_thread_to_proto(thread: &CommentThread) -> Value {
-    serde_json::json!({
-        "kind": "comment",
-        "threadId": thread.thread_id,
-        "anchor": format!("th/{}", thread.thread_id),
-        "target": comment_target_to_proto(&thread.target),
-        "position": thread.position.as_ref().map(comment_position_to_proto),
-        "status": comment_status_to_proto(thread.status),
-        "messages": thread.messages.iter().map(comment_message_to_proto).collect::<Vec<_>>(),
-    })
-}
-
-fn comment_target_to_proto(target: &CommentTarget) -> Value {
-    match target {
-        CommentTarget::Slide { slide_id } => serde_json::json!({
-            "type": "slide",
-            "slideId": slide_id,
-            "slideAnchor": format!("sl/{slide_id}"),
-        }),
-        CommentTarget::Element {
-            slide_id,
-            element_id,
-        } => serde_json::json!({
-            "type": "element",
-            "slideId": slide_id,
-            "slideAnchor": format!("sl/{slide_id}"),
-            "elementId": element_id,
-            "elementAnchor": format!("sh/{element_id}"),
-        }),
-        CommentTarget::TextRange {
-            slide_id,
-            element_id,
-            start_cp,
-            length,
-            context,
-        } => serde_json::json!({
-            "type": "textRange",
-            "slideId": slide_id,
-            "slideAnchor": format!("sl/{slide_id}"),
-            "elementId": element_id,
-            "elementAnchor": format!("sh/{element_id}"),
-            "startCp": start_cp,
-            "length": length,
-            "context": context,
-        }),
-    }
-}
-
-fn comment_position_to_proto(position: &CommentPosition) -> Value {
-    serde_json::json!({
-        "x": position.x,
-        "y": position.y,
-        "unit": "points",
-    })
-}
-
-fn comment_message_to_proto(message: &CommentMessage) -> Value {
-    serde_json::json!({
-        "messageId": message.message_id,
-        "author": comment_author_to_proto(&message.author),
-        "text": message.text,
-        "createdAt": message.created_at,
-        "reactions": message.reactions,
-    })
-}
-
-fn comment_status_to_proto(status: CommentThreadStatus) -> &'static str {
-    match status {
-        CommentThreadStatus::Active => "active",
-        CommentThreadStatus::Resolved => "resolved",
-    }
-}
-
-fn text_slice_by_codepoint_range(text: &str, start_cp: usize, length: usize) -> String {
-    text.chars().skip(start_cp).take(length).collect()
-}
-
-fn build_table_cell(
-    cell: TableCellSpec,
-    merges: &[TableMergeRegion],
-    row_index: usize,
-    column_index: usize,
-) -> TableCell {
-    let mut table_cell = TableCell::new(&cell.text);
-    if cell.text_style.bold {
-        table_cell = table_cell.bold();
-    }
-    if cell.text_style.italic {
-        table_cell = table_cell.italic();
-    }
-    if cell.text_style.underline {
-        table_cell = table_cell.underline();
-    }
-    if let Some(color) = cell.text_style.color {
-        table_cell = table_cell.text_color(&color);
-    }
-    if let Some(fill) = cell.background_fill {
-        table_cell = table_cell.background_color(&fill);
-    }
-    if let Some(size) = cell.text_style.font_size {
-        table_cell = table_cell.font_size(size);
-    }
-    if let Some(font_family) = cell.text_style.font_family {
-        table_cell = table_cell.font_family(&font_family);
-    }
-    if let Some(alignment) = cell.alignment.or(cell.text_style.alignment) {
-        table_cell = match alignment {
-            TextAlignment::Left => table_cell.align_left(),
-            TextAlignment::Center => table_cell.align_center(),
-            TextAlignment::Right => table_cell.align_right(),
-            TextAlignment::Justify => table_cell.align(CellAlign::Justify),
-        };
-    }
-    for merge in merges {
-        if row_index == merge.start_row && column_index == merge.start_column {
-            table_cell = table_cell
-                .grid_span((merge.end_column - merge.start_column + 1) as u32)
-                .row_span((merge.end_row - merge.start_row + 1) as u32);
-        } else if row_index >= merge.start_row
-            && row_index <= merge.end_row
-            && column_index >= merge.start_column
-            && column_index <= merge.end_column
-        {
-            if row_index == merge.start_row {
-                table_cell = table_cell.h_merge();
-            } else {
-                table_cell = table_cell.v_merge();
-            }
-        }
-    }
-    table_cell
-}

codex-rs/artifact-presentation/src/presentation_artifact/response.rs

@@ -1,138 +0,0 @@
-#[derive(Debug, Clone, Serialize)]
-pub struct PresentationArtifactResponse {
-    pub artifact_id: String,
-    pub action: String,
-    pub summary: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub executed_actions: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Vec::is_empty")]
-    pub exported_paths: Vec<PathBuf>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub artifact_snapshot: Option<ArtifactSnapshot>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub slide_list: Option<Vec<SlideListEntry>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub layout_list: Option<Vec<LayoutListEntry>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub placeholder_list: Option<Vec<PlaceholderListEntry>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub theme: Option<ThemeSnapshot>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub inspect_ndjson: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub resolved_record: Option<Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub proto_json: Option<Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub patch: Option<Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub active_slide_index: Option<usize>,
-}
-
-impl PresentationArtifactResponse {
-    fn new(
-        artifact_id: String,
-        action: String,
-        summary: String,
-        artifact_snapshot: ArtifactSnapshot,
-    ) -> Self {
-        Self {
-            artifact_id,
-            action,
-            summary,
-            executed_actions: None,
-            exported_paths: Vec::new(),
-            artifact_snapshot: Some(artifact_snapshot),
-            slide_list: None,
-            layout_list: None,
-            placeholder_list: None,
-            theme: None,
-            inspect_ndjson: None,
-            resolved_record: None,
-            proto_json: None,
-            patch: None,
-            active_slide_index: None,
-        }
-    }
-}
-
-fn response_for_document_state(
-    artifact_id: String,
-    action: String,
-    summary: String,
-    document: Option<&PresentationDocument>,
-) -> PresentationArtifactResponse {
-    PresentationArtifactResponse {
-        artifact_id,
-        action,
-        summary,
-        executed_actions: None,
-        exported_paths: Vec::new(),
-        artifact_snapshot: document.map(snapshot_for_document),
-        slide_list: None,
-        layout_list: None,
-        placeholder_list: None,
-        theme: document.map(PresentationDocument::theme_snapshot),
-        inspect_ndjson: None,
-        resolved_record: None,
-        proto_json: None,
-        patch: None,
-        active_slide_index: document.and_then(|current| current.active_slide_index),
-    }
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct ArtifactSnapshot {
-    pub slide_count: usize,
-    pub slides: Vec<SlideSnapshot>,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct SlideSnapshot {
-    pub slide_id: String,
-    pub index: usize,
-    pub element_ids: Vec<String>,
-    pub element_types: Vec<String>,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct SlideListEntry {
-    pub slide_id: String,
-    pub index: usize,
-    pub is_active: bool,
-    pub notes: Option<String>,
-    pub notes_visible: bool,
-    pub background_fill: Option<String>,
-    pub layout_id: Option<String>,
-    pub element_count: usize,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct LayoutListEntry {
-    pub layout_id: String,
-    pub name: String,
-    pub kind: String,
-    pub parent_layout_id: Option<String>,
-    pub placeholder_count: usize,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct PlaceholderListEntry {
-    pub scope: String,
-    pub source_layout_id: Option<String>,
-    pub slide_index: Option<usize>,
-    pub element_id: Option<String>,
-    pub name: String,
-    pub placeholder_type: String,
-    pub index: Option<u32>,
-    pub geometry: Option<String>,
-    pub text_preview: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct ThemeSnapshot {
-    pub color_scheme: HashMap<String, String>,
-    pub hex_color_map: HashMap<String, String>,
-    pub major_font: Option<String>,
-    pub minor_font: Option<String>,
-}

codex-rs/artifact-presentation/src/presentation_artifact/snapshot.rs

@@ -1,339 +0,0 @@
-fn cell_value_to_string(value: Value) -> String {
-    match value {
-        Value::Null => String::new(),
-        Value::String(text) => text,
-        Value::Bool(boolean) => boolean.to_string(),
-        Value::Number(number) => number.to_string(),
-        other => other.to_string(),
-    }
-}
-
-fn snapshot_for_document(document: &PresentationDocument) -> ArtifactSnapshot {
-    ArtifactSnapshot {
-        slide_count: document.slides.len(),
-        slides: document
-            .slides
-            .iter()
-            .enumerate()
-            .map(|(index, slide)| SlideSnapshot {
-                slide_id: slide.slide_id.clone(),
-                index,
-                element_ids: slide
-                    .elements
-                    .iter()
-                    .map(|element| element.element_id().to_string())
-                    .collect(),
-                element_types: slide
-                    .elements
-                    .iter()
-                    .map(|element| element.kind().to_string())
-                    .collect(),
-            })
-            .collect(),
-    }
-}
-
-fn slide_list(document: &PresentationDocument) -> Vec<SlideListEntry> {
-    document
-        .slides
-        .iter()
-        .enumerate()
-        .map(|(index, slide)| SlideListEntry {
-            slide_id: slide.slide_id.clone(),
-            index,
-            is_active: document.active_slide_index == Some(index),
-            notes: (slide.notes.visible && !slide.notes.text.is_empty())
-                .then(|| slide.notes.text.clone()),
-            notes_visible: slide.notes.visible,
-            background_fill: slide.background_fill.clone(),
-            layout_id: slide.layout_id.clone(),
-            element_count: slide.elements.len(),
-        })
-        .collect()
-}
-
-fn layout_list(document: &PresentationDocument) -> Vec<LayoutListEntry> {
-    document
-        .layouts
-        .iter()
-        .map(|layout| LayoutListEntry {
-            layout_id: layout.layout_id.clone(),
-            name: layout.name.clone(),
-            kind: match layout.kind {
-                LayoutKind::Layout => "layout".to_string(),
-                LayoutKind::Master => "master".to_string(),
-            },
-            parent_layout_id: layout.parent_layout_id.clone(),
-            placeholder_count: layout.placeholders.len(),
-        })
-        .collect()
-}
-
-fn points_to_emu(points: u32) -> u32 {
-    points.saturating_mul(POINT_TO_EMU)
-}
-
-fn emu_to_points(emu: u32) -> u32 {
-    emu / POINT_TO_EMU
-}
-
-type ImageCrop = (f64, f64, f64, f64);
-type FittedImage = (u32, u32, u32, u32, Option<ImageCrop>);
-
-pub(crate) fn fit_image(image: &ImageElement) -> FittedImage {
-    let Some(payload) = image.payload.as_ref() else {
-        return (
-            image.frame.left,
-            image.frame.top,
-            image.frame.width,
-            image.frame.height,
-            None,
-        );
-    };
-    let frame = image.frame;
-    let source_width = payload.width_px as f64;
-    let source_height = payload.height_px as f64;
-    let target_width = frame.width as f64;
-    let target_height = frame.height as f64;
-    let source_ratio = source_width / source_height;
-    let target_ratio = target_width / target_height;
-
-    match image.fit_mode {
-        ImageFitMode::Stretch => (frame.left, frame.top, frame.width, frame.height, None),
-        ImageFitMode::Contain => {
-            let scale = if source_ratio > target_ratio {
-                target_width / source_width
-            } else {
-                target_height / source_height
-            };
-            let width = (source_width * scale).round() as u32;
-            let height = (source_height * scale).round() as u32;
-            let left = frame.left + frame.width.saturating_sub(width) / 2;
-            let top = frame.top + frame.height.saturating_sub(height) / 2;
-            (left, top, width, height, None)
-        }
-        ImageFitMode::Cover => {
-            let scale = if source_ratio > target_ratio {
-                target_height / source_height
-            } else {
-                target_width / source_width
-            };
-            let width = source_width * scale;
-            let height = source_height * scale;
-            let crop_x = ((width - target_width).max(0.0) / width) / 2.0;
-            let crop_y = ((height - target_height).max(0.0) / height) / 2.0;
-            (
-                frame.left,
-                frame.top,
-                frame.width,
-                frame.height,
-                Some((crop_x, crop_y, crop_x, crop_y)),
-            )
-        }
-    }
-}
-
-fn normalize_image_crop(
-    crop: ImageCropArgs,
-    action: &str,
-) -> Result<ImageCrop, PresentationArtifactError> {
-    for (name, value) in [
-        ("left", crop.left),
-        ("top", crop.top),
-        ("right", crop.right),
-        ("bottom", crop.bottom),
-    ] {
-        if !(0.0..=1.0).contains(&value) {
-            return Err(PresentationArtifactError::InvalidArgs {
-                action: action.to_string(),
-                message: format!("image crop `{name}` must be between 0.0 and 1.0"),
-            });
-        }
-    }
-    Ok((crop.left, crop.top, crop.right, crop.bottom))
-}
-
-fn load_image_payload_from_path(
-    path: &Path,
-    action: &str,
-) -> Result<ImagePayload, PresentationArtifactError> {
-    let bytes = std::fs::read(path).map_err(|error| PresentationArtifactError::InvalidArgs {
-        action: action.to_string(),
-        message: format!("failed to read image `{}`: {error}", path.display()),
-    })?;
-    build_image_payload(
-        bytes,
-        path.file_name()
-            .and_then(|name| name.to_str())
-            .unwrap_or("image")
-            .to_string(),
-        action,
-    )
-}
-
-fn load_image_payload_from_data_url(
-    data_url: &str,
-    action: &str,
-) -> Result<ImagePayload, PresentationArtifactError> {
-    let (header, payload) =
-        data_url
-            .split_once(',')
-            .ok_or_else(|| PresentationArtifactError::InvalidArgs {
-                action: action.to_string(),
-                message: "data_url must include a MIME header and base64 payload".to_string(),
-            })?;
-    let mime = header
-        .strip_prefix("data:")
-        .and_then(|prefix| prefix.strip_suffix(";base64"))
-        .ok_or_else(|| PresentationArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: "data_url must be base64-encoded".to_string(),
-        })?;
-    let bytes = BASE64_STANDARD.decode(payload).map_err(|error| {
-        PresentationArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: format!("failed to decode image data_url: {error}"),
-        }
-    })?;
-    build_image_payload(
-        bytes,
-        format!("image.{}", image_extension_from_mime(mime)),
-        action,
-    )
-}
-
-fn load_image_payload_from_blob(
-    blob: &str,
-    action: &str,
-) -> Result<ImagePayload, PresentationArtifactError> {
-    let bytes = BASE64_STANDARD.decode(blob.trim()).map_err(|error| {
-        PresentationArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: format!("failed to decode image blob: {error}"),
-        }
-    })?;
-    let extension = image::guess_format(&bytes)
-        .ok()
-        .map(image_extension_from_format)
-        .unwrap_or("png");
-    build_image_payload(bytes, format!("image.{extension}"), action)
-}
-
-fn load_image_payload_from_uri(
-    uri: &str,
-    action: &str,
-) -> Result<ImagePayload, PresentationArtifactError> {
-    let response =
-        reqwest::blocking::get(uri).map_err(|error| PresentationArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: format!("failed to fetch image `{uri}`: {error}"),
-        })?;
-    let status = response.status();
-    if !status.is_success() {
-        return Err(PresentationArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: format!("failed to fetch image `{uri}`: HTTP {status}"),
-        });
-    }
-    let content_type = response
-        .headers()
-        .get(reqwest::header::CONTENT_TYPE)
-        .and_then(|value| value.to_str().ok())
-        .map(|value| value.split(';').next().unwrap_or(value).trim().to_string());
-    let bytes = response
-        .bytes()
-        .map_err(|error| PresentationArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: format!("failed to read image `{uri}`: {error}"),
-        })?;
-    build_image_payload(
-        bytes.to_vec(),
-        infer_remote_image_filename(uri, content_type.as_deref()),
-        action,
-    )
-}
-
-fn infer_remote_image_filename(uri: &str, content_type: Option<&str>) -> String {
-    let path_name = reqwest::Url::parse(uri)
-        .ok()
-        .and_then(|url| {
-            url.path_segments()
-                .and_then(Iterator::last)
-                .map(str::to_owned)
-        })
-        .filter(|segment| !segment.is_empty());
-    match (path_name, content_type) {
-        (Some(path_name), _) if Path::new(&path_name).extension().is_some() => path_name,
-        (Some(path_name), Some(content_type)) => {
-            format!("{path_name}.{}", image_extension_from_mime(content_type))
-        }
-        (Some(path_name), None) => path_name,
-        (None, Some(content_type)) => format!("image.{}", image_extension_from_mime(content_type)),
-        (None, None) => "image.png".to_string(),
-    }
-}
-
-fn build_image_payload(
-    bytes: Vec<u8>,
-    filename: String,
-    action: &str,
-) -> Result<ImagePayload, PresentationArtifactError> {
-    let image = image::load_from_memory(&bytes).map_err(|error| {
-        PresentationArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: format!("failed to decode image bytes: {error}"),
-        }
-    })?;
-    let (width_px, height_px) = image.dimensions();
-    let format = Path::new(&filename)
-        .extension()
-        .and_then(|extension| extension.to_str())
-        .unwrap_or("png")
-        .to_uppercase();
-    Ok(ImagePayload {
-        bytes,
-        format,
-        width_px,
-        height_px,
-    })
-}
-
-fn image_extension_from_mime(mime: &str) -> &'static str {
-    match mime {
-        "image/jpeg" => "jpg",
-        "image/gif" => "gif",
-        "image/webp" => "webp",
-        _ => "png",
-    }
-}
-
-fn image_extension_from_format(format: image::ImageFormat) -> &'static str {
-    match format {
-        image::ImageFormat::Jpeg => "jpg",
-        image::ImageFormat::Gif => "gif",
-        image::ImageFormat::WebP => "webp",
-        image::ImageFormat::Bmp => "bmp",
-        image::ImageFormat::Tiff => "tiff",
-        _ => "png",
-    }
-}
-
-fn index_out_of_range(action: &str, index: usize, len: usize) -> PresentationArtifactError {
-    PresentationArtifactError::InvalidArgs {
-        action: action.to_string(),
-        message: format!("slide index {index} is out of range for {len} slides"),
-    }
-}
-
-fn to_index(value: u32) -> Result<usize, PresentationArtifactError> {
-    usize::try_from(value).map_err(|_| PresentationArtifactError::InvalidArgs {
-        action: "insert_slide".to_string(),
-        message: "index does not fit in usize".to_string(),
-    })
-}
-
-fn resequence_z_order(slide: &mut PresentationSlide) {
-    for (index, element) in slide.elements.iter_mut().enumerate() {
-        element.set_z_order(index);
-    }
-}

codex-rs/artifact-spreadsheet/BUILD.bazel

@@ -1,6 +0,0 @@
-load("//:defs.bzl", "codex_rust_crate")
-
-codex_rust_crate(
-    name = "artifact-spreadsheet",
-    crate_name = "codex_artifact_spreadsheet",
-)

codex-rs/artifact-spreadsheet/Cargo.toml

@@ -1,25 +0,0 @@
-[package]
-name = "codex-artifact-spreadsheet"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-
-[lib]
-name = "codex_artifact_spreadsheet"
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-base64 = { workspace = true }
-regex = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
-thiserror = { workspace = true }
-uuid = { workspace = true, features = ["v4"] }
-zip = { workspace = true }
-
-[dev-dependencies]
-pretty_assertions = { workspace = true }
-tempfile = { workspace = true }

codex-rs/artifact-spreadsheet/src/address.rs

@@ -1,245 +0,0 @@
-use serde::Deserialize;
-use serde::Serialize;
-
-use crate::SpreadsheetArtifactError;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-pub struct CellAddress {
-    pub column: u32,
-    pub row: u32,
-}
-
-impl CellAddress {
-    pub fn parse(address: &str) -> Result<Self, SpreadsheetArtifactError> {
-        let trimmed = address.trim();
-        if trimmed.is_empty() {
-            return Err(SpreadsheetArtifactError::InvalidAddress {
-                address: address.to_string(),
-                message: "address is empty".to_string(),
-            });
-        }
-
-        let mut split = 0usize;
-        for (index, ch) in trimmed.char_indices() {
-            if ch.is_ascii_alphabetic() {
-                split = index + ch.len_utf8();
-            } else {
-                break;
-            }
-        }
-
-        let (letters, digits) = trimmed.split_at(split);
-        if letters.is_empty() || digits.is_empty() {
-            return Err(SpreadsheetArtifactError::InvalidAddress {
-                address: address.to_string(),
-                message: "expected A1-style address".to_string(),
-            });
-        }
-
-        if !letters.chars().all(|ch| ch.is_ascii_alphabetic())
-            || !digits.chars().all(|ch| ch.is_ascii_digit())
-        {
-            return Err(SpreadsheetArtifactError::InvalidAddress {
-                address: address.to_string(),
-                message: "expected letters followed by digits".to_string(),
-            });
-        }
-
-        let column = column_letters_to_index(letters)?;
-        let row = digits
-            .parse::<u32>()
-            .map_err(|_| SpreadsheetArtifactError::InvalidAddress {
-                address: address.to_string(),
-                message: "row must be a positive integer".to_string(),
-            })?;
-
-        if row == 0 {
-            return Err(SpreadsheetArtifactError::InvalidAddress {
-                address: address.to_string(),
-                message: "row must be positive".to_string(),
-            });
-        }
-
-        Ok(Self { column, row })
-    }
-
-    pub fn to_a1(self) -> String {
-        format!("{}{}", column_index_to_letters(self.column), self.row)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct CellRange {
-    pub start: CellAddress,
-    pub end: CellAddress,
-}
-
-impl CellRange {
-    pub fn parse(address: &str) -> Result<Self, SpreadsheetArtifactError> {
-        let trimmed = address.trim();
-        if trimmed.is_empty() {
-            return Err(SpreadsheetArtifactError::InvalidAddress {
-                address: address.to_string(),
-                message: "range is empty".to_string(),
-            });
-        }
-
-        let (start, end) = if let Some((left, right)) = trimmed.split_once(':') {
-            (CellAddress::parse(left)?, CellAddress::parse(right)?)
-        } else {
-            let cell = CellAddress::parse(trimmed)?;
-            (cell, cell)
-        };
-
-        let normalized = Self {
-            start: CellAddress {
-                column: start.column.min(end.column),
-                row: start.row.min(end.row),
-            },
-            end: CellAddress {
-                column: start.column.max(end.column),
-                row: start.row.max(end.row),
-            },
-        };
-        Ok(normalized)
-    }
-
-    pub fn from_start_end(start: CellAddress, end: CellAddress) -> Self {
-        Self {
-            start: CellAddress {
-                column: start.column.min(end.column),
-                row: start.row.min(end.row),
-            },
-            end: CellAddress {
-                column: start.column.max(end.column),
-                row: start.row.max(end.row),
-            },
-        }
-    }
-
-    pub fn to_a1(&self) -> String {
-        if self.is_single_cell() {
-            self.start.to_a1()
-        } else {
-            format!("{}:{}", self.start.to_a1(), self.end.to_a1())
-        }
-    }
-
-    pub fn is_single_cell(&self) -> bool {
-        self.start == self.end
-    }
-
-    pub fn is_single_row(&self) -> bool {
-        self.start.row == self.end.row
-    }
-
-    pub fn is_single_column(&self) -> bool {
-        self.start.column == self.end.column
-    }
-
-    pub fn width(&self) -> usize {
-        (self.end.column - self.start.column + 1) as usize
-    }
-
-    pub fn height(&self) -> usize {
-        (self.end.row - self.start.row + 1) as usize
-    }
-
-    pub fn contains(&self, address: CellAddress) -> bool {
-        self.start.column <= address.column
-            && address.column <= self.end.column
-            && self.start.row <= address.row
-            && address.row <= self.end.row
-    }
-
-    pub fn contains_range(&self, other: &CellRange) -> bool {
-        self.contains(other.start) && self.contains(other.end)
-    }
-
-    pub fn intersects(&self, other: &CellRange) -> bool {
-        !(self.end.column < other.start.column
-            || other.end.column < self.start.column
-            || self.end.row < other.start.row
-            || other.end.row < self.start.row)
-    }
-
-    pub fn addresses(&self) -> impl Iterator<Item = CellAddress> {
-        let range = self.clone();
-        (range.start.row..=range.end.row).flat_map(move |row| {
-            let range = range.clone();
-            (range.start.column..=range.end.column).map(move |column| CellAddress { column, row })
-        })
-    }
-}
-
-pub fn column_letters_to_index(column: &str) -> Result<u32, SpreadsheetArtifactError> {
-    let trimmed = column.trim();
-    if trimmed.is_empty() {
-        return Err(SpreadsheetArtifactError::InvalidAddress {
-            address: column.to_string(),
-            message: "column is empty".to_string(),
-        });
-    }
-
-    let mut result = 0u32;
-    for ch in trimmed.chars() {
-        if !ch.is_ascii_alphabetic() {
-            return Err(SpreadsheetArtifactError::InvalidAddress {
-                address: column.to_string(),
-                message: "column must contain only letters".to_string(),
-            });
-        }
-        result = result
-            .checked_mul(26)
-            .and_then(|value| value.checked_add((ch.to_ascii_uppercase() as u8 - b'A' + 1) as u32))
-            .ok_or_else(|| SpreadsheetArtifactError::InvalidAddress {
-                address: column.to_string(),
-                message: "column is too large".to_string(),
-            })?;
-    }
-    Ok(result)
-}
-
-pub fn column_index_to_letters(mut index: u32) -> String {
-    if index == 0 {
-        return String::new();
-    }
-
-    let mut letters = Vec::new();
-    while index > 0 {
-        let remainder = (index - 1) % 26;
-        letters.push((b'A' + remainder as u8) as char);
-        index = (index - 1) / 26;
-    }
-    letters.iter().rev().collect()
-}
-
-pub fn parse_column_reference(reference: &str) -> Result<(u32, u32), SpreadsheetArtifactError> {
-    let trimmed = reference.trim();
-    if let Some((left, right)) = trimmed.split_once(':') {
-        let start = column_letters_to_index(left)?;
-        let end = column_letters_to_index(right)?;
-        Ok((start.min(end), start.max(end)))
-    } else {
-        let column = column_letters_to_index(trimmed)?;
-        Ok((column, column))
-    }
-}
-
-pub fn is_valid_cell_reference(address: &str) -> bool {
-    CellAddress::parse(address).is_ok()
-}
-
-pub fn is_valid_range_reference(address: &str) -> bool {
-    CellRange::parse(address).is_ok()
-}
-
-pub fn is_valid_row_reference(address: &str) -> bool {
-    CellRange::parse(address)
-        .map(|range| range.is_single_row())
-        .unwrap_or(false)
-}
-
-pub fn is_valid_column_reference(address: &str) -> bool {
-    parse_column_reference(address).is_ok()
-}

codex-rs/artifact-spreadsheet/src/chart.rs

@@ -1,357 +0,0 @@
-use serde::Deserialize;
-use serde::Serialize;
-
-use crate::CellAddress;
-use crate::CellRange;
-use crate::SpreadsheetArtifactError;
-use crate::SpreadsheetSheet;
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum SpreadsheetChartType {
-    Area,
-    Bar,
-    Doughnut,
-    Line,
-    Pie,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum SpreadsheetChartLegendPosition {
-    Bottom,
-    Top,
-    Left,
-    Right,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct SpreadsheetChartLegend {
-    pub visible: bool,
-    pub position: SpreadsheetChartLegendPosition,
-    pub overlay: bool,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct SpreadsheetChartAxis {
-    pub linked_number_format: bool,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct SpreadsheetChartSeries {
-    pub id: u32,
-    pub name: Option<String>,
-    pub category_sheet_name: Option<String>,
-    pub category_range: String,
-    pub value_sheet_name: Option<String>,
-    pub value_range: String,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct SpreadsheetChart {
-    pub id: u32,
-    pub chart_type: SpreadsheetChartType,
-    pub source_sheet_name: Option<String>,
-    pub source_range: Option<String>,
-    pub title: Option<String>,
-    pub style_index: u32,
-    pub display_blanks_as: String,
-    pub legend: SpreadsheetChartLegend,
-    pub category_axis: SpreadsheetChartAxis,
-    pub value_axis: SpreadsheetChartAxis,
-    #[serde(default)]
-    pub series: Vec<SpreadsheetChartSeries>,
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct SpreadsheetChartLookup {
-    pub id: Option<u32>,
-    pub index: Option<usize>,
-}
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub struct SpreadsheetChartCreateOptions {
-    pub id: Option<u32>,
-    pub title: Option<String>,
-    pub legend_visible: Option<bool>,
-    pub legend_position: Option<SpreadsheetChartLegendPosition>,
-}
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub struct SpreadsheetChartProperties {
-    pub title: Option<String>,
-    pub legend_visible: Option<bool>,
-    pub legend_position: Option<SpreadsheetChartLegendPosition>,
-}
-
-impl SpreadsheetSheet {
-    pub fn list_charts(
-        &self,
-        range: Option<&CellRange>,
-    ) -> Result<Vec<SpreadsheetChart>, SpreadsheetArtifactError> {
-        Ok(self
-            .charts
-            .iter()
-            .filter(|chart| {
-                range.is_none_or(|target| {
-                    chart
-                        .source_range
-                        .as_deref()
-                        .map(CellRange::parse)
-                        .transpose()
-                        .ok()
-                        .flatten()
-                        .is_some_and(|chart_range| chart_range.intersects(target))
-                })
-            })
-            .cloned()
-            .collect())
-    }
-
-    pub fn get_chart(
-        &self,
-        action: &str,
-        lookup: SpreadsheetChartLookup,
-    ) -> Result<&SpreadsheetChart, SpreadsheetArtifactError> {
-        if let Some(id) = lookup.id {
-            return self
-                .charts
-                .iter()
-                .find(|chart| chart.id == id)
-                .ok_or_else(|| SpreadsheetArtifactError::InvalidArgs {
-                    action: action.to_string(),
-                    message: format!("chart id `{id}` was not found"),
-                });
-        }
-        if let Some(index) = lookup.index {
-            return self.charts.get(index).ok_or_else(|| {
-                SpreadsheetArtifactError::IndexOutOfRange {
-                    action: action.to_string(),
-                    index,
-                    len: self.charts.len(),
-                }
-            });
-        }
-        Err(SpreadsheetArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: "chart id or index is required".to_string(),
-        })
-    }
-
-    pub fn create_chart(
-        &mut self,
-        action: &str,
-        chart_type: SpreadsheetChartType,
-        source_sheet_name: Option<String>,
-        source_range: &CellRange,
-        options: SpreadsheetChartCreateOptions,
-    ) -> Result<u32, SpreadsheetArtifactError> {
-        if source_range.width() < 2 {
-            return Err(SpreadsheetArtifactError::InvalidArgs {
-                action: action.to_string(),
-                message: "chart source range must include at least two columns".to_string(),
-            });
-        }
-        let id = if let Some(id) = options.id {
-            if self.charts.iter().any(|chart| chart.id == id) {
-                return Err(SpreadsheetArtifactError::InvalidArgs {
-                    action: action.to_string(),
-                    message: format!("chart id `{id}` already exists"),
-                });
-            }
-            id
-        } else {
-            self.charts.iter().map(|chart| chart.id).max().unwrap_or(0) + 1
-        };
-        let series = (source_range.start.column + 1..=source_range.end.column)
-            .enumerate()
-            .map(|(index, value_column)| SpreadsheetChartSeries {
-                id: index as u32 + 1,
-                name: None,
-                category_sheet_name: source_sheet_name.clone(),
-                category_range: CellRange::from_start_end(
-                    source_range.start,
-                    CellAddress {
-                        column: source_range.start.column,
-                        row: source_range.end.row,
-                    },
-                )
-                .to_a1(),
-                value_sheet_name: source_sheet_name.clone(),
-                value_range: CellRange::from_start_end(
-                    CellAddress {
-                        column: value_column,
-                        row: source_range.start.row,
-                    },
-                    CellAddress {
-                        column: value_column,
-                        row: source_range.end.row,
-                    },
-                )
-                .to_a1(),
-            })
-            .collect::<Vec<_>>();
-        self.charts.push(SpreadsheetChart {
-            id,
-            chart_type,
-            source_sheet_name,
-            source_range: Some(source_range.to_a1()),
-            title: options.title,
-            style_index: 102,
-            display_blanks_as: "gap".to_string(),
-            legend: SpreadsheetChartLegend {
-                visible: options.legend_visible.unwrap_or(true),
-                position: options
-                    .legend_position
-                    .unwrap_or(SpreadsheetChartLegendPosition::Bottom),
-                overlay: false,
-            },
-            category_axis: SpreadsheetChartAxis {
-                linked_number_format: true,
-            },
-            value_axis: SpreadsheetChartAxis {
-                linked_number_format: true,
-            },
-            series,
-        });
-        Ok(id)
-    }
-
-    pub fn add_chart_series(
-        &mut self,
-        action: &str,
-        lookup: SpreadsheetChartLookup,
-        mut series: SpreadsheetChartSeries,
-    ) -> Result<u32, SpreadsheetArtifactError> {
-        validate_chart_series(action, &series)?;
-        let chart = self.get_chart_mut(action, lookup)?;
-        let next_id = chart.series.iter().map(|entry| entry.id).max().unwrap_or(0) + 1;
-        series.id = next_id;
-        chart.series.push(series);
-        Ok(next_id)
-    }
-
-    pub fn delete_chart(
-        &mut self,
-        action: &str,
-        lookup: SpreadsheetChartLookup,
-    ) -> Result<(), SpreadsheetArtifactError> {
-        let index = if let Some(id) = lookup.id {
-            self.charts
-                .iter()
-                .position(|chart| chart.id == id)
-                .ok_or_else(|| SpreadsheetArtifactError::InvalidArgs {
-                    action: action.to_string(),
-                    message: format!("chart id `{id}` was not found"),
-                })?
-        } else if let Some(index) = lookup.index {
-            if index >= self.charts.len() {
-                return Err(SpreadsheetArtifactError::IndexOutOfRange {
-                    action: action.to_string(),
-                    index,
-                    len: self.charts.len(),
-                });
-            }
-            index
-        } else {
-            return Err(SpreadsheetArtifactError::InvalidArgs {
-                action: action.to_string(),
-                message: "chart id or index is required".to_string(),
-            });
-        };
-        self.charts.remove(index);
-        Ok(())
-    }
-
-    pub fn set_chart_properties(
-        &mut self,
-        action: &str,
-        lookup: SpreadsheetChartLookup,
-        properties: SpreadsheetChartProperties,
-    ) -> Result<(), SpreadsheetArtifactError> {
-        let chart = self.get_chart_mut(action, lookup)?;
-        if let Some(title) = properties.title {
-            chart.title = Some(title);
-        }
-        if let Some(visible) = properties.legend_visible {
-            chart.legend.visible = visible;
-        }
-        if let Some(position) = properties.legend_position {
-            chart.legend.position = position;
-        }
-        Ok(())
-    }
-
-    pub fn validate_charts(&self, action: &str) -> Result<(), SpreadsheetArtifactError> {
-        for chart in &self.charts {
-            if let Some(source_range) = &chart.source_range {
-                let range = CellRange::parse(source_range)?;
-                if range.width() < 2 {
-                    return Err(SpreadsheetArtifactError::InvalidArgs {
-                        action: action.to_string(),
-                        message: format!(
-                            "chart `{}` source range `{source_range}` is too narrow",
-                            chart.id
-                        ),
-                    });
-                }
-            }
-            for series in &chart.series {
-                validate_chart_series(action, series)?;
-            }
-        }
-        Ok(())
-    }
-
-    fn get_chart_mut(
-        &mut self,
-        action: &str,
-        lookup: SpreadsheetChartLookup,
-    ) -> Result<&mut SpreadsheetChart, SpreadsheetArtifactError> {
-        if let Some(id) = lookup.id {
-            return self
-                .charts
-                .iter_mut()
-                .find(|chart| chart.id == id)
-                .ok_or_else(|| SpreadsheetArtifactError::InvalidArgs {
-                    action: action.to_string(),
-                    message: format!("chart id `{id}` was not found"),
-                });
-        }
-        if let Some(index) = lookup.index {
-            let len = self.charts.len();
-            return self.charts.get_mut(index).ok_or_else(|| {
-                SpreadsheetArtifactError::IndexOutOfRange {
-                    action: action.to_string(),
-                    index,
-                    len,
-                }
-            });
-        }
-        Err(SpreadsheetArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: "chart id or index is required".to_string(),
-        })
-    }
-}
-
-fn validate_chart_series(
-    action: &str,
-    series: &SpreadsheetChartSeries,
-) -> Result<(), SpreadsheetArtifactError> {
-    let category_range = CellRange::parse(&series.category_range)?;
-    let value_range = CellRange::parse(&series.value_range)?;
-    if !category_range.is_single_column() || !value_range.is_single_column() {
-        return Err(SpreadsheetArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: "chart category and value ranges must be single-column ranges".to_string(),
-        });
-    }
-    if category_range.height() != value_range.height() {
-        return Err(SpreadsheetArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: "chart category and value series lengths must match".to_string(),
-        });
-    }
-    Ok(())
-}

codex-rs/artifact-spreadsheet/src/conditional.rs

@@ -1,308 +0,0 @@
-use serde::Deserialize;
-use serde::Serialize;
-
-use crate::CellRange;
-use crate::SpreadsheetArtifact;
-use crate::SpreadsheetArtifactError;
-use crate::SpreadsheetSheet;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub enum SpreadsheetConditionalFormatType {
-    Expression,
-    CellIs,
-    ColorScale,
-    DataBar,
-    IconSet,
-    Top10,
-    UniqueValues,
-    DuplicateValues,
-    ContainsText,
-    NotContainsText,
-    BeginsWith,
-    EndsWith,
-    ContainsBlanks,
-    NotContainsBlanks,
-    ContainsErrors,
-    NotContainsErrors,
-    TimePeriod,
-    AboveAverage,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct SpreadsheetColorScale {
-    pub min_type: Option<String>,
-    pub mid_type: Option<String>,
-    pub max_type: Option<String>,
-    pub min_value: Option<String>,
-    pub mid_value: Option<String>,
-    pub max_value: Option<String>,
-    pub min_color: String,
-    pub mid_color: Option<String>,
-    pub max_color: String,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct SpreadsheetDataBar {
-    pub color: String,
-    pub min_length: Option<u8>,
-    pub max_length: Option<u8>,
-    pub show_value: Option<bool>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct SpreadsheetIconSet {
-    pub style: String,
-    pub show_value: Option<bool>,
-    pub reverse_order: Option<bool>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct SpreadsheetConditionalFormat {
-    pub id: u32,
-    pub range: String,
-    pub rule_type: SpreadsheetConditionalFormatType,
-    pub operator: Option<String>,
-    #[serde(default)]
-    pub formulas: Vec<String>,
-    pub text: Option<String>,
-    pub dxf_id: Option<u32>,
-    pub stop_if_true: bool,
-    pub priority: u32,
-    pub rank: Option<u32>,
-    pub percent: Option<bool>,
-    pub time_period: Option<String>,
-    pub above_average: Option<bool>,
-    pub equal_average: Option<bool>,
-    pub color_scale: Option<SpreadsheetColorScale>,
-    pub data_bar: Option<SpreadsheetDataBar>,
-    pub icon_set: Option<SpreadsheetIconSet>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct SpreadsheetConditionalFormatCollection {
-    pub sheet_name: String,
-    pub range: String,
-}
-
-impl SpreadsheetConditionalFormatCollection {
-    pub fn new(sheet_name: String, range: &CellRange) -> Self {
-        Self {
-            sheet_name,
-            range: range.to_a1(),
-        }
-    }
-
-    pub fn range(&self) -> Result<CellRange, SpreadsheetArtifactError> {
-        CellRange::parse(&self.range)
-    }
-
-    pub fn list(
-        &self,
-        artifact: &SpreadsheetArtifact,
-    ) -> Result<Vec<SpreadsheetConditionalFormat>, SpreadsheetArtifactError> {
-        let sheet = artifact.sheet_lookup(
-            "conditional_format_collection",
-            Some(&self.sheet_name),
-            None,
-        )?;
-        Ok(sheet.list_conditional_formats(Some(&self.range()?)))
-    }
-
-    pub fn add(
-        &self,
-        artifact: &mut SpreadsheetArtifact,
-        mut format: SpreadsheetConditionalFormat,
-    ) -> Result<u32, SpreadsheetArtifactError> {
-        format.range = self.range.clone();
-        artifact.add_conditional_format("conditional_format_collection", &self.sheet_name, format)
-    }
-
-    pub fn delete(
-        &self,
-        artifact: &mut SpreadsheetArtifact,
-        id: u32,
-    ) -> Result<(), SpreadsheetArtifactError> {
-        artifact.delete_conditional_format("conditional_format_collection", &self.sheet_name, id)
-    }
-}
-
-impl SpreadsheetArtifact {
-    pub fn validate_conditional_formats(
-        &self,
-        action: &str,
-        sheet_name: &str,
-    ) -> Result<(), SpreadsheetArtifactError> {
-        let sheet = self.sheet_lookup(action, Some(sheet_name), None)?;
-        for format in &sheet.conditional_formats {
-            validate_conditional_format(self, format, action)?;
-        }
-        Ok(())
-    }
-
-    pub fn add_conditional_format(
-        &mut self,
-        action: &str,
-        sheet_name: &str,
-        mut format: SpreadsheetConditionalFormat,
-    ) -> Result<u32, SpreadsheetArtifactError> {
-        validate_conditional_format(self, &format, action)?;
-        let sheet = self.sheet_lookup_mut(action, Some(sheet_name), None)?;
-        let next_id = sheet
-            .conditional_formats
-            .iter()
-            .map(|entry| entry.id)
-            .max()
-            .unwrap_or(0)
-            + 1;
-        format.id = next_id;
-        format.priority = if format.priority == 0 {
-            next_id
-        } else {
-            format.priority
-        };
-        sheet.conditional_formats.push(format);
-        Ok(next_id)
-    }
-
-    pub fn delete_conditional_format(
-        &mut self,
-        action: &str,
-        sheet_name: &str,
-        id: u32,
-    ) -> Result<(), SpreadsheetArtifactError> {
-        let sheet = self.sheet_lookup_mut(action, Some(sheet_name), None)?;
-        let previous_len = sheet.conditional_formats.len();
-        sheet.conditional_formats.retain(|entry| entry.id != id);
-        if sheet.conditional_formats.len() == previous_len {
-            return Err(SpreadsheetArtifactError::InvalidArgs {
-                action: action.to_string(),
-                message: format!("conditional format `{id}` was not found"),
-            });
-        }
-        Ok(())
-    }
-}
-
-impl SpreadsheetSheet {
-    pub fn conditional_format_collection(
-        &self,
-        range: &CellRange,
-    ) -> SpreadsheetConditionalFormatCollection {
-        SpreadsheetConditionalFormatCollection::new(self.name.clone(), range)
-    }
-
-    pub fn list_conditional_formats(
-        &self,
-        range: Option<&CellRange>,
-    ) -> Vec<SpreadsheetConditionalFormat> {
-        self.conditional_formats
-            .iter()
-            .filter(|entry| {
-                range.is_none_or(|target| {
-                    CellRange::parse(&entry.range)
-                        .map(|entry_range| entry_range.intersects(target))
-                        .unwrap_or(false)
-                })
-            })
-            .cloned()
-            .collect()
-    }
-}
-
-fn validate_conditional_format(
-    artifact: &SpreadsheetArtifact,
-    format: &SpreadsheetConditionalFormat,
-    action: &str,
-) -> Result<(), SpreadsheetArtifactError> {
-    CellRange::parse(&format.range)?;
-    if let Some(dxf_id) = format.dxf_id
-        && artifact.get_differential_format(dxf_id).is_none()
-    {
-        return Err(SpreadsheetArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: format!("differential format `{dxf_id}` was not found"),
-        });
-    }
-
-    let has_style = format.dxf_id.is_some();
-    let has_intrinsic_visual =
-        format.color_scale.is_some() || format.data_bar.is_some() || format.icon_set.is_some();
-
-    match format.rule_type {
-        SpreadsheetConditionalFormatType::Expression | SpreadsheetConditionalFormatType::CellIs => {
-            if format.formulas.is_empty() {
-                return Err(SpreadsheetArtifactError::InvalidArgs {
-                    action: action.to_string(),
-                    message: "conditional format formulas are required".to_string(),
-                });
-            }
-        }
-        SpreadsheetConditionalFormatType::ContainsText
-        | SpreadsheetConditionalFormatType::NotContainsText
-        | SpreadsheetConditionalFormatType::BeginsWith
-        | SpreadsheetConditionalFormatType::EndsWith => {
-            if format.text.as_deref().unwrap_or_default().is_empty() {
-                return Err(SpreadsheetArtifactError::InvalidArgs {
-                    action: action.to_string(),
-                    message: "conditional format text is required".to_string(),
-                });
-            }
-        }
-        SpreadsheetConditionalFormatType::ColorScale => {
-            if format.color_scale.is_none() {
-                return Err(SpreadsheetArtifactError::InvalidArgs {
-                    action: action.to_string(),
-                    message: "color scale settings are required".to_string(),
-                });
-            }
-        }
-        SpreadsheetConditionalFormatType::DataBar => {
-            if format.data_bar.is_none() {
-                return Err(SpreadsheetArtifactError::InvalidArgs {
-                    action: action.to_string(),
-                    message: "data bar settings are required".to_string(),
-                });
-            }
-        }
-        SpreadsheetConditionalFormatType::IconSet => {
-            if format.icon_set.is_none() {
-                return Err(SpreadsheetArtifactError::InvalidArgs {
-                    action: action.to_string(),
-                    message: "icon set settings are required".to_string(),
-                });
-            }
-        }
-        SpreadsheetConditionalFormatType::Top10 => {
-            if format.rank.is_none() {
-                return Err(SpreadsheetArtifactError::InvalidArgs {
-                    action: action.to_string(),
-                    message: "top10 rank is required".to_string(),
-                });
-            }
-        }
-        SpreadsheetConditionalFormatType::TimePeriod => {
-            if format.time_period.as_deref().unwrap_or_default().is_empty() {
-                return Err(SpreadsheetArtifactError::InvalidArgs {
-                    action: action.to_string(),
-                    message: "time period is required".to_string(),
-                });
-            }
-        }
-        SpreadsheetConditionalFormatType::AboveAverage => {}
-        SpreadsheetConditionalFormatType::UniqueValues
-        | SpreadsheetConditionalFormatType::DuplicateValues
-        | SpreadsheetConditionalFormatType::ContainsBlanks
-        | SpreadsheetConditionalFormatType::NotContainsBlanks
-        | SpreadsheetConditionalFormatType::ContainsErrors
-        | SpreadsheetConditionalFormatType::NotContainsErrors => {}
-    }
-
-    if !has_style && !has_intrinsic_visual {
-        return Err(SpreadsheetArtifactError::InvalidArgs {
-            action: action.to_string(),
-            message: "conditional formatting requires at least one style component".to_string(),
-        });
-    }
-    Ok(())
-}

codex-rs/artifact-spreadsheet/src/error.rs

@@ -1,39 +0,0 @@
-use std::path::PathBuf;
-
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum SpreadsheetArtifactError {
-    #[error("missing `artifact_id` for action `{action}`")]
-    MissingArtifactId { action: String },
-    #[error("unknown artifact id `{artifact_id}` for action `{action}`")]
-    UnknownArtifactId { action: String, artifact_id: String },
-    #[error("unknown action `{0}`")]
-    UnknownAction(String),
-    #[error("invalid args for action `{action}`: {message}")]
-    InvalidArgs { action: String, message: String },
-    #[error("invalid address `{address}`: {message}")]
-    InvalidAddress { address: String, message: String },
-    #[error("sheet lookup failed for action `{action}`: {message}")]
-    SheetLookup { action: String, message: String },
-    #[error("index `{index}` is out of range for action `{action}`; len={len}")]
-    IndexOutOfRange {
-        action: String,
-        index: usize,
-        len: usize,
-    },
-    #[error("merge conflict for action `{action}` on range `{range}` with `{conflict}`")]
-    MergeConflict {
-        action: String,
-        range: String,
-        conflict: String,
-    },
-    #[error("formula error at `{location}`: {message}")]
-    Formula { location: String, message: String },
-    #[error("serialization failed: {message}")]
-    Serialization { message: String },
-    #[error("failed to import XLSX `{path}`: {message}")]
-    ImportFailed { path: PathBuf, message: String },
-    #[error("failed to export XLSX `{path}`: {message}")]
-    ExportFailed { path: PathBuf, message: String },
-}