Merge remote-tracking branch 'origin/main' into easong/mcp-CLI-interface

.github/ISSUE_TEMPLATE/5-vs-code-extension.yml

@@ -1,50 +0,0 @@
-name: 🧑‍💻 VS Code Extension
-description: Report an issue with the VS Code extension
-labels:
-  - extension
-  - needs triage
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Before submitting a new issue, please search for existing issues to see if your issue has already been reported.
-        If it has, please add a 👍 reaction (no need to leave a comment) to the existing issue instead of creating a new one.
-
-  - type: input
-    id: version
-    attributes:
-      label: What version of the VS Code extension are you using?
-  - type: input
-    id: ide
-    attributes:
-      label: Which IDE are you using?
-      description: Like `VS Code`, `Cursor`, `Windsurf`, etc.
-  - type: input
-    id: platform
-    attributes:
-      label: What platform is your computer?
-      description: |
-        For MacOS and Linux: copy the output of `uname -mprs`
-        For Windows: copy the output of `"$([Environment]::OSVersion | ForEach-Object VersionString) $(if ([Environment]::Is64BitOperatingSystem) { "x64" } else { "x86" })"` in the PowerShell console
-  - type: textarea
-    id: steps
-    attributes:
-      label: What steps can reproduce the bug?
-      description: Explain the bug and provide a code snippet that can reproduce it.
-    validations:
-      required: true
-  - type: textarea
-    id: expected
-    attributes:
-      label: What is the expected behavior?
-      description: If possible, please provide text instead of a screenshot.
-  - type: textarea
-    id: actual
-    attributes:
-      label: What do you see instead?
-      description: If possible, please provide text instead of a screenshot.
-  - type: textarea
-    id: notes
-    attributes:
-      label: Additional information
-      description: Is there anything else you think we should know?

.github/dotslash-config.json

@@ -21,10 +21,6 @@
         "windows-x86_64": {
           "regex": "^codex-x86_64-pc-windows-msvc\\.exe\\.zst$",
           "path": "codex.exe"
-        },
-        "windows-aarch64": {
-          "regex": "^codex-aarch64-pc-windows-msvc\\.exe\\.zst$",
-          "path": "codex.exe"
         }
       }
     }

.github/pull_request_template.md

@@ -1,6 +1,6 @@
 # External (non-OpenAI) Pull Request Requirements
 
-Before opening this Pull Request, please read the dedicated "Contributing" markdown file or your PR may be closed:
-https://github.com/openai/codex/blob/main/docs/contributing.md
+Before opening this Pull Request, please read the "Contributing" section of the README or your PR may be closed:
+https://github.com/openai/codex#contributing
 
 If your PR conforms to our contribution guidelines, replace this text with a detailed and high quality description of your changes.

.github/workflows/rust-ci.yml

@@ -100,26 +100,15 @@ jobs:
           - runner: windows-latest
             target: x86_64-pc-windows-msvc
             profile: dev
-          - runner: windows-11-arm
-            target: aarch64-pc-windows-msvc
-            profile: dev
 
           # Also run representative release builds on Mac and Linux because
           # there could be release-only build errors we want to catch.
-          # Hopefully this also pre-populates the build cache to speed up
-          # releases.
           - runner: macos-14
             target: aarch64-apple-darwin
             profile: release
           - runner: ubuntu-24.04
             target: x86_64-unknown-linux-musl
             profile: release
-          - runner: windows-latest
-            target: x86_64-pc-windows-msvc
-            profile: release
-          - runner: windows-11-arm
-            target: aarch64-pc-windows-msvc
-            profile: release
 
     steps:
       - uses: actions/checkout@v5
@@ -145,7 +134,7 @@ jobs:
 
       - name: cargo clippy
         id: clippy
-        run: cargo clippy --target ${{ matrix.target }} --all-features --tests --profile ${{ matrix.profile }} -- -D warnings
+        run: cargo clippy --target ${{ matrix.target }} --all-features --tests -- -D warnings
 
       # Running `cargo build` from the workspace root builds the workspace using
       # the union of all features from third-party crates. This can mask errors

.github/workflows/rust-release.yml

@@ -72,8 +72,6 @@ jobs:
             target: aarch64-unknown-linux-gnu
           - runner: windows-latest
             target: x86_64-pc-windows-msvc
-          - runner: windows-11-arm
-            target: aarch64-pc-windows-msvc
 
     steps:
       - uses: actions/checkout@v5
@@ -89,7 +87,7 @@ jobs:
             ~/.cargo/registry/cache/
             ~/.cargo/git/db/
             ${{ github.workspace }}/codex-rs/target/
-          key: cargo-${{ matrix.runner }}-${{ matrix.target }}-release-${{ hashFiles('**/Cargo.lock') }}
+          key: cargo-release-${{ matrix.runner }}-${{ matrix.target }}-release-${{ hashFiles('**/Cargo.lock') }}
 
       - if: ${{ matrix.target == 'x86_64-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl'}}
         name: Install musl build tools
@@ -111,11 +109,6 @@ jobs:
             cp target/${{ matrix.target }}/release/codex "$dest/codex-${{ matrix.target }}"
           fi
 
-      - if: ${{ matrix.runner == 'windows-11-arm' }}
-        name: Install zstd
-        shell: powershell
-        run: choco install -y zstandard
-
       - name: Compress artifacts
         shell: bash
         run: |

AGENTS.md

@@ -8,7 +8,7 @@ In the codex-rs folder where the rust code lives:
   - You operate in a sandbox where `CODEX_SANDBOX_NETWORK_DISABLED=1` will be set whenever you use the `shell` tool. Any existing code that uses `CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR` was authored with this fact in mind. It is often used to early exit out of tests that the author knew you would not be able to run given your sandbox limitations.
   - Similarly, when you spawn a process using Seatbelt (`/usr/bin/sandbox-exec`), `CODEX_SANDBOX=seatbelt` will be set on the child process. Integration tests that want to run Seatbelt themselves cannot be run under Seatbelt, so checks for `CODEX_SANDBOX=seatbelt` are also often used to early exit out of tests, as appropriate.
 
-Before finalizing a change to `codex-rs`, run `just fmt` (in `codex-rs` directory) to format the code and `just fix -p <project>` (in `codex-rs` directory) to fix any linter issues in the code. Prefer scoping with `-p` to avoid slow workspace‑wide Clippy builds; only run `just fix` without `-p` if you changed shared crates. Additionally, run the tests:
+Before finalizing a change to `codex-rs`, run `just fmt` (in `codex-rs` directory) to format the code and `just fix -p <project>` (in `codex-rs` directory) to fix any linter issues in the code. Additionally, run the tests:
 1. Run the test for the specific project that was changed. For example, if changes were made in `codex-rs/tui`, run `cargo test -p codex-tui`.
 2. Once those pass, if any changes were made in common, core, or protocol, run the complete test suite with `cargo test --all-features`.
 When running interactively, ask the user before running these commands to finalize.
@@ -26,17 +26,6 @@ See `codex-rs/tui/styles.md`.
   - Example: patch summary file lines
     - Desired: vec!["  └ ".into(), "M".red(), " ".dim(), "tui/src/app.rs".dim()]
 
-### TUI Styling (ratatui)
-- Prefer Stylize helpers: use "text".dim(), .bold(), .cyan(), .italic(), .underlined() instead of manual Style where possible.
-- Prefer simple conversions: use "text".into() for spans and vec![…].into() for lines; when inference is ambiguous (e.g., Paragraph::new/Cell::from), use Line::from(spans) or Span::from(text).
-- Computed styles: if the Style is computed at runtime, using `Span::styled` is OK (`Span::from(text).set_style(style)` is also acceptable).
-- Avoid hardcoded white: do not use `.white()`; prefer the default foreground (no color).
-- Chaining: combine helpers by chaining for readability (e.g., url.cyan().underlined()).
-- Single items: prefer "text".into(); use Line::from(text) or Span::from(text) only when the target type isn’t obvious from context, or when using .into() would require extra type annotations.
-- Building lines: use vec![…].into() to construct a Line when the target type is obvious and no extra type annotations are needed; otherwise use Line::from(vec![…]).
-- Avoid churn: don’t refactor between equivalent forms (Span::styled ↔ set_style, Line::from ↔ .into()) without a clear readability or functional gain; follow file‑local conventions and do not introduce type annotations solely to satisfy .into().
-- Compactness: prefer the form that stays on one line after rustfmt; if only one of Line::from(vec![…]) or vec![…].into() avoids wrapping, choose that. If both wrap, pick the one with fewer wrapped lines.
-
 ## Snapshot tests
 
 This repo uses snapshot tests (via `insta`), especially in `codex-rs/tui`, to validate rendered output. When UI or text output changes intentionally, update the snapshots as follows:

CHANGELOG.md

@@ -1 +1,211 @@
-The changelog can be found on the [releases page](https://github.com/openai/codex/releases)
+# Changelog
+
+You can install any of these versions: `npm install -g codex@version`
+
+## `0.1.2505172129`
+
+### 🪲 Bug Fixes
+
+- Add node version check (#1007)
+- Persist token after refresh (#1006)
+
+## `0.1.2505171619`
+
+- `codex --login` + `codex --free` (#998)
+
+## `0.1.2505161800`
+
+- Sign in with chatgpt credits (#974)
+- Add support for OpenAI tool type, local_shell (#961)
+
+## `0.1.2505161243`
+
+- Sign in with chatgpt (#963)
+- Session history viewer (#912)
+- Apply patch issue when using different cwd (#942)
+- Diff command for filenames with special characters (#954)
+
+## `0.1.2505160811`
+
+- `codex-mini-latest` (#951)
+
+## `0.1.2505140839`
+
+### 🪲 Bug Fixes
+
+- Gpt-4.1 apply_patch handling (#930)
+- Add support for fileOpener in config.json (#911)
+- Patch in #366 and #367 for marked-terminal (#916)
+- Remember to set lastIndex = 0 on shared RegExp (#918)
+- Always load version from package.json at runtime (#909)
+- Tweak the label for citations for better rendering (#919)
+- Tighten up some logic around session timestamps and ids (#922)
+- Change EventMsg enum so every variant takes a single struct (#925)
+- Reasoning default to medium, show workdir when supplied (#931)
+- Test_dev_null_write() was not using echo as intended (#923)
+
+## `0.1.2504301751`
+
+### 🚀 Features
+
+- User config api key (#569)
+- `@mention` files in codex (#701)
+- Add `--reasoning` CLI flag (#314)
+- Lower default retry wait time and increase number of tries (#720)
+- Add common package registries domains to allowed-domains list (#414)
+
+### 🪲 Bug Fixes
+
+- Insufficient quota message (#758)
+- Input keyboard shortcut opt+delete (#685)
+- `/diff` should include untracked files (#686)
+- Only allow running without sandbox if explicitly marked in safe container (#699)
+- Tighten up check for /usr/bin/sandbox-exec (#710)
+- Check if sandbox-exec is available (#696)
+- Duplicate messages in quiet mode (#680)
+
+## `0.1.2504251709`
+
+### 🚀 Features
+
+- Add openai model info configuration (#551)
+- Added provider to run quiet mode function (#571)
+- Create parent directories when creating new files (#552)
+- Print bug report URL in terminal instead of opening browser (#510) (#528)
+- Add support for custom provider configuration in the user config (#537)
+- Add support for OpenAI-Organization and OpenAI-Project headers (#626)
+- Add specific instructions for creating API keys in error msg (#581)
+- Enhance toCodePoints to prevent potential unicode 14 errors (#615)
+- More native keyboard navigation in multiline editor (#655)
+- Display error on selection of invalid model (#594)
+
+### 🪲 Bug Fixes
+
+- Model selection (#643)
+- Nits in apply patch (#640)
+- Input keyboard shortcuts (#676)
+- `apply_patch` unicode characters (#625)
+- Don't clear turn input before retries (#611)
+- More loosely match context for apply_patch (#610)
+- Update bug report template - there is no --revision flag (#614)
+- Remove outdated copy of text input and external editor feature (#670)
+- Remove unreachable "disableResponseStorage" logic flow introduced in #543 (#573)
+- Non-openai mode - fix for gemini content: null, fix 429 to throw before stream (#563)
+- Only allow going up in history when not already in history if input is empty (#654)
+- Do not grant "node" user sudo access when using run_in_container.sh (#627)
+- Update scripts/build_container.sh to use pnpm instead of npm (#631)
+- Update lint-staged config to use pnpm --filter (#582)
+- Non-openai mode - don't default temp and top_p (#572)
+- Fix error catching when checking for updates (#597)
+- Close stdin when running an exec tool call (#636)
+
+## `0.1.2504221401`
+
+### 🚀 Features
+
+- Show actionable errors when api keys are missing (#523)
+- Add CLI `--version` flag (#492)
+
+### 🪲 Bug Fixes
+
+- Agent loop for ZDR (`disableResponseStorage`) (#543)
+- Fix relative `workdir` check for `apply_patch` (#556)
+- Minimal mid-stream #429 retry loop using existing back-off (#506)
+- Inconsistent usage of base URL and API key (#507)
+- Remove requirement for api key for ollama (#546)
+- Support `[provider]_BASE_URL` (#542)
+
+## `0.1.2504220136`
+
+### 🚀 Features
+
+- Add support for ZDR orgs (#481)
+- Include fractional portion of chunk that exceeds stdout/stderr limit (#497)
+
+## `0.1.2504211509`
+
+### 🚀 Features
+
+- Support multiple providers via Responses-Completion transformation (#247)
+- Add user-defined safe commands configuration and approval logic #380 (#386)
+- Allow switching approval modes when prompted to approve an edit/command (#400)
+- Add support for `/diff` command autocomplete in TerminalChatInput (#431)
+- Auto-open model selector if user selects deprecated model (#427)
+- Read approvalMode from config file (#298)
+- `/diff` command to view git diff (#426)
+- Tab completions for file paths (#279)
+- Add /command autocomplete (#317)
+- Allow multi-line input (#438)
+
+### 🪲 Bug Fixes
+
+- `full-auto` support in quiet mode (#374)
+- Enable shell option for child process execution (#391)
+- Configure husky and lint-staged for pnpm monorepo (#384)
+- Command pipe execution by improving shell detection (#437)
+- Name of the file not matching the name of the component (#354)
+- Allow proper exit from new Switch approval mode dialog (#453)
+- Ensure /clear resets context and exclude system messages from approximateTokenUsed count (#443)
+- `/clear` now clears terminal screen and resets context left indicator (#425)
+- Correct fish completion function name in CLI script (#485)
+- Auto-open model-selector when model is not found (#448)
+- Remove unnecessary isLoggingEnabled() checks (#420)
+- Improve test reliability for `raw-exec` (#434)
+- Unintended tear down of agent loop (#483)
+- Remove extraneous type casts (#462)
+
+## `0.1.2504181820`
+
+### 🚀 Features
+
+- Add `/bug` report command (#312)
+- Notify when a newer version is available (#333)
+
+### 🪲 Bug Fixes
+
+- Update context left display logic in TerminalChatInput component (#307)
+- Improper spawn of sh on Windows Powershell (#318)
+- `/bug` report command, thinking indicator (#381)
+- Include pnpm lock file (#377)
+
+## `0.1.2504172351`
+
+### 🚀 Features
+
+- Add Nix flake for reproducible development environments (#225)
+
+### 🪲 Bug Fixes
+
+- Handle invalid commands (#304)
+- Raw-exec-process-group.test improve reliability and error handling (#280)
+- Canonicalize the writeable paths used in seatbelt policy (#275)
+
+## `0.1.2504172304`
+
+### 🚀 Features
+
+- Add shell completion subcommand (#138)
+- Add command history persistence (#152)
+- Shell command explanation option (#173)
+- Support bun fallback runtime for codex CLI (#282)
+- Add notifications for MacOS using Applescript (#160)
+- Enhance image path detection in input processing (#189)
+- `--config`/`-c` flag to open global instructions in nvim (#158)
+- Update position of cursor when navigating input history with arrow keys to the end of the text (#255)
+
+### 🪲 Bug Fixes
+
+- Correct word deletion logic for trailing spaces (Ctrl+Backspace) (#131)
+- Improve Windows compatibility for CLI commands and sandbox (#261)
+- Correct typos in thinking texts (transcendent & parroting) (#108)
+- Add empty vite config file to prevent resolving to parent (#273)
+- Update regex to better match the retry error messages (#266)
+- Add missing "as" in prompt prefix in agent loop (#186)
+- Allow continuing after interrupting assistant (#178)
+- Standardize filename to kebab-case 🐍➡️🥙 (#302)
+- Small update to bug report template (#288)
+- Duplicated message on model change (#276)
+- Typos in prompts and comments (#195)
+- Check workdir before spawn (#221)
+
+<!-- generated - do not edit -->

README.md

@@ -5,25 +5,73 @@
 <p align="center"><strong>Codex CLI</strong> is a coding agent from OpenAI that runs locally on your computer.</br>If you are looking for the <em>cloud-based agent</em> from OpenAI, <strong>Codex Web</strong>, see <a href="https://chatgpt.com/codex">chatgpt.com/codex</a>.</p>
 
 <p align="center">
-  <img src="./.github/codex-cli-splash.png" alt="Codex CLI splash" width="80%" />
+  <img src="./.github/codex-cli-splash.png" alt="Codex CLI splash" width="50%" />
   </p>
 
 ---
 
+<details>
+<summary><strong>Table of contents</strong></summary>
+
+<!-- Begin ToC -->
+
+- [Quickstart](#quickstart)
+  - [Installing and running Codex CLI](#installing-and-running-codex-cli)
+  - [Using Codex with your ChatGPT plan](#using-codex-with-your-chatgpt-plan)
+  - [Connecting on a "Headless" Machine](#connecting-on-a-headless-machine)
+    - [Authenticate locally and copy your credentials to the "headless" machine](#authenticate-locally-and-copy-your-credentials-to-the-headless-machine)
+    - [Connecting through VPS or remote](#connecting-through-vps-or-remote)
+  - [Usage-based billing alternative: Use an OpenAI API key](#usage-based-billing-alternative-use-an-openai-api-key)
+    - [Forcing a specific auth method (advanced)](#forcing-a-specific-auth-method-advanced)
+  - [Choosing Codex's level of autonomy](#choosing-codexs-level-of-autonomy)
+    - [**1. Read/write**](#1-readwrite)
+    - [**2. Read-only**](#2-read-only)
+    - [**3. Advanced configuration**](#3-advanced-configuration)
+    - [Can I run without ANY approvals?](#can-i-run-without-any-approvals)
+    - [Fine-tuning in `config.toml`](#fine-tuning-in-configtoml)
+  - [Example prompts](#example-prompts)
+- [Running with a prompt as input](#running-with-a-prompt-as-input)
+- [Using Open Source Models](#using-open-source-models)
+  - [Platform sandboxing details](#platform-sandboxing-details)
+- [Experimental technology disclaimer](#experimental-technology-disclaimer)
+- [System requirements](#system-requirements)
+- [CLI reference](#cli-reference)
+- [Memory & project docs](#memory--project-docs)
+- [Non-interactive / CI mode](#non-interactive--ci-mode)
+- [Model Context Protocol (MCP)](#model-context-protocol-mcp)
+- [Tracing / verbose logging](#tracing--verbose-logging)
+  - [DotSlash](#dotslash)
+- [Configuration](#configuration)
+- [FAQ](#faq)
+- [Zero data retention (ZDR) usage](#zero-data-retention-zdr-usage)
+- [Codex open source fund](#codex-open-source-fund)
+- [Contributing](#contributing)
+  - [Development workflow](#development-workflow)
+  - [Writing high-impact code changes](#writing-high-impact-code-changes)
+  - [Opening a pull request](#opening-a-pull-request)
+  - [Review process](#review-process)
+  - [Community values](#community-values)
+  - [Getting help](#getting-help)
+  - [Contributor license agreement (CLA)](#contributor-license-agreement-cla)
+    - [Quick fixes](#quick-fixes)
+  - [Releasing `codex`](#releasing-codex)
+- [Security & responsible AI](#security--responsible-ai)
+- [License](#license)
+
+<!-- End ToC -->
+
+</details>
+
+---
+
 ## Quickstart
 
 ### Installing and running Codex CLI
 
-Install globally with your preferred package manager. If you use npm:
+Install globally with your preferred package manager:
 
 ```shell
-npm install -g @openai/codex
-```
-
-Alternatively, if you use Homebrew:
-
-```shell
-brew install codex
+npm install -g @openai/codex  # Alternatively: `brew install codex`
 ```
 
 Then simply run `codex` to get started:
@@ -51,52 +99,607 @@ Each archive contains a single entry with the platform baked into the name (e.g.
 ### Using Codex with your ChatGPT plan
 
 <p align="center">
-  <img src="./.github/codex-cli-login.png" alt="Codex CLI login" width="80%" />
+  <img src="./.github/codex-cli-login.png" alt="Codex CLI login" width="50%" />
   </p>
 
-Run `codex` and select **Sign in with ChatGPT**. We recommend signing into your ChatGPT account to use Codex as part of your Plus, Pro, Team, Edu, or Enterprise plan. [Learn more about what's included in your ChatGPT plan](https://help.openai.com/en/articles/11369540-codex-in-chatgpt).
+Run `codex` and select **Sign in with ChatGPT**. You'll need a Plus, Pro, or Team ChatGPT account, and will get access to our latest models, including `gpt-5`, at no extra cost to your plan. (Enterprise is coming soon.)
 
-You can also use Codex with an API key, but this requires [additional setup](./docs/authentication.md#usage-based-billing-alternative-use-an-openai-api-key). If you previously used an API key for usage-based billing, see the [migration steps](./docs/authentication.md#migrating-from-usage-based-billing-api-key). If you're having trouble with login, please comment on [this issue](https://github.com/openai/codex/issues/1243).
+> Important: If you've used the Codex CLI before, follow these steps to migrate from usage-based billing with your API key:
+>
+> 1. Update the CLI and ensure `codex --version` is `0.20.0` or later
+> 2. Delete `~/.codex/auth.json` (this should be `C:\Users\USERNAME\.codex\auth.json` on Windows)
+> 3. Run `codex login` again
 
-### Model Context Protocol (MCP)
+If you encounter problems with the login flow, please comment on [this issue](https://github.com/openai/codex/issues/1243).
 
-Codex CLI supports [MCP servers](./docs/advanced.md#model-context-protocol-mcp). Enable by adding an `mcp_servers` section to your `~/.codex/config.toml`.
+### Connecting on a "Headless" Machine
 
+Today, the login process entails running a server on `localhost:1455`. If you are on a "headless" server, such as a Docker container or are `ssh`'d into a remote machine, loading `localhost:1455` in the browser on your local machine will not automatically connect to the webserver running on the _headless_ machine, so you must use one of the following workarounds:
 
-### Configuration
+#### Authenticate locally and copy your credentials to the "headless" machine
 
-Codex CLI supports a rich set of configuration options, with preferences stored in `~/.codex/config.toml`. For full configuration options, see [Configuration](./docs/config.md).
+The easiest solution is likely to run through the `codex login` process on your local machine such that `localhost:1455` _is_ accessible in your web browser. When you complete the authentication process, an `auth.json` file should be available at `$CODEX_HOME/auth.json` (on Mac/Linux, `$CODEX_HOME` defaults to `~/.codex` whereas on Windows, it defaults to `%USERPROFILE%\.codex`).
+
+Because the `auth.json` file is not tied to a specific host, once you complete the authentication flow locally, you can copy the `$CODEX_HOME/auth.json` file to the headless machine and then `codex` should "just work" on that machine. Note to copy a file to a Docker container, you can do:
+
+```shell
+# substitute MY_CONTAINER with the name or id of your Docker container:
+CONTAINER_HOME=$(docker exec MY_CONTAINER printenv HOME)
+docker exec MY_CONTAINER mkdir -p "$CONTAINER_HOME/.codex"
+docker cp auth.json MY_CONTAINER:"$CONTAINER_HOME/.codex/auth.json"
+```
+
+whereas if you are `ssh`'d into a remote machine, you likely want to use [`scp`](https://en.wikipedia.org/wiki/Secure_copy_protocol):
+
+```shell
+ssh user@remote 'mkdir -p ~/.codex'
+scp ~/.codex/auth.json user@remote:~/.codex/auth.json
+```
+
+or try this one-liner:
+
+```shell
+ssh user@remote 'mkdir -p ~/.codex && cat > ~/.codex/auth.json' < ~/.codex/auth.json
+```
+
+#### Connecting through VPS or remote
+
+If you run Codex on a remote machine (VPS/server) without a local browser, the login helper starts a server on `localhost:1455` on the remote host. To complete login in your local browser, forward that port to your machine before starting the login flow:
+
+```bash
+# From your local machine
+ssh -L 1455:localhost:1455 <user>@<remote-host>
+```
+
+Then, in that SSH session, run `codex` and select "Sign in with ChatGPT". When prompted, open the printed URL (it will be `http://localhost:1455/...`) in your local browser. The traffic will be tunneled to the remote server.
+
+### Usage-based billing alternative: Use an OpenAI API key
+
+If you prefer to pay-as-you-go, you can still authenticate with your OpenAI API key by setting it as an environment variable:
+
+```shell
+export OPENAI_API_KEY="your-api-key-here"
+```
+
+Notes:
+
+- This command only sets the key for your current terminal session, which we recommend. To set it for all future sessions, you can also add the `export` line to your shell's configuration file (e.g., `~/.zshrc`).
+- If you have signed in with ChatGPT, Codex will default to using your ChatGPT credits. If you wish to use your API key, use the `/logout` command to clear your ChatGPT authentication.
+
+#### Forcing a specific auth method (advanced)
+
+You can explicitly choose which authentication Codex should prefer when both are available.
+
+- To always use your API key (even when ChatGPT auth exists), set:
+
+```toml
+# ~/.codex/config.toml
+preferred_auth_method = "apikey"
+```
+
+Or override ad-hoc via CLI:
+
+```bash
+codex --config preferred_auth_method="apikey"
+```
+
+- To prefer ChatGPT auth (default), set:
+
+```toml
+# ~/.codex/config.toml
+preferred_auth_method = "chatgpt"
+```
+
+Notes:
+
+- When `preferred_auth_method = "apikey"` and an API key is available, the login screen is skipped.
+- When `preferred_auth_method = "chatgpt"` (default), Codex prefers ChatGPT auth if present; if only an API key is present, it will use the API key. Certain account types may also require API-key mode.
+
+### Choosing Codex's level of autonomy
+
+We always recommend running Codex in its default sandbox that gives you strong guardrails around what the agent can do. The default sandbox prevents it from editing files outside its workspace, or from accessing the network.
+
+When you launch Codex in a new folder, it detects whether the folder is version controlled and recommends one of two levels of autonomy:
+
+#### **1. Read/write**
+
+- Codex can run commands and write files in the workspace without approval.
+- To write files in other folders, access network, update git or perform other actions protected by the sandbox, Codex will need your permission.
+- By default, the workspace includes the current directory, as well as temporary directories like `/tmp`. You can see what directories are in the workspace with the `/status` command. See the docs for how to customize this behavior.
+- Advanced: You can manually specify this configuration by running `codex --sandbox workspace-write --ask-for-approval on-request`
+- This is the recommended default for version-controlled folders.
+
+#### **2. Read-only**
+
+- Codex can run read-only commands without approval.
+- To edit files, access network, or perform other actions protected by the sandbox, Codex will need your permission.
+- Advanced: You can manually specify this configuration by running `codex --sandbox read-only --ask-for-approval on-request`
+- This is the recommended default non-version-controlled folders.
+
+#### **3. Advanced configuration**
+
+Codex gives you fine-grained control over the sandbox with the `--sandbox` option, and over when it requests approval with the `--ask-for-approval` option. Run `codex help` for more on these options.
+
+#### Can I run without ANY approvals?
+
+Yes, run codex non-interactively with `--ask-for-approval never`. This option works with all `--sandbox` options, so you still have full control over Codex's level of autonomy. It will make its best attempt with whatever contrainsts you provide. For example:
+
+- Use `codex --ask-for-approval never --sandbox read-only` when you are running many agents to answer questions in parallel in the same workspace.
+- Use `codex --ask-for-approval never --sandbox workspace-write` when you want the agent to non-interactively take time to produce the best outcome, with strong guardrails around its behavior.
+- Use `codex --ask-for-approval never --sandbox danger-full-access` to dangerously give the agent full autonomy. Because this disables important safety mechanisms, we recommend against using this unless running Codex in an isolated environment.
+
+#### Fine-tuning in `config.toml`
+
+```toml
+# approval mode
+approval_policy = "untrusted"
+sandbox_mode    = "read-only"
+
+# full-auto mode
+approval_policy = "on-request"
+sandbox_mode    = "workspace-write"
+
+# Optional: allow network in workspace-write mode
+[sandbox_workspace_write]
+network_access = true
+```
+
+You can also save presets as **profiles**:
+
+```toml
+[profiles.full_auto]
+approval_policy = "on-request"
+sandbox_mode    = "workspace-write"
+
+[profiles.readonly_quiet]
+approval_policy = "never"
+sandbox_mode    = "read-only"
+```
+
+### Example prompts
+
+Below are a few bite-size examples you can copy-paste. Replace the text in quotes with your own task. See the [prompting guide](https://github.com/openai/codex/blob/main/codex-cli/examples/prompting_guide.md) for more tips and usage patterns.
+
+| ✨  | What you type                                                                   | What happens                                                               |
+| --- | ------------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
+| 1   | `codex "Refactor the Dashboard component to React Hooks"`                       | Codex rewrites the class component, runs `npm test`, and shows the diff.   |
+| 2   | `codex "Generate SQL migrations for adding a users table"`                      | Infers your ORM, creates migration files, and runs them in a sandboxed DB. |
+| 3   | `codex "Write unit tests for utils/date.ts"`                                    | Generates tests, executes them, and iterates until they pass.              |
+| 4   | `codex "Bulk-rename *.jpeg -> *.jpg with git mv"`                               | Safely renames files and updates imports/usages.                           |
+| 5   | `codex "Explain what this regex does: ^(?=.*[A-Z]).{8,}$"`                      | Outputs a step-by-step human explanation.                                  |
+| 6   | `codex "Carefully review this repo, and propose 3 high impact well-scoped PRs"` | Suggests impactful PRs in the current codebase.                            |
+| 7   | `codex "Look for vulnerabilities and create a security review report"`          | Finds and explains security bugs.                                          |
+
+## Running with a prompt as input
+
+You can also run Codex CLI with a prompt as input:
+
+```shell
+codex "explain this codebase to me"
+```
+
+```shell
+codex --full-auto "create the fanciest todo-list app"
+```
+
+That's it - Codex will scaffold a file, run it inside a sandbox, install any
+missing dependencies, and show you the live result. Approve the changes and
+they'll be committed to your working directory.
+
+## Using Open Source Models
+
+<details>
+<summary><strong>Use <code>--profile</code> to use other models</strong></summary>
+
+Codex also allows you to use other providers that support the OpenAI Chat Completions (or Responses) API.
+
+To do so, you must first define custom [providers](./config.md#model_providers) in `~/.codex/config.toml`. For example, the provider for a standard Ollama setup would be defined as follows:
+
+```toml
+[model_providers.ollama]
+name = "Ollama"
+base_url = "http://localhost:11434/v1"
+```
+
+The `base_url` will have `/chat/completions` appended to it to build the full URL for the request.
+
+For providers that also require an `Authorization` header of the form `Bearer: SECRET`, an `env_key` can be specified, which indicates the environment variable to read to use as the value of `SECRET` when making a request:
+
+```toml
+[model_providers.openrouter]
+name = "OpenRouter"
+base_url = "https://openrouter.ai/api/v1"
+env_key = "OPENROUTER_API_KEY"
+```
+
+Providers that speak the Responses API are also supported by adding `wire_api = "responses"` as part of the definition. Accessing OpenAI models via Azure is an example of such a provider, though it also requires specifying additional `query_params` that need to be appended to the request URL:
+
+```toml
+[model_providers.azure]
+name = "Azure"
+# Make sure you set the appropriate subdomain for this URL.
+base_url = "https://YOUR_PROJECT_NAME.openai.azure.com/openai"
+env_key = "AZURE_OPENAI_API_KEY"  # Or "OPENAI_API_KEY", whichever you use.
+# Newer versions appear to support the responses API, see https://github.com/openai/codex/pull/1321
+query_params = { api-version = "2025-04-01-preview" }
+wire_api = "responses"
+```
+
+Once you have defined a provider you wish to use, you can configure it as your default provider as follows:
+
+```toml
+model_provider = "azure"
+```
+
+> [!TIP]
+> If you find yourself experimenting with a variety of models and providers, then you likely want to invest in defining a _profile_ for each configuration like so:
+
+```toml
+[profiles.o3]
+model_provider = "azure"
+model = "o3"
+
+[profiles.mistral]
+model_provider = "ollama"
+model = "mistral"
+```
+
+This way, you can specify one command-line argument (.e.g., `--profile o3`, `--profile mistral`) to override multiple settings together.
+
+</details>
+
+Codex can run fully locally against an OpenAI-compatible OSS host (like Ollama) using the `--oss` flag:
+
+- Interactive UI:
+  - codex --oss
+- Non-interactive (programmatic) mode:
+  - echo "Refactor utils" | codex exec --oss
+
+Model selection when using `--oss`:
+
+- If you omit `-m/--model`, Codex defaults to -m gpt-oss:20b and will verify it exists locally (downloading if needed).
+- To pick a different size, pass one of:
+  - -m "gpt-oss:20b"
+  - -m "gpt-oss:120b"
+
+Point Codex at your own OSS host:
+
+- By default, `--oss` talks to http://localhost:11434/v1.
+- To use a different host, set one of these environment variables before running Codex:
+  - CODEX_OSS_BASE_URL, for example:
+    - CODEX_OSS_BASE_URL="http://my-ollama.example.com:11434/v1" codex --oss -m gpt-oss:20b
+  - or CODEX_OSS_PORT (when the host is localhost):
+    - CODEX_OSS_PORT=11434 codex --oss
+
+Advanced: you can persist this in your config instead of environment variables by overriding the built-in `oss` provider in `~/.codex/config.toml`:
+
+```toml
+[model_providers.oss]
+name = "Open Source"
+base_url = "http://my-ollama.example.com:11434/v1"
+```
 
 ---
 
-### Docs & FAQ
+### Platform sandboxing details
 
-- [**Getting started**](./docs/getting-started.md)
-  - [CLI usage](./docs/getting-started.md#cli-usage)
-  - [Running with a prompt as input](./docs/getting-started.md#running-with-a-prompt-as-input)
-  - [Example prompts](./docs/getting-started.md#example-prompts)
-  - [Memory with AGENTS.md](./docs/getting-started.md#memory--project-docs)
-  - [Configuration](./docs/config.md)
-- [**Sandbox & approvals**](./docs/sandbox.md)
-- [**Authentication**](./docs/authentication.md)
-  - [Auth methods](./docs/authentication.md#forcing-a-specific-auth-method-advanced)
-  - [Login on a "Headless" machine](./docs/authentication.md#connecting-on-a-headless-machine)
-- [**Advanced**](./docs/advanced.md)
-  - [Non-interactive / CI mode](./docs/advanced.md#non-interactive--ci-mode)
-  - [Tracing / verbose logging](./docs/advanced.md#tracing--verbose-logging)
-  - [Model Context Protocol (MCP)](./docs/advanced.md#model-context-protocol-mcp)
-- [**Zero data retention (ZDR)**](./docs/zdr.md)
-- [**Contributing**](./docs/contributing.md)
-- [**Install & build**](./docs/install.md)
-  - [System Requirements](./docs/install.md#system-requirements)
-  - [DotSlash](./docs/install.md#dotslash)
-  - [Build from source](./docs/install.md#build-from-source)
-- [**FAQ**](./docs/faq.md)
-- [**Open source fund**](./docs/open-source-fund.md)
+By default, Codex CLI runs code and shell commands inside a restricted sandbox to protect your system.  
+
+> [!IMPORTANT]
+> Not all tool calls are sandboxed. Specifically, **trusted Model Context Protocol (MCP) tool calls** are executed outside of the sandbox.  
+> This is intentional: MCP tools are explicitly configured and trusted by you, and they often need to connect to **external applications or services** (e.g. issue trackers, databases, messaging systems).  
+> Running them outside the sandbox allows Codex to integrate with these external systems without being blocked by sandbox restrictions.
+
+The mechanism Codex uses to implement the sandbox policy depends on your OS:
+
+- **macOS 12+** uses **Apple Seatbelt** and runs commands using `sandbox-exec` with a profile (`-p`) that corresponds to the `--sandbox` that was specified.
+- **Linux** uses a combination of Landlock/seccomp APIs to enforce the `sandbox` configuration.
+
+Note that when running Linux in a containerized environment such as Docker, sandboxing may not work if the host/container configuration does not support the necessary Landlock/seccomp APIs. In such cases, we recommend configuring your Docker container so that it provides the sandbox guarantees you are looking for and then running `codex` with `--sandbox danger-full-access` (or, more simply, the `--dangerously-bypass-approvals-and-sandbox` flag) within your container.
+
+---
+
+## Experimental technology disclaimer
+
+Codex CLI is an experimental project under active development. It is not yet stable, may contain bugs, incomplete features, or undergo breaking changes. We're building it in the open with the community and welcome:
+
+- Bug reports
+- Feature requests
+- Pull requests
+- Good vibes
+
+Help us improve by filing issues or submitting PRs (see the section below for how to contribute)!
+
+---
+
+## System requirements
+
+| Requirement                 | Details                                                         |
+| --------------------------- | --------------------------------------------------------------- |
+| Operating systems           | macOS 12+, Ubuntu 20.04+/Debian 10+, or Windows 11 **via WSL2** |
+| Git (optional, recommended) | 2.23+ for built-in PR helpers                                   |
+| RAM                         | 4-GB minimum (8-GB recommended)                                 |
+
+---
+
+## CLI reference
+
+| Command            | Purpose                            | Example                         |
+| ------------------ | ---------------------------------- | ------------------------------- |
+| `codex`            | Interactive TUI                    | `codex`                         |
+| `codex "..."`      | Initial prompt for interactive TUI | `codex "fix lint errors"`       |
+| `codex exec "..."` | Non-interactive "automation mode"  | `codex exec "explain utils.ts"` |
+
+Key flags: `--model/-m`, `--ask-for-approval/-a`.
+
+---
+
+## Memory & project docs
+
+You can give Codex extra instructions and guidance using `AGENTS.md` files. Codex looks for `AGENTS.md` files in the following places, and merges them top-down:
+
+1. `~/.codex/AGENTS.md` - personal global guidance
+2. `AGENTS.md` at repo root - shared project notes
+3. `AGENTS.md` in the current working directory - sub-folder/feature specifics
+
+---
+
+## Non-interactive / CI mode
+
+Run Codex head-less in pipelines. Example GitHub Action step:
+
+```yaml
+- name: Update changelog via Codex
+  run: |
+    npm install -g @openai/codex
+    export OPENAI_API_KEY="${{ secrets.OPENAI_KEY }}"
+    codex exec --full-auto "update CHANGELOG for next release"
+```
+
+## Model Context Protocol (MCP)
+
+The Codex CLI can be configured to leverage MCP servers by defining an [`mcp_servers`](./codex-rs/config.md#mcp_servers) section in `~/.codex/config.toml`. It is intended to mirror how tools such as Claude and Cursor define `mcpServers` in their respective JSON config files, though the Codex format is slightly different since it uses TOML rather than JSON, e.g.:
+
+```toml
+# IMPORTANT: the top-level key is `mcp_servers` rather than `mcpServers`.
+[mcp_servers.server-name]
+command = "npx"
+args = ["-y", "mcp-server"]
+env = { "API_KEY" = "value" }
+```
+
+> [!TIP]
+> It is somewhat experimental, but the Codex CLI can also be run as an MCP _server_ via `codex mcp`. If you launch it with an MCP client such as `npx @modelcontextprotocol/inspector codex mcp` and send it a `tools/list` request, you will see that there is only one tool, `codex`, that accepts a grab-bag of inputs, including a catch-all `config` map for anything you might want to override. Feel free to play around with it and provide feedback via GitHub issues.
+
+## Tracing / verbose logging
+
+Because Codex is written in Rust, it honors the `RUST_LOG` environment variable to configure its logging behavior.
+
+The TUI defaults to `RUST_LOG=codex_core=info,codex_tui=info` and log messages are written to `~/.codex/log/codex-tui.log`, so you can leave the following running in a separate terminal to monitor log messages as they are written:
+
+```
+tail -F ~/.codex/log/codex-tui.log
+```
+
+By comparison, the non-interactive mode (`codex exec`) defaults to `RUST_LOG=error`, but messages are printed inline, so there is no need to monitor a separate file.
+
+See the Rust documentation on [`RUST_LOG`](https://docs.rs/env_logger/latest/env_logger/#enabling-logging) for more information on the configuration options.
+
+---
+
+### DotSlash
+
+The GitHub Release also contains a [DotSlash](https://dotslash-cli.com/) file for the Codex CLI named `codex`. Using a DotSlash file makes it possible to make a lightweight commit to source control to ensure all contributors use the same version of an executable, regardless of what platform they use for development.
+
+</details>
+
+<details>
+<summary><strong>Build from source</strong></summary>
+
+```bash
+# Clone the repository and navigate to the root of the Cargo workspace.
+git clone https://github.com/openai/codex.git
+cd codex/codex-rs
+
+# Install the Rust toolchain, if necessary.
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+source "$HOME/.cargo/env"
+rustup component add rustfmt
+rustup component add clippy
+
+# Build Codex.
+cargo build
+
+# Launch the TUI with a sample prompt.
+cargo run --bin codex -- "explain this codebase to me"
+
+# After making changes, ensure the code is clean.
+cargo fmt -- --config imports_granularity=Item
+cargo clippy --tests
+
+# Run the tests.
+cargo test
+```
+
+</details>
+
+---
+
+## Configuration
+
+Codex supports a rich set of configuration options documented in [`codex-rs/config.md`](./codex-rs/config.md).
+
+By default, Codex loads its configuration from `~/.codex/config.toml`.
+
+Though `--config` can be used to set/override ad-hoc config values for individual invocations of `codex`.
+
+---
+
+## FAQ
+
+<details>
+<summary>OpenAI released a model called Codex in 2021 - is this related?</summary>
+
+In 2021, OpenAI released Codex, an AI system designed to generate code from natural language prompts. That original Codex model was deprecated as of March 2023 and is separate from the CLI tool.
+
+</details>
+
+<details>
+<summary>Which models are supported?</summary>
+
+Any model available with [Responses API](https://platform.openai.com/docs/api-reference/responses). The default is `o4-mini`, but pass `--model gpt-4.1` or set `model: gpt-4.1` in your config file to override.
+
+</details>
+<details>
+<summary>Why does <code>o3</code> or <code>o4-mini</code> not work for me?</summary>
+
+It's possible that your [API account needs to be verified](https://help.openai.com/en/articles/10910291-api-organization-verification) in order to start streaming responses and seeing chain of thought summaries from the API. If you're still running into issues, please let us know!
+
+</details>
+
+<details>
+<summary>How do I stop Codex from editing my files?</summary>
+
+Codex runs model-generated commands in a sandbox. If a proposed command or file change doesn't look right, you can simply type **n** to deny the command or give the model feedback.
+
+</details>
+<details>
+<summary>Does it work on Windows?</summary>
+
+Not directly. It requires [Windows Subsystem for Linux (WSL2)](https://learn.microsoft.com/en-us/windows/wsl/install) - Codex has been tested on macOS and Linux with Node 22.
+
+</details>
+
+---
+
+## Zero data retention (ZDR) usage
+
+Codex CLI **does** support OpenAI organizations with [Zero Data Retention (ZDR)](https://platform.openai.com/docs/guides/your-data#zero-data-retention) enabled. If your OpenAI organization has Zero Data Retention enabled and you still encounter errors such as:
+
+```
+OpenAI rejected the request. Error details: Status: 400, Code: unsupported_parameter, Type: invalid_request_error, Message: 400 Previous response cannot be used for this organization due to Zero Data Retention.
+```
+
+Ensure you are running `codex` with `--config disable_response_storage=true` or add this line to `~/.codex/config.toml` to avoid specifying the command line option each time:
+
+```toml
+disable_response_storage = true
+```
+
+See [the configuration documentation on `disable_response_storage`](./codex-rs/config.md#disable_response_storage) for details.
+
+---
+
+## Codex open source fund
+
+We're excited to launch a **$1 million initiative** supporting open source projects that use Codex CLI and other OpenAI models.
+
+- Grants are awarded up to **$25,000** API credits.
+- Applications are reviewed **on a rolling basis**.
+
+**Interested? [Apply here](https://openai.com/form/codex-open-source-fund/).**
+
+---
+
+## Contributing
+
+This project is under active development and the code will likely change pretty significantly.
+
+**At the moment, we only plan to prioritize reviewing external contributions for bugs or security fixes.**
+
+If you want to add a new feature or change the behavior of an existing one, please open an issue proposing the feature and get approval from an OpenAI team member before spending time building it.
+
+**New contributions that don't go through this process may be closed** if they aren't aligned with our current roadmap or conflict with other priorities/upcoming features.
+
+### Development workflow
+
+- Create a _topic branch_ from `main` - e.g. `feat/interactive-prompt`.
+- Keep your changes focused. Multiple unrelated fixes should be opened as separate PRs.
+- Following the [development setup](#development-workflow) instructions above, ensure your change is free of lint warnings and test failures.
+
+### Writing high-impact code changes
+
+1. **Start with an issue.** Open a new one or comment on an existing discussion so we can agree on the solution before code is written.
+2. **Add or update tests.** Every new feature or bug-fix should come with test coverage that fails before your change and passes afterwards. 100% coverage is not required, but aim for meaningful assertions.
+3. **Document behaviour.** If your change affects user-facing behaviour, update the README, inline help (`codex --help`), or relevant example projects.
+4. **Keep commits atomic.** Each commit should compile and the tests should pass. This makes reviews and potential rollbacks easier.
+
+### Opening a pull request
+
+- Fill in the PR template (or include similar information) - **What? Why? How?**
+- Run **all** checks locally (`cargo test && cargo clippy --tests && cargo fmt -- --config imports_granularity=Item`). CI failures that could have been caught locally slow down the process.
+- Make sure your branch is up-to-date with `main` and that you have resolved merge conflicts.
+- Mark the PR as **Ready for review** only when you believe it is in a merge-able state.
+
+### Review process
+
+1. One maintainer will be assigned as a primary reviewer.
+2. If your PR adds a new feature that was not previously discussed and approved, we may choose to close your PR (see [Contributing](#contributing)).
+3. We may ask for changes - please do not take this personally. We value the work, but we also value consistency and long-term maintainability.
+5. When there is consensus that the PR meets the bar, a maintainer will squash-and-merge.
+
+### Community values
+
+- **Be kind and inclusive.** Treat others with respect; we follow the [Contributor Covenant](https://www.contributor-covenant.org/).
+- **Assume good intent.** Written communication is hard - err on the side of generosity.
+- **Teach & learn.** If you spot something confusing, open an issue or PR with improvements.
+
+### Getting help
+
+If you run into problems setting up the project, would like feedback on an idea, or just want to say _hi_ - please open a Discussion or jump into the relevant issue. We are happy to help.
+
+Together we can make Codex CLI an incredible tool. **Happy hacking!** :rocket:
+
+### Contributor license agreement (CLA)
+
+All contributors **must** accept the CLA. The process is lightweight:
+
+1. Open your pull request.
+2. Paste the following comment (or reply `recheck` if you've signed before):
+
+   ```text
+   I have read the CLA Document and I hereby sign the CLA
+   ```
+
+3. The CLA-Assistant bot records your signature in the repo and marks the status check as passed.
+
+No special Git commands, email attachments, or commit footers required.
+
+#### Quick fixes
+
+| Scenario          | Command                                          |
+| ----------------- | ------------------------------------------------ |
+| Amend last commit | `git commit --amend -s --no-edit && git push -f` |
+
+The **DCO check** blocks merges until every commit in the PR carries the footer (with squash this is just the one).
+
+### Releasing `codex`
+
+_For admins only._
+
+Make sure you are on `main` and have no local changes. Then run:
+
+```shell
+VERSION=0.2.0  # Can also be 0.2.0-alpha.1 or any valid Rust version.
+./codex-rs/scripts/create_github_release.sh "$VERSION"
+```
+
+This will make a local commit on top of `main` with `version` set to `$VERSION` in `codex-rs/Cargo.toml` (note that on `main`, we leave the version as `version = "0.0.0"`).
+
+This will push the commit using the tag `rust-v${VERSION}`, which in turn kicks off [the release workflow](.github/workflows/rust-release.yml). This will create a new GitHub Release named `$VERSION`.
+
+If everything looks good in the generated GitHub Release, uncheck the **pre-release** box so it is the latest release.
+
+Create a PR to update [`Formula/c/codex.rb`](https://github.com/Homebrew/homebrew-core/blob/main/Formula/c/codex.rb) on Homebrew.
+
+---
+
+## Security & responsible AI
+
+Have you discovered a vulnerability or have concerns about model output? Please e-mail **security@openai.com** and we will respond promptly.
 
 ---
 
 ## License
 
 This repository is licensed under the [Apache-2.0 License](LICENSE).
-

codex-cli/bin/codex.js

@@ -43,8 +43,7 @@ switch (platform) {
         targetTriple = "x86_64-pc-windows-msvc.exe";
         break;
       case "arm64":
-        targetTriple = "aarch64-pc-windows-msvc.exe";
-        break;
+      // We do not build this today, fall through...
       default:
         break;
     }

codex-cli/scripts/install_native_deps.sh

@@ -20,7 +20,7 @@ CODEX_CLI_ROOT=""
 # Until we start publishing stable GitHub releases, we have to grab the binaries
 # from the GitHub Action that created them. Update the URL below to point to the
 # appropriate workflow run:
-WORKFLOW_URL="https://github.com/openai/codex/actions/runs/17417194663" # rust-v0.28.0
+WORKFLOW_URL="https://github.com/openai/codex/actions/runs/16840150768" # rust-v0.20.0-alpha.2
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
@@ -87,8 +87,5 @@ zstd -d "$ARTIFACTS_DIR/aarch64-apple-darwin/codex-aarch64-apple-darwin.zst" \
 # x64 Windows
 zstd -d "$ARTIFACTS_DIR/x86_64-pc-windows-msvc/codex-x86_64-pc-windows-msvc.exe.zst" \
     -o "$BIN_DIR/codex-x86_64-pc-windows-msvc.exe"
-# ARM64 Windows
-zstd -d "$ARTIFACTS_DIR/aarch64-pc-windows-msvc/codex-aarch64-pc-windows-msvc.exe.zst" \
-    -o "$BIN_DIR/codex-aarch64-pc-windows-msvc.exe"
 
 echo "Installed native dependencies into $BIN_DIR"

codex-rs/Cargo.lock

@@ -636,11 +636,10 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "assert_cmd",
- "once_cell",
  "pretty_assertions",
  "similar",
  "tempfile",
- "thiserror 2.0.16",
+ "thiserror 2.0.12",
  "tree-sitter",
  "tree-sitter-bash",
 ]
@@ -666,7 +665,7 @@ dependencies = [
  "clap",
  "codex-common",
  "codex-core",
- "codex-protocol",
+ "codex-login",
  "reqwest",
  "serde",
  "serde_json",
@@ -679,6 +678,7 @@ name = "codex-cli"
 version = "0.0.0"
 dependencies = [
  "anyhow",
+ "assert_cmd",
  "clap",
  "clap_complete",
  "codex-arg0",
@@ -692,7 +692,10 @@ dependencies = [
  "codex-protocol-ts",
  "codex-tui",
  "serde_json",
+ "tempfile",
  "tokio",
+ "toml 0.9.5",
+ "toml_edit 0.23.4",
  "tracing",
  "tracing-subscriber",
 ]
@@ -719,6 +722,7 @@ dependencies = [
  "bytes",
  "chrono",
  "codex-apply-patch",
+ "codex-login",
  "codex-mcp-client",
  "codex-protocol",
  "core_test_support",
@@ -748,7 +752,7 @@ dependencies = [
  "similar",
  "strum_macros 0.27.2",
  "tempfile",
- "thiserror 2.0.16",
+ "thiserror 2.0.12",
  "time",
  "tokio",
  "tokio-test",
@@ -847,7 +851,6 @@ version = "0.0.0"
 dependencies = [
  "base64 0.22.1",
  "chrono",
- "codex-core",
  "codex-protocol",
  "pretty_assertions",
  "rand 0.8.5",
@@ -856,7 +859,7 @@ dependencies = [
  "serde_json",
  "sha2",
  "tempfile",
- "thiserror 2.0.16",
+ "thiserror 2.0.12",
  "tiny_http",
  "tokio",
  "url",
@@ -974,13 +977,11 @@ dependencies = [
  "diffy",
  "image",
  "insta",
- "itertools 0.14.0",
  "lazy_static",
  "libc",
  "mcp-types",
  "once_cell",
  "path-clean",
- "pathdiff",
  "pretty_assertions",
  "rand 0.9.2",
  "ratatui",
@@ -2687,7 +2688,7 @@ checksum = "b3d2ef408b88e913bfc6594f5e693d57676f6463ded7d8bf994175364320c706"
 dependencies = [
  "enumflags2",
  "libc",
- "thiserror 2.0.16",
+ "thiserror 2.0.12",
 ]
 
 [[package]]
@@ -3380,12 +3381,6 @@ dependencies = [
  "once_cell",
 ]
 
-[[package]]
-name = "pathdiff"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
-
 [[package]]
 name = "percent-encoding"
 version = "2.3.1"
@@ -3859,7 +3854,7 @@ checksum = "dd6f9d3d47bdd2ad6945c5015a226ec6155d0bcdfd8f7cd29f86b71f8de99d2b"
 dependencies = [
  "getrandom 0.2.16",
  "libredox",
- "thiserror 2.0.16",
+ "thiserror 2.0.12",
 ]
 
 [[package]]
@@ -3916,9 +3911,9 @@ dependencies = [
 
 [[package]]
 name = "regex-lite"
-version = "0.1.7"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "943f41321c63ef1c92fd763bfe054d2668f7f225a5c29f0105903dc2fc04ba30"
+checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a"
 
 [[package]]
 name = "regex-syntax"
@@ -4944,11 +4939,11 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.16"
+version = "2.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3467d614147380f2e4e374161426ff399c91084acd2363eaf549172b3d5e60c0"
+checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
 dependencies = [
- "thiserror-impl 2.0.16",
+ "thiserror-impl 2.0.12",
 ]
 
 [[package]]
@@ -4964,9 +4959,9 @@ dependencies = [
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.16"
+version = "2.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c5e1be1c48b9172ee610da68fd9cd2770e7a4056cb3fc98710ee6906f0c7960"
+checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5403,7 +5398,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ef1b7a6d914a34127ed8e1fa927eb7088903787bcded4fa3eef8f85ee1568be"
 dependencies = [
  "serde_json",
- "thiserror 2.0.16",
+ "thiserror 2.0.12",
  "ts-rs-macros",
  "uuid",
 ]

codex-rs/Cargo.toml

@@ -22,7 +22,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.29.0-alpha.1"
+version = "0.0.0"
 # Track the edition for all workspace crates in one place. Individual
 # crates can still override this value, but keeping it here means new
 # crates created with `cargo new -w ...` automatically inherit the 2024
@@ -34,7 +34,6 @@ rust = {}
 
 [workspace.lints.clippy]
 expect_used = "deny"
-uninlined_format_args = "deny"
 unwrap_used = "deny"
 
 [profile.release]

codex-rs/README.md

@@ -19,11 +19,11 @@ While we are [working to close the gap between the TypeScript and Rust implement
 
 ### Config
 
-Codex supports a rich set of configuration options. Note that the Rust CLI uses `config.toml` instead of `config.json`. See [`docs/config.md`](../docs/config.md) for details.
+Codex supports a rich set of configuration options. Note that the Rust CLI uses `config.toml` instead of `config.json`. See [`config.md`](./config.md) for details.
 
 ### Model Context Protocol Support
 
-Codex CLI functions as an MCP client that can connect to MCP servers on startup. See the [`mcp_servers`](../docs/config.md#mcp_servers) section in the configuration documentation for details.
+Codex CLI functions as an MCP client that can connect to MCP servers on startup. See the [`mcp_servers`](./config.md#mcp_servers) section in the configuration documentation for details.
 
 It is still experimental, but you can also launch Codex as an MCP _server_ by running `codex mcp`. Use the [`@modelcontextprotocol/inspector`](https://github.com/modelcontextprotocol/inspector) to try it out:
 
@@ -33,7 +33,7 @@ npx @modelcontextprotocol/inspector codex mcp
 
 ### Notifications
 
-You can enable notifications by configuring a script that is run whenever the agent finishes a turn. The [notify documentation](../docs/config.md#notify) includes a detailed example that explains how to get desktop notifications via [terminal-notifier](https://github.com/julienXX/terminal-notifier) on macOS.
+You can enable notifications by configuring a script that is run whenever the agent finishes a turn. The [notify documentation](./config.md#notify) includes a detailed example that explains how to get desktop notifications via [terminal-notifier](https://github.com/julienXX/terminal-notifier) on macOS.
 
 ### `codex exec` to run Codex programmatially/non-interactively
 

codex-rs/ansi-escape/src/lib.rs

@@ -9,7 +9,7 @@ use ratatui::text::Text;
 pub fn ansi_escape_line(s: &str) -> Line<'static> {
     let text = ansi_escape(s);
     match text.lines.as_slice() {
-        [] => "".into(),
+        [] => Line::from(""),
         [only] => only.clone(),
         [first, rest @ ..] => {
             tracing::warn!("ansi_escape_line: expected a single line, got {first:?} and {rest:?}");

codex-rs/apply-patch/Cargo.toml

@@ -17,10 +17,9 @@ workspace = true
 [dependencies]
 anyhow = "1"
 similar = "2.7.0"
-thiserror = "2.0.16"
+thiserror = "2.0.12"
 tree-sitter = "0.25.8"
 tree-sitter-bash = "0.25.0"
-once_cell = "1"
 
 [dev-dependencies]
 assert_cmd = "2"

codex-rs/apply-patch/src/lib.rs

@@ -9,7 +9,6 @@ use std::str::Utf8Error;
 
 use anyhow::Context;
 use anyhow::Result;
-use once_cell::sync::Lazy;
 pub use parser::Hunk;
 pub use parser::ParseError;
 use parser::ParseError::*;
@@ -19,9 +18,6 @@ use similar::TextDiff;
 use thiserror::Error;
 use tree_sitter::LanguageError;
 use tree_sitter::Parser;
-use tree_sitter::Query;
-use tree_sitter::QueryCursor;
-use tree_sitter::StreamingIterator;
 use tree_sitter_bash::LANGUAGE as BASH;
 
 pub use standalone_executable::main;
@@ -88,7 +84,6 @@ pub enum MaybeApplyPatch {
 pub struct ApplyPatchArgs {
     pub patch: String,
     pub hunks: Vec<Hunk>,
-    pub workdir: Option<String>,
 }
 
 pub fn maybe_parse_apply_patch(argv: &[String]) -> MaybeApplyPatch {
@@ -97,18 +92,18 @@ pub fn maybe_parse_apply_patch(argv: &[String]) -> MaybeApplyPatch {
             Ok(source) => MaybeApplyPatch::Body(source),
             Err(e) => MaybeApplyPatch::PatchParseError(e),
         },
-        [bash, flag, script] if bash == "bash" && flag == "-lc" => {
-            match extract_apply_patch_from_bash(script) {
-                Ok((body, workdir)) => match parse_patch(&body) {
-                    Ok(mut source) => {
-                        source.workdir = workdir;
-                        MaybeApplyPatch::Body(source)
-                    }
+        [bash, flag, script]
+            if bash == "bash"
+                && flag == "-lc"
+                && APPLY_PATCH_COMMANDS
+                    .iter()
+                    .any(|cmd| script.trim_start().starts_with(cmd)) =>
+        {
+            match extract_heredoc_body_from_apply_patch_command(script) {
+                Ok(body) => match parse_patch(&body) {
+                    Ok(source) => MaybeApplyPatch::Body(source),
                     Err(e) => MaybeApplyPatch::PatchParseError(e),
                 },
-                Err(ExtractHeredocError::CommandDidNotStartWithApplyPatch) => {
-                    MaybeApplyPatch::NotApplyPatch
-                }
                 Err(e) => MaybeApplyPatch::ShellParseError(e),
             }
         }
@@ -121,9 +116,7 @@ pub enum ApplyPatchFileChange {
     Add {
         content: String,
     },
-    Delete {
-        content: String,
-    },
+    Delete,
     Update {
         unified_diff: String,
         move_path: Option<PathBuf>,
@@ -208,42 +201,16 @@ impl ApplyPatchAction {
 /// patch.
 pub fn maybe_parse_apply_patch_verified(argv: &[String], cwd: &Path) -> MaybeApplyPatchVerified {
     match maybe_parse_apply_patch(argv) {
-        MaybeApplyPatch::Body(ApplyPatchArgs {
-            patch,
-            hunks,
-            workdir,
-        }) => {
-            let effective_cwd = workdir
-                .as_ref()
-                .map(|dir| {
-                    let path = Path::new(dir);
-                    if path.is_absolute() {
-                        path.to_path_buf()
-                    } else {
-                        cwd.join(path)
-                    }
-                })
-                .unwrap_or_else(|| cwd.to_path_buf());
+        MaybeApplyPatch::Body(ApplyPatchArgs { patch, hunks }) => {
             let mut changes = HashMap::new();
             for hunk in hunks {
-                let path = hunk.resolve_path(&effective_cwd);
+                let path = hunk.resolve_path(cwd);
                 match hunk {
                     Hunk::AddFile { contents, .. } => {
                         changes.insert(path, ApplyPatchFileChange::Add { content: contents });
                     }
                     Hunk::DeleteFile { .. } => {
-                        let content = match std::fs::read_to_string(&path) {
-                            Ok(content) => content,
-                            Err(e) => {
-                                return MaybeApplyPatchVerified::CorrectnessError(
-                                    ApplyPatchError::IoError(IoError {
-                                        context: format!("Failed to read {}", path.display()),
-                                        source: e,
-                                    }),
-                                );
-                            }
-                        };
-                        changes.insert(path, ApplyPatchFileChange::Delete { content });
+                        changes.insert(path, ApplyPatchFileChange::Delete);
                     }
                     Hunk::UpdateFile {
                         move_path, chunks, ..
@@ -271,7 +238,7 @@ pub fn maybe_parse_apply_patch_verified(argv: &[String], cwd: &Path) -> MaybeApp
             MaybeApplyPatchVerified::Body(ApplyPatchAction {
                 changes,
                 patch,
-                cwd: effective_cwd,
+                cwd: cwd.to_path_buf(),
             })
         }
         MaybeApplyPatch::ShellParseError(e) => MaybeApplyPatchVerified::ShellParseError(e),
@@ -280,96 +247,33 @@ pub fn maybe_parse_apply_patch_verified(argv: &[String], cwd: &Path) -> MaybeApp
     }
 }
 
-/// Extract the heredoc body (and optional `cd` workdir) from a `bash -lc` script
-/// that invokes the apply_patch tool using a heredoc.
+/// Attempts to extract a heredoc_body object from a string bash command like:
+/// Optimistically
 ///
-/// Supported top‑level forms (must be the only top‑level statement):
-/// - `apply_patch <<'EOF'\n...\nEOF`
-/// - `cd <path> && apply_patch <<'EOF'\n...\nEOF`
+/// ```bash
+/// bash -lc 'apply_patch <<EOF\n***Begin Patch\n...EOF'
+/// ```
 ///
-/// Notes about matching:
-/// - Parsed with Tree‑sitter Bash and a strict query that uses anchors so the
-///   heredoc‑redirected statement is the only top‑level statement.
-/// - The connector between `cd` and `apply_patch` must be `&&` (not `|` or `||`).
-/// - Exactly one positional `word` argument is allowed for `cd` (no flags, no quoted
-///   strings, no second argument).
-/// - The apply command is validated in‑query via `#any-of?` to allow `apply_patch`
-///   or `applypatch`.
-/// - Preceding or trailing commands (e.g., `echo ...;` or `... && echo done`) do not match.
+/// # Arguments
 ///
-/// Returns `(heredoc_body, Some(path))` when the `cd` variant matches, or
-/// `(heredoc_body, None)` for the direct form. Errors are returned if the script
-/// cannot be parsed or does not match the allowed patterns.
-fn extract_apply_patch_from_bash(
+/// * `src` - A string slice that holds the full command
+///
+/// # Returns
+///
+/// This function returns a `Result` which is:
+///
+/// * `Ok(String)` - The heredoc body if the extraction is successful.
+/// * `Err(anyhow::Error)` - An error if the extraction fails.
+///
+fn extract_heredoc_body_from_apply_patch_command(
     src: &str,
-) -> std::result::Result<(String, Option<String>), ExtractHeredocError> {
-    // This function uses a Tree-sitter query to recognize one of two
-    // whole-script forms, each expressed as a single top-level statement:
-    //
-    // 1. apply_patch <<'EOF'\n...\nEOF
-    // 2. cd <path> && apply_patch <<'EOF'\n...\nEOF
-    //
-    // Key ideas when reading the query:
-    // - dots (`.`) between named nodes enforces adjacency among named children and
-    //   anchor to the start/end of the expression.
-    // - we match a single redirected_statement directly under program with leading
-    //   and trailing anchors (`.`). This ensures it is the only top-level statement
-    //   (so prefixes like `echo ...;` or suffixes like `... && echo done` do not match).
-    //
-    // Overall, we want to be conservative and only match the intended forms, as other
-    // forms are likely to be model errors, or incorrectly interpreted by later code.
-    //
-    // If you're editing this query, it's helpful to start by creating a debugging binary
-    // which will let you see the AST of an arbitrary bash script passed in, and optionally
-    // also run an arbitrary query against the AST. This is useful for understanding
-    // how tree-sitter parses the script and whether the query syntax is correct. Be sure
-    // to test both positive and negative cases.
-    static APPLY_PATCH_QUERY: Lazy<Query> = Lazy::new(|| {
-        let language = BASH.into();
-        #[expect(clippy::expect_used)]
-        Query::new(
-            &language,
-            r#"
-            (
-              program
-                . (redirected_statement
-                    body: (command
-                            name: (command_name (word) @apply_name) .)
-                    (#any-of? @apply_name "apply_patch" "applypatch")
-                    redirect: (heredoc_redirect
-                                . (heredoc_start)
-                                . (heredoc_body) @heredoc
-                                . (heredoc_end)
-                                .))
-                .)
-
-            (
-              program
-                . (redirected_statement
-                    body: (list
-                            . (command
-                                name: (command_name (word) @cd_name) .
-                                argument: [
-                                  (word) @cd_path
-                                  (string (string_content) @cd_path)
-                                  (raw_string) @cd_raw_string
-                                ] .)
-                            "&&"
-                            . (command
-                                name: (command_name (word) @apply_name))
-                            .)
-                    (#eq? @cd_name "cd")
-                    (#any-of? @apply_name "apply_patch" "applypatch")
-                    redirect: (heredoc_redirect
-                                . (heredoc_start)
-                                . (heredoc_body) @heredoc
-                                . (heredoc_end)
-                                .))
-                .)
-            "#,
-        )
-        .expect("valid bash query")
-    });
+) -> std::result::Result<String, ExtractHeredocError> {
+    if !APPLY_PATCH_COMMANDS
+        .iter()
+        .any(|cmd| src.trim_start().starts_with(cmd))
+    {
+        return Err(ExtractHeredocError::CommandDidNotStartWithApplyPatch);
+    }
 
     let lang = BASH.into();
     let mut parser = Parser::new();
@@ -381,55 +285,26 @@ fn extract_apply_patch_from_bash(
         .ok_or(ExtractHeredocError::FailedToParsePatchIntoAst)?;
 
     let bytes = src.as_bytes();
-    let root = tree.root_node();
+    let mut c = tree.root_node().walk();
 
-    let mut cursor = QueryCursor::new();
-    let mut matches = cursor.matches(&APPLY_PATCH_QUERY, root, bytes);
-    while let Some(m) = matches.next() {
-        let mut heredoc_text: Option<String> = None;
-        let mut cd_path: Option<String> = None;
+    loop {
+        let node = c.node();
+        if node.kind() == "heredoc_body" {
+            let text = node
+                .utf8_text(bytes)
+                .map_err(ExtractHeredocError::HeredocNotUtf8)?;
+            return Ok(text.trim_end_matches('\n').to_owned());
+        }
 
-        for capture in m.captures.iter() {
-            let name = APPLY_PATCH_QUERY.capture_names()[capture.index as usize];
-            match name {
-                "heredoc" => {
-                    let text = capture
-                        .node
-                        .utf8_text(bytes)
-                        .map_err(ExtractHeredocError::HeredocNotUtf8)?
-                        .trim_end_matches('\n')
-                        .to_string();
-                    heredoc_text = Some(text);
-                }
-                "cd_path" => {
-                    let text = capture
-                        .node
-                        .utf8_text(bytes)
-                        .map_err(ExtractHeredocError::HeredocNotUtf8)?
-                        .to_string();
-                    cd_path = Some(text);
-                }
-                "cd_raw_string" => {
-                    let raw = capture
-                        .node
-                        .utf8_text(bytes)
-                        .map_err(ExtractHeredocError::HeredocNotUtf8)?;
-                    let trimmed = raw
-                        .strip_prefix('\'')
-                        .and_then(|s| s.strip_suffix('\''))
-                        .unwrap_or(raw);
-                    cd_path = Some(trimmed.to_string());
-                }
-                _ => {}
+        if c.goto_first_child() {
+            continue;
+        }
+        while !c.goto_next_sibling() {
+            if !c.goto_parent() {
+                return Err(ExtractHeredocError::FailedToFindHeredocBody);
             }
         }
-
-        if let Some(heredoc) = heredoc_text {
-            return Ok((heredoc, cd_path));
-        }
     }
-
-    Err(ExtractHeredocError::CommandDidNotStartWithApplyPatch)
 }
 
 #[derive(Debug, PartialEq)]
@@ -830,49 +705,6 @@ mod tests {
         strs.iter().map(|s| s.to_string()).collect()
     }
 
-    // Test helpers to reduce repetition when building bash -lc heredoc scripts
-    fn args_bash(script: &str) -> Vec<String> {
-        strs_to_strings(&["bash", "-lc", script])
-    }
-
-    fn heredoc_script(prefix: &str) -> String {
-        format!(
-            "{prefix}apply_patch <<'PATCH'\n*** Begin Patch\n*** Add File: foo\n+hi\n*** End Patch\nPATCH"
-        )
-    }
-
-    fn heredoc_script_ps(prefix: &str, suffix: &str) -> String {
-        format!(
-            "{prefix}apply_patch <<'PATCH'\n*** Begin Patch\n*** Add File: foo\n+hi\n*** End Patch\nPATCH{suffix}"
-        )
-    }
-
-    fn expected_single_add() -> Vec<Hunk> {
-        vec![Hunk::AddFile {
-            path: PathBuf::from("foo"),
-            contents: "hi\n".to_string(),
-        }]
-    }
-
-    fn assert_match(script: &str, expected_workdir: Option<&str>) {
-        let args = args_bash(script);
-        match maybe_parse_apply_patch(&args) {
-            MaybeApplyPatch::Body(ApplyPatchArgs { hunks, workdir, .. }) => {
-                assert_eq!(workdir.as_deref(), expected_workdir);
-                assert_eq!(hunks, expected_single_add());
-            }
-            result => panic!("expected MaybeApplyPatch::Body got {result:?}"),
-        }
-    }
-
-    fn assert_not_match(script: &str) {
-        let args = args_bash(script);
-        assert!(matches!(
-            maybe_parse_apply_patch(&args),
-            MaybeApplyPatch::NotApplyPatch
-        ));
-    }
-
     #[test]
     fn test_literal() {
         let args = strs_to_strings(&[
@@ -885,7 +717,7 @@ mod tests {
         ]);
 
         match maybe_parse_apply_patch(&args) {
-            MaybeApplyPatch::Body(ApplyPatchArgs { hunks, .. }) => {
+            MaybeApplyPatch::Body(ApplyPatchArgs { hunks, patch: _ }) => {
                 assert_eq!(
                     hunks,
                     vec![Hunk::AddFile {
@@ -910,7 +742,7 @@ mod tests {
         ]);
 
         match maybe_parse_apply_patch(&args) {
-            MaybeApplyPatch::Body(ApplyPatchArgs { hunks, .. }) => {
+            MaybeApplyPatch::Body(ApplyPatchArgs { hunks, patch: _ }) => {
                 assert_eq!(
                     hunks,
                     vec![Hunk::AddFile {
@@ -925,7 +757,29 @@ mod tests {
 
     #[test]
     fn test_heredoc() {
-        assert_match(&heredoc_script(""), None);
+        let args = strs_to_strings(&[
+            "bash",
+            "-lc",
+            r#"apply_patch <<'PATCH'
+*** Begin Patch
+*** Add File: foo
++hi
+*** End Patch
+PATCH"#,
+        ]);
+
+        match maybe_parse_apply_patch(&args) {
+            MaybeApplyPatch::Body(ApplyPatchArgs { hunks, patch: _ }) => {
+                assert_eq!(
+                    hunks,
+                    vec![Hunk::AddFile {
+                        path: PathBuf::from("foo"),
+                        contents: "hi\n".to_string()
+                    }]
+                );
+            }
+            result => panic!("expected MaybeApplyPatch::Body got {result:?}"),
+        }
     }
 
     #[test]
@@ -942,8 +796,7 @@ PATCH"#,
         ]);
 
         match maybe_parse_apply_patch(&args) {
-            MaybeApplyPatch::Body(ApplyPatchArgs { hunks, workdir, .. }) => {
-                assert_eq!(workdir, None);
+            MaybeApplyPatch::Body(ApplyPatchArgs { hunks, patch: _ }) => {
                 assert_eq!(
                     hunks,
                     vec![Hunk::AddFile {
@@ -956,69 +809,6 @@ PATCH"#,
         }
     }
 
-    #[test]
-    fn test_heredoc_with_leading_cd() {
-        assert_match(&heredoc_script("cd foo && "), Some("foo"));
-    }
-
-    #[test]
-    fn test_cd_with_semicolon_is_ignored() {
-        assert_not_match(&heredoc_script("cd foo; "));
-    }
-
-    #[test]
-    fn test_cd_or_apply_patch_is_ignored() {
-        assert_not_match(&heredoc_script("cd bar || "));
-    }
-
-    #[test]
-    fn test_cd_pipe_apply_patch_is_ignored() {
-        assert_not_match(&heredoc_script("cd bar | "));
-    }
-
-    #[test]
-    fn test_cd_single_quoted_path_with_spaces() {
-        assert_match(&heredoc_script("cd 'foo bar' && "), Some("foo bar"));
-    }
-
-    #[test]
-    fn test_cd_double_quoted_path_with_spaces() {
-        assert_match(&heredoc_script("cd \"foo bar\" && "), Some("foo bar"));
-    }
-
-    #[test]
-    fn test_echo_and_apply_patch_is_ignored() {
-        assert_not_match(&heredoc_script("echo foo && "));
-    }
-
-    #[test]
-    fn test_apply_patch_with_arg_is_ignored() {
-        let script = "apply_patch foo <<'PATCH'\n*** Begin Patch\n*** Add File: foo\n+hi\n*** End Patch\nPATCH";
-        assert_not_match(script);
-    }
-
-    #[test]
-    fn test_double_cd_then_apply_patch_is_ignored() {
-        assert_not_match(&heredoc_script("cd foo && cd bar && "));
-    }
-
-    #[test]
-    fn test_cd_two_args_is_ignored() {
-        assert_not_match(&heredoc_script("cd foo bar && "));
-    }
-
-    #[test]
-    fn test_cd_then_apply_patch_then_extra_is_ignored() {
-        let script = heredoc_script_ps("cd bar && ", " && echo done");
-        assert_not_match(&script);
-    }
-
-    #[test]
-    fn test_echo_then_cd_and_apply_patch_is_ignored() {
-        // Ensure preceding commands before the `cd && apply_patch <<...` sequence do not match.
-        assert_not_match(&heredoc_script("echo foo; cd bar && "));
-    }
-
     #[test]
     fn test_add_file_hunk_creates_file_with_contents() {
         let dir = tempdir().unwrap();

codex-rs/apply-patch/src/parser.rs

@@ -175,11 +175,7 @@ fn parse_patch_text(patch: &str, mode: ParseMode) -> Result<ApplyPatchArgs, Pars
         remaining_lines = &remaining_lines[hunk_lines..]
     }
     let patch = lines.join("\n");
-    Ok(ApplyPatchArgs {
-        hunks,
-        patch,
-        workdir: None,
-    })
+    Ok(ApplyPatchArgs { hunks, patch })
 }
 
 /// Checks the start and end lines of the patch text for `apply_patch`,
@@ -590,8 +586,7 @@ fn test_parse_patch_lenient() {
         parse_patch_text(&patch_text_in_heredoc, ParseMode::Lenient),
         Ok(ApplyPatchArgs {
             hunks: expected_patch.clone(),
-            patch: patch_text.to_string(),
-            workdir: None,
+            patch: patch_text.to_string()
         })
     );
 
@@ -604,8 +599,7 @@ fn test_parse_patch_lenient() {
         parse_patch_text(&patch_text_in_single_quoted_heredoc, ParseMode::Lenient),
         Ok(ApplyPatchArgs {
             hunks: expected_patch.clone(),
-            patch: patch_text.to_string(),
-            workdir: None,
+            patch: patch_text.to_string()
         })
     );
 
@@ -618,8 +612,7 @@ fn test_parse_patch_lenient() {
         parse_patch_text(&patch_text_in_double_quoted_heredoc, ParseMode::Lenient),
         Ok(ApplyPatchArgs {
             hunks: expected_patch.clone(),
-            patch: patch_text.to_string(),
-            workdir: None,
+            patch: patch_text.to_string()
         })
     );
 

codex-rs/chatgpt/Cargo.toml

@@ -11,7 +11,7 @@ anyhow = "1"
 clap = { version = "4", features = ["derive"] }
 codex-common = { path = "../common", features = ["cli"] }
 codex-core = { path = "../core" }
-codex-protocol = { path = "../protocol" }
+codex-login = { path = "../login" }
 reqwest = { version = "0.12", features = ["json", "stream"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

codex-rs/chatgpt/src/chatgpt_token.rs

@@ -1,10 +1,10 @@
-use codex_core::CodexAuth;
-use codex_protocol::mcp_protocol::AuthMode;
+use codex_login::AuthMode;
+use codex_login::CodexAuth;
 use std::path::Path;
 use std::sync::LazyLock;
 use std::sync::RwLock;
 
-use codex_core::token_data::TokenData;
+use codex_login::TokenData;
 
 static CHATGPT_TOKEN: LazyLock<RwLock<Option<TokenData>>> = LazyLock::new(|| RwLock::new(None));
 

codex-rs/cli/Cargo.toml

@@ -28,6 +28,9 @@ codex-mcp-server = { path = "../mcp-server" }
 codex-protocol = { path = "../protocol" }
 codex-tui = { path = "../tui" }
 serde_json = "1"
+toml = "0.9.5"
+toml_edit = "0.23.4"
+tempfile = "3"
 tokio = { version = "1", features = [
     "io-std",
     "macros",
@@ -38,3 +41,6 @@ tokio = { version = "1", features = [
 tracing = "0.1.41"
 tracing-subscriber = "0.3.19"
 codex-protocol-ts = { path = "../protocol-ts" }
+
+[dev-dependencies]
+assert_cmd = "2"

codex-rs/cli/src/lib.rs

@@ -1,6 +1,7 @@
 pub mod debug_sandbox;
 mod exit_status;
 pub mod login;
+pub mod mcp_cmd;
 pub mod proto;
 
 use clap::Parser;

codex-rs/cli/src/login.rs

@@ -1,14 +1,14 @@
 use codex_common::CliConfigOverrides;
-use codex_core::CodexAuth;
-use codex_core::auth::CLIENT_ID;
-use codex_core::auth::OPENAI_API_KEY_ENV_VAR;
-use codex_core::auth::login_with_api_key;
-use codex_core::auth::logout;
 use codex_core::config::Config;
 use codex_core::config::ConfigOverrides;
+use codex_login::AuthMode;
+use codex_login::CLIENT_ID;
+use codex_login::CodexAuth;
+use codex_login::OPENAI_API_KEY_ENV_VAR;
 use codex_login::ServerOptions;
+use codex_login::login_with_api_key;
+use codex_login::logout;
 use codex_login::run_login_server;
-use codex_protocol::mcp_protocol::AuthMode;
 use std::env;
 use std::path::PathBuf;
 

codex-rs/cli/src/main.rs

@@ -11,6 +11,8 @@ use codex_cli::login::run_login_status;
 use codex_cli::login::run_login_with_api_key;
 use codex_cli::login::run_login_with_chatgpt;
 use codex_cli::login::run_logout;
+use codex_cli::mcp_cmd;
+use codex_cli::mcp_cmd::McpCli;
 use codex_cli::proto;
 use codex_common::CliConfigOverrides;
 use codex_exec::Cli as ExecCli;
@@ -56,8 +58,8 @@ enum Subcommand {
     /// Remove stored authentication credentials.
     Logout(LogoutCommand),
 
-    /// Experimental: run Codex as an MCP server.
-    Mcp,
+    /// Experimental: run Codex as an MCP server and manage MCP config.
+    Mcp(McpCli),
 
     /// Run the Protocol stream via stdin/stdout
     #[clap(visible_alias = "p")]
@@ -158,8 +160,9 @@ async fn cli_main(codex_linux_sandbox_exe: Option<PathBuf>) -> anyhow::Result<()
             prepend_config_flags(&mut exec_cli.config_overrides, cli.config_overrides);
             codex_exec::run_main(exec_cli, codex_linux_sandbox_exe).await?;
         }
-        Some(Subcommand::Mcp) => {
-            codex_mcp_server::run_main(codex_linux_sandbox_exe, cli.config_overrides).await?;
+        Some(Subcommand::Mcp(mut mcp_cli)) => {
+            prepend_config_flags(&mut mcp_cli.config_overrides, cli.config_overrides);
+            mcp_cmd::run_main(mcp_cli, codex_linux_sandbox_exe).await?;
         }
         Some(Subcommand::Login(mut login_cli)) => {
             prepend_config_flags(&mut login_cli.config_overrides, cli.config_overrides);

codex-rs/cli/src/mcp_cmd.rs

@@ -0,0 +1,641 @@
+use std::collections::BTreeSet;
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::Parser;
+use codex_common::CliConfigOverrides;
+use codex_core::config::find_codex_home;
+use codex_core::config::load_config_as_toml_with_cli_overrides;
+use codex_core::config_types::McpServerConfig;
+use codex_core::git_info::resolve_root_git_project_for_trust;
+use codex_core::mcp_toml::McpToml;
+use codex_core::mcp_toml::McpTomlEntry;
+use codex_core::mcp_toml::load_project_overlays;
+use codex_core::mcp_toml::to_mcp_server_config;
+use serde_json::json;
+use tempfile as _;
+use toml::Value as TomlValue;
+use toml_edit as _; // ensure dependency is linked
+
+#[derive(Debug, Parser)]
+#[command(
+    about = "Manage MCP servers and run Codex as an MCP server",
+    long_about = "Manage Model Context Protocol (MCP) servers configured for Codex.\n\nUse subcommands to add, import, list, inspect, or remove servers.\nIf no subcommand is provided, this runs the built-in MCP server (back-compat).",
+    after_help = "Examples:\n  # Add a local stdio server (everything after -- is the server command)\n  codex mcp add airtable --env AIRTABLE_API_KEY=YOUR_KEY -- npx -y airtable-mcp-server\n\n  # Import multiple servers from a TOML file into project scope\n  codex mcp add-toml --scope project ./mcp.toml\n\n  # List configured servers (merged view with precedence local > project > user)\n  codex mcp list --json\n\n  # Show details for a specific server\n  codex mcp get airtable --json\n\n  # Remove a server from the user scope\n  codex mcp remove airtable --scope user\n\n  # Remove a server from all scopes\n  codex mcp remove airtable --all\n\n  # Windows: wrap npx with cmd /c\n  codex mcp add my-svc -- cmd /c npx -y @some/package"
+)]
+pub struct McpCli {
+    #[clap(skip)]
+    pub config_overrides: CliConfigOverrides,
+
+    #[command(subcommand)]
+    pub cmd: Option<McpSub>,
+}
+
+#[derive(Debug, clap::Subcommand)]
+pub enum McpSub {
+    /// Run Codex as an MCP server (back-compat: `codex mcp`).
+    Serve,
+    /// List configured MCP servers (merged view).
+    List {
+        #[arg(long)]
+        json: bool,
+    },
+    /// Get details for a specific server name (merged view).
+    Get {
+        name: String,
+        #[arg(long)]
+        json: bool,
+    },
+    /// Add an MCP stdio server entry to a given scope.
+    Add(AddArgs),
+    /// Remove an MCP server entry from a given scope or all scopes.
+    Remove(RemoveArgs),
+    /// Import one or more MCP servers from a TOML file with a [mcp_servers] table.
+    AddToml(AddTomlArgs),
+}
+
+pub async fn run_main(mcp_cli: McpCli, codex_linux_sandbox_exe: Option<PathBuf>) -> Result<()> {
+    match mcp_cli.cmd.unwrap_or(McpSub::Serve) {
+        McpSub::Serve => {
+            // Preserve the historical `codex mcp` behavior.
+            codex_mcp_server::run_main(codex_linux_sandbox_exe, mcp_cli.config_overrides).await?
+        }
+        McpSub::List { json } => {
+            list_servers(mcp_cli.config_overrides, json)?;
+        }
+        McpSub::Get { name, json } => {
+            get_server(mcp_cli.config_overrides, &name, json)?;
+        }
+        McpSub::Add(args) => {
+            add_server(mcp_cli.config_overrides, args)?;
+        }
+        McpSub::Remove(args) => {
+            remove_server(mcp_cli.config_overrides, args)?;
+        }
+        McpSub::AddToml(args) => {
+            add_toml(mcp_cli.config_overrides, args)?;
+        }
+    }
+    Ok(())
+}
+
+fn parse_cli_overrides(overrides: CliConfigOverrides) -> Vec<(String, TomlValue)> {
+    overrides.parse_overrides().unwrap_or_default()
+}
+
+fn load_user_project_local_maps(
+    cli_overrides: CliConfigOverrides,
+) -> Result<(
+    HashMap<String, McpServerConfig>,
+    HashMap<String, McpServerConfig>,
+    HashMap<String, McpServerConfig>,
+)> {
+    // User map via `~/.codex/config.toml` (+ -c overrides)
+    let codex_home = find_codex_home()?;
+    let user_cfg =
+        load_config_as_toml_with_cli_overrides(&codex_home, parse_cli_overrides(cli_overrides))?;
+    let mut user_map = user_cfg.mcp_servers;
+
+    // Project/local overlays via current project root
+    let cwd = std::env::current_dir()?;
+    let project_root = resolve_root_git_project_for_trust(&cwd).unwrap_or(cwd);
+    let overlays = load_project_overlays(&project_root)?;
+
+    let mut project_map = HashMap::new();
+    let mut local_map = HashMap::new();
+    for (scope, overlay) in overlays {
+        for (name, entry) in overlay.mcp_servers.into_iter() {
+            // Convert permissive overlay entry → strict config, expanding env vars.
+            if let Ok(cfg) = to_mcp_server_config(&entry, |k| std::env::var(k).ok()) {
+                match scope {
+                    codex_core::mcp_toml::Scope::Project => {
+                        project_map.insert(name, cfg);
+                    }
+                    codex_core::mcp_toml::Scope::Local => {
+                        local_map.insert(name, cfg);
+                    }
+                    codex_core::mcp_toml::Scope::User => {
+                        user_map.insert(name, cfg);
+                    }
+                }
+            }
+        }
+    }
+
+    Ok((user_map, project_map, local_map))
+}
+
+fn list_servers(cli_overrides: CliConfigOverrides, json_out: bool) -> Result<()> {
+    let (user_map, project_map, local_map) = load_user_project_local_maps(cli_overrides)?;
+    let mut names: BTreeSet<String> = BTreeSet::new();
+    names.extend(user_map.keys().cloned());
+    names.extend(project_map.keys().cloned());
+    names.extend(local_map.keys().cloned());
+
+    if json_out {
+        let mut arr = Vec::new();
+        for name in names {
+            let (scope, cfg, shadowed_by) =
+                pick_with_scope(&name, &user_map, &project_map, &local_map);
+            arr.push(json!({
+                "name": name,
+                "scope": scope,
+                "config": cfg_to_json(cfg),
+                "shadowed_by": shadowed_by,
+            }));
+        }
+        println!("{}", serde_json::to_string_pretty(&arr)?);
+    } else {
+        for name in names {
+            let (scope, cfg, _) = pick_with_scope(&name, &user_map, &project_map, &local_map);
+            let args_preview = if cfg.args.is_empty() {
+                String::new()
+            } else {
+                format!(" {}", cfg.args.join(" "))
+            };
+            println!("{} [{}] -> {}{}", name, scope, cfg.command, args_preview);
+        }
+    }
+    Ok(())
+}
+
+fn get_server(cli_overrides: CliConfigOverrides, name: &str, json_out: bool) -> Result<()> {
+    let (user_map, project_map, local_map) = load_user_project_local_maps(cli_overrides)?;
+    if !user_map.contains_key(name)
+        && !project_map.contains_key(name)
+        && !local_map.contains_key(name)
+    {
+        anyhow::bail!("MCP server `{}` not found in any scope", name);
+    }
+    let (scope, cfg, shadowed_by) = pick_with_scope(name, &user_map, &project_map, &local_map);
+    if json_out {
+        let obj = json!({
+            "name": name,
+            "scope": scope,
+            "config": cfg_to_json(cfg),
+            "shadowed_by": shadowed_by,
+        });
+        println!("{}", serde_json::to_string_pretty(&obj)?);
+    } else {
+        let args_preview = if cfg.args.is_empty() {
+            String::new()
+        } else {
+            format!(" {}", cfg.args.join(" "))
+        };
+        println!("{} [{}] -> {}{}", name, scope, cfg.command, args_preview);
+    }
+    Ok(())
+}
+
+fn pick_with_scope<'a>(
+    name: &str,
+    user_map: &'a HashMap<String, McpServerConfig>,
+    project_map: &'a HashMap<String, McpServerConfig>,
+    local_map: &'a HashMap<String, McpServerConfig>,
+) -> (&'static str, &'a McpServerConfig, Vec<&'static str>) {
+    if let Some(cfg) = local_map.get(name) {
+        (
+            "local",
+            cfg,
+            vec![
+                if project_map.contains_key(name) {
+                    "project"
+                } else {
+                    ""
+                },
+                if user_map.contains_key(name) {
+                    "user"
+                } else {
+                    ""
+                },
+            ]
+            .into_iter()
+            .filter(|s| !s.is_empty())
+            .collect(),
+        )
+    } else if let Some(cfg) = project_map.get(name) {
+        (
+            "project",
+            cfg,
+            vec![if user_map.contains_key(name) {
+                "user"
+            } else {
+                ""
+            }]
+            .into_iter()
+            .filter(|s| !s.is_empty())
+            .collect(),
+        )
+    } else if let Some(cfg) = user_map.get(name) {
+        ("user", cfg, vec![])
+    } else {
+        // Should not occur because callers pre-check membership. Return a
+        // fallback to avoid panics in release builds.
+        let fallback = user_map
+            .iter()
+            .next()
+            .or_else(|| project_map.iter().next())
+            .or_else(|| local_map.iter().next());
+        let (k, v) = match fallback {
+            Some(kv) => kv,
+            None => panic!("internal error: no MCP server entries found across scopes"),
+        };
+        let _ = k; // suppress unused warning
+        ("user", v, vec![])
+    }
+}
+
+fn cfg_to_json(cfg: &McpServerConfig) -> serde_json::Value {
+    json!({
+        "command": cfg.command,
+        "args": cfg.args,
+        "env": cfg.env,
+    })
+}
+
+// ------------------------------
+// Add/remove writers
+// ------------------------------
+
+#[derive(Copy, Clone, Debug, clap::ValueEnum)]
+enum ScopeArg {
+    Local,
+    Project,
+    User,
+}
+
+#[derive(Debug, Parser)]
+pub struct AddArgs {
+    /// Unique server name (^[A-Za-z0-9_-]+$)
+    name: String,
+    /// Target scope
+    #[arg(long, value_enum, default_value_t = ScopeArg::Local)]
+    scope: ScopeArg,
+    /// Environment variables KEY=VALUE (repeatable)
+    #[arg(long = "env")]
+    env: Vec<String>,
+    /// Command and args to launch the MCP server (after `--`)
+    #[arg(trailing_var_arg = true)]
+    cmd: Vec<String>,
+}
+
+#[derive(Debug, Parser)]
+pub struct RemoveArgs {
+    /// Server name
+    name: String,
+    /// Scope to remove from; omit with --all to remove everywhere
+    #[arg(long, value_enum)]
+    scope: Option<ScopeArg>,
+    /// Remove from all scopes
+    #[arg(long)]
+    all: bool,
+}
+
+fn add_server(cli_overrides: CliConfigOverrides, args: AddArgs) -> Result<()> {
+    validate_server_name(&args.name)?;
+    if args.cmd.is_empty() {
+        anyhow::bail!(
+            "missing server command; use: codex mcp add <name> [--scope ...] [--env KEY=VALUE]... -- <command> [args...]"
+        );
+    }
+    let command = args.cmd[0].clone();
+    let cmd_args: Vec<String> = args.cmd.iter().skip(1).cloned().collect();
+    let env_map = parse_env_kv(args.env.iter())?;
+
+    let path = match args.scope {
+        ScopeArg::User => {
+            write_user_scope(&args.name, &command, &cmd_args, &env_map, cli_overrides)?
+        }
+        ScopeArg::Project => write_overlay_scope(&args.name, &command, &cmd_args, &env_map, false)?,
+        ScopeArg::Local => write_overlay_scope(&args.name, &command, &cmd_args, &env_map, true)?,
+    };
+    println!(
+        "Added MCP server '{}' (scope: {}) → wrote {}",
+        args.name,
+        match args.scope {
+            ScopeArg::Local => "local",
+            ScopeArg::Project => "project",
+            ScopeArg::User => "user",
+        },
+        path.display()
+    );
+    Ok(())
+}
+
+fn remove_server(cli_overrides: CliConfigOverrides, args: RemoveArgs) -> Result<()> {
+    if args.all && args.scope.is_some() {
+        anyhow::bail!("cannot use --scope with --all");
+    }
+
+    if args.all {
+        let u = remove_user_scope(&args.name, cli_overrides.clone())?;
+        if u.wrote {
+            println!("Removed '{}' → wrote {}", args.name, u.path.display());
+        }
+        let p = remove_overlay_scope(&args.name, false)?;
+        if p.wrote {
+            println!("Removed '{}' → wrote {}", args.name, p.path.display());
+        }
+        let l = remove_overlay_scope(&args.name, true)?;
+        if l.wrote {
+            println!("Removed '{}' → wrote {}", args.name, l.path.display());
+        }
+        return Ok(());
+    }
+
+    let outcome = match args.scope.unwrap_or(ScopeArg::Local) {
+        ScopeArg::User => remove_user_scope(&args.name, cli_overrides)?,
+        ScopeArg::Project => remove_overlay_scope(&args.name, false)?,
+        ScopeArg::Local => remove_overlay_scope(&args.name, true)?,
+    };
+    if outcome.wrote {
+        println!("Removed '{}' → wrote {}", args.name, outcome.path.display());
+    } else {
+        println!(
+            "No changes for '{}' at {}",
+            args.name,
+            outcome.path.display()
+        );
+    }
+    Ok(())
+}
+
+#[derive(Debug, Parser)]
+pub struct AddTomlArgs {
+    /// Path to a TOML file containing a [mcp_servers] table
+    path: PathBuf,
+    /// Target scope to import into
+    #[arg(long, value_enum, default_value_t = ScopeArg::Local)]
+    scope: ScopeArg,
+}
+
+fn add_toml(_cli_overrides: CliConfigOverrides, args: AddTomlArgs) -> Result<()> {
+    let contents = std::fs::read_to_string(&args.path)?;
+    let parsed: McpToml = toml::from_str(&contents)?;
+    let mut accepted: Vec<(String, McpTomlEntry)> = Vec::new();
+    let mut rejected: Vec<(String, String)> = Vec::new();
+    for (name, entry) in parsed.mcp_servers.into_iter() {
+        if let Some(t) = entry.r#type.as_deref()
+            && !t.eq_ignore_ascii_case("stdio")
+        {
+            rejected.push((name, format!("unsupported transport `{}`", t)));
+            continue;
+        }
+        if entry.command.is_none() {
+            rejected.push((name, "missing command".to_string()));
+            continue;
+        }
+        accepted.push((name, entry));
+    }
+
+    let path = match args.scope {
+        ScopeArg::User => write_user_batch(&accepted)?,
+        ScopeArg::Project => write_overlay_batch(&accepted, false)?,
+        ScopeArg::Local => write_overlay_batch(&accepted, true)?,
+    };
+    println!(
+        "Imported {} MCP server(s) into {}",
+        accepted.len(),
+        path.display()
+    );
+
+    if !rejected.is_empty() {
+        for (n, why) in rejected {
+            eprintln!("skipped `{}`: {}", n, why);
+        }
+    }
+    Ok(())
+}
+
+fn parse_env_kv<'a>(pairs: impl Iterator<Item = &'a String>) -> Result<HashMap<String, String>> {
+    let mut map = HashMap::new();
+    for p in pairs {
+        if let Some((k, v)) = p.split_once('=') {
+            if k.is_empty() {
+                anyhow::bail!("invalid --env '{}': empty key", p);
+            }
+            map.insert(k.to_string(), v.to_string());
+        } else {
+            anyhow::bail!("invalid --env '{}': expected KEY=VALUE", p);
+        }
+    }
+    Ok(map)
+}
+
+fn validate_server_name(name: &str) -> Result<()> {
+    let ok = !name.is_empty()
+        && name
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-');
+    if ok {
+        Ok(())
+    } else {
+        anyhow::bail!(
+            "invalid server name '{}': must match ^[a-zA-Z0-9_-]+$",
+            name
+        )
+    }
+}
+
+fn resolve_codex_home_for_write() -> Result<PathBuf> {
+    if let Ok(val) = std::env::var("CODEX_HOME")
+        && !val.is_empty()
+    {
+        let p = PathBuf::from(val);
+        if !p.exists() {
+            std::fs::create_dir_all(&p)?;
+        }
+        return Ok(p.canonicalize().unwrap_or(p));
+    }
+    let p = find_codex_home()?;
+    if !p.exists() {
+        std::fs::create_dir_all(&p)?;
+    }
+    Ok(p)
+}
+
+fn write_user_scope(
+    name: &str,
+    command: &str,
+    args: &[String],
+    env_map: &HashMap<String, String>,
+    cli_overrides: CliConfigOverrides,
+) -> Result<PathBuf> {
+    let codex_home = resolve_codex_home_for_write()?;
+    let path = codex_home.join("config.toml");
+    let contents = std::fs::read_to_string(&path).unwrap_or_default();
+    let mut doc = contents
+        .parse::<toml_edit::DocumentMut>()
+        .unwrap_or_default();
+    upsert_mcp_entry(&mut doc, name, command, args, env_map);
+    write_doc_atomic(&doc, &path)?;
+    let _ = cli_overrides;
+    Ok(path)
+}
+
+fn write_overlay_scope(
+    name: &str,
+    command: &str,
+    args: &[String],
+    env_map: &HashMap<String, String>,
+    local: bool,
+) -> Result<PathBuf> {
+    let cwd = std::env::current_dir()?;
+    let project_root = resolve_root_git_project_for_trust(&cwd).unwrap_or(cwd);
+    let fname = if local {
+        ".mcp.local.toml"
+    } else {
+        ".mcp.toml"
+    };
+    let path = project_root.join(fname);
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    let contents = std::fs::read_to_string(&path).unwrap_or_default();
+    let mut doc = contents
+        .parse::<toml_edit::DocumentMut>()
+        .unwrap_or_default();
+    upsert_mcp_entry(&mut doc, name, command, args, env_map);
+    write_doc_atomic(&doc, &path)?;
+    Ok(path)
+}
+
+fn write_user_batch(entries: &[(String, McpTomlEntry)]) -> Result<PathBuf> {
+    let codex_home = resolve_codex_home_for_write()?;
+    let path = codex_home.join("config.toml");
+    let contents = std::fs::read_to_string(&path).unwrap_or_default();
+    let mut doc = contents
+        .parse::<toml_edit::DocumentMut>()
+        .unwrap_or_default();
+    for (name, entry) in entries {
+        let args = entry.args.clone();
+        let env_map = entry.env.clone();
+        let command = entry.command.clone().unwrap_or_default();
+        upsert_mcp_entry(&mut doc, name, &command, &args, &env_map);
+    }
+    write_doc_atomic(&doc, &path)?;
+    Ok(path)
+}
+
+fn write_overlay_batch(entries: &[(String, McpTomlEntry)], local: bool) -> Result<PathBuf> {
+    let cwd = std::env::current_dir()?;
+    let project_root = resolve_root_git_project_for_trust(&cwd).unwrap_or(cwd);
+    let fname = if local {
+        ".mcp.local.toml"
+    } else {
+        ".mcp.toml"
+    };
+    let path = project_root.join(fname);
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    let contents = std::fs::read_to_string(&path).unwrap_or_default();
+    let mut doc = contents
+        .parse::<toml_edit::DocumentMut>()
+        .unwrap_or_default();
+    for (name, entry) in entries {
+        let args = entry.args.clone();
+        let env_map = entry.env.clone();
+        let command = entry.command.clone().unwrap_or_default();
+        upsert_mcp_entry(&mut doc, name, &command, &args, &env_map);
+    }
+    write_doc_atomic(&doc, &path)?;
+    Ok(path)
+}
+
+struct RemoveOutcome {
+    path: PathBuf,
+    wrote: bool,
+}
+
+fn remove_user_scope(name: &str, _cli_overrides: CliConfigOverrides) -> Result<RemoveOutcome> {
+    let codex_home = resolve_codex_home_for_write()?;
+    let path = codex_home.join("config.toml");
+    if !path.exists() {
+        return Ok(RemoveOutcome { path, wrote: false });
+    }
+    let contents = std::fs::read_to_string(&path)?;
+    let mut doc = contents.parse::<toml_edit::DocumentMut>()?;
+    if let Some(tbl) = doc.get_mut("mcp_servers").and_then(|i| i.as_table_mut()) {
+        if tbl.remove(name).is_some() {
+            write_doc_atomic(&doc, &path)?;
+            return Ok(RemoveOutcome { path, wrote: true });
+        }
+    }
+    Ok(RemoveOutcome { path, wrote: false })
+}
+
+fn remove_overlay_scope(name: &str, local: bool) -> Result<RemoveOutcome> {
+    let cwd = std::env::current_dir()?;
+    let project_root = resolve_root_git_project_for_trust(&cwd).unwrap_or(cwd);
+    let fname = if local {
+        ".mcp.local.toml"
+    } else {
+        ".mcp.toml"
+    };
+    let path = project_root.join(fname);
+    if !path.exists() {
+        return Ok(RemoveOutcome { path, wrote: false });
+    }
+    let contents = std::fs::read_to_string(&path)?;
+    let mut doc = contents.parse::<toml_edit::DocumentMut>()?;
+    if let Some(tbl) = doc.get_mut("mcp_servers").and_then(|i| i.as_table_mut()) {
+        if tbl.remove(name).is_some() {
+            write_doc_atomic(&doc, &path)?;
+            return Ok(RemoveOutcome { path, wrote: true });
+        }
+    }
+    Ok(RemoveOutcome { path, wrote: false })
+}
+
+fn upsert_mcp_entry(
+    doc: &mut toml_edit::DocumentMut,
+    name: &str,
+    command: &str,
+    args: &[String],
+    env_map: &HashMap<String, String>,
+) {
+    if !doc.as_table().contains_key("mcp_servers") {
+        doc.insert("mcp_servers", toml_edit::table());
+    }
+    let tbl = doc["mcp_servers"].as_table_mut().expect("table");
+    tbl.set_implicit(false);
+
+    if !tbl.contains_key(name) {
+        tbl.insert(name, toml_edit::table());
+    }
+    let st = tbl[name].as_table_mut().expect("subtable");
+    st.set_implicit(false);
+
+    st["command"] = toml_edit::value(command);
+    let mut arr = toml_edit::Array::new();
+    for a in args {
+        arr.push(a.as_str());
+    }
+    st["args"] = toml_edit::Item::Value(toml_edit::Value::Array(arr));
+
+    if env_map.is_empty() {
+        if st.contains_key("env") {
+            st.remove("env");
+        }
+    } else {
+        let mut kv = toml_edit::InlineTable::new();
+        for (k, v) in env_map {
+            kv.get_or_insert(k, toml_edit::Value::from(v.as_str()));
+        }
+        st["env"] = toml_edit::Item::Value(toml_edit::Value::InlineTable(kv));
+    }
+}
+
+fn write_doc_atomic(doc: &toml_edit::DocumentMut, path: &PathBuf) -> Result<()> {
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    let tmp = tempfile::NamedTempFile::new_in(
+        path.parent().unwrap_or_else(|| std::path::Path::new(".")),
+    )?;
+    std::fs::write(tmp.path(), doc.to_string())?;
+    tmp.persist(path)?;
+    Ok(())
+}

codex-rs/cli/src/proto.rs

@@ -2,7 +2,6 @@ use std::io::IsTerminal;
 
 use clap::Parser;
 use codex_common::CliConfigOverrides;
-use codex_core::AuthManager;
 use codex_core::ConversationManager;
 use codex_core::NewConversation;
 use codex_core::config::Config;
@@ -10,6 +9,7 @@ use codex_core::config::ConfigOverrides;
 use codex_core::protocol::Event;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::Submission;
+use codex_login::AuthManager;
 use tokio::io::AsyncBufReadExt;
 use tokio::io::BufReader;
 use tracing::error;

codex-rs/cli/tests/mcp_add_remove.rs

@@ -0,0 +1,88 @@
+use assert_cmd::prelude::*;
+use std::fs;
+use std::process::Command;
+
+fn write(path: &std::path::Path, contents: &str) {
+    fs::write(path, contents).unwrap();
+}
+
+#[test]
+fn add_and_remove_user_scope() {
+    let codex_home = tempfile::tempdir().unwrap();
+    // Pre-create CODEX_HOME for canonicalization logic
+    let config_path = codex_home.path().join("config.toml");
+
+    let project_dir = tempfile::tempdir().unwrap();
+    write(&project_dir.path().join(".git"), "gitdir: nowhere");
+
+    // Add
+    Command::cargo_bin("codex")
+        .unwrap()
+        .current_dir(project_dir.path())
+        .env("CODEX_HOME", codex_home.path())
+        .args([
+            "mcp", "add", "svc", "--scope", "user", "--", "tool", "--flag",
+        ])
+        .assert()
+        .success();
+
+    let config = fs::read_to_string(&config_path).unwrap();
+    assert!(config.contains("[mcp_servers.svc]"));
+    assert!(config.contains("command = \"tool\""));
+
+    // Remove
+    Command::cargo_bin("codex")
+        .unwrap()
+        .current_dir(project_dir.path())
+        .env("CODEX_HOME", codex_home.path())
+        .args(["mcp", "remove", "svc", "--scope", "user"])
+        .assert()
+        .success();
+
+    let config_after = fs::read_to_string(&config_path).unwrap();
+    assert!(!config_after.contains("[mcp_servers.svc]"));
+}
+
+#[test]
+fn add_local_and_project_scopes() {
+    let codex_home = tempfile::tempdir().unwrap();
+    let project_dir = tempfile::tempdir().unwrap();
+    write(&project_dir.path().join(".git"), "gitdir: nowhere");
+
+    // Add project
+    Command::cargo_bin("codex")
+        .unwrap()
+        .current_dir(project_dir.path())
+        .env("CODEX_HOME", codex_home.path())
+        .args(["mcp", "add", "svc", "--scope", "project", "--", "toolp"])
+        .assert()
+        .success();
+    let proj = fs::read_to_string(project_dir.path().join(".mcp.toml")).unwrap();
+    assert!(proj.contains("[mcp_servers.svc]"));
+    assert!(proj.contains("toolp"));
+
+    // Add local (override in precedence for merged view)
+    Command::cargo_bin("codex")
+        .unwrap()
+        .current_dir(project_dir.path())
+        .env("CODEX_HOME", codex_home.path())
+        .args(["mcp", "add", "svc", "--scope", "local", "--", "tooll"])
+        .assert()
+        .success();
+    let local = fs::read_to_string(project_dir.path().join(".mcp.local.toml")).unwrap();
+    assert!(local.contains("tooll"));
+
+    // Remove all
+    Command::cargo_bin("codex")
+        .unwrap()
+        .current_dir(project_dir.path())
+        .env("CODEX_HOME", codex_home.path())
+        .args(["mcp", "remove", "svc", "--all"])
+        .assert()
+        .success();
+
+    let proj_after = fs::read_to_string(project_dir.path().join(".mcp.toml")).unwrap();
+    assert!(!proj_after.contains("[mcp_servers.svc]"));
+    let local_after = fs::read_to_string(project_dir.path().join(".mcp.local.toml")).unwrap();
+    assert!(!local_after.contains("[mcp_servers.svc]"));
+}

codex-rs/cli/tests/mcp_add_toml.rs

@@ -0,0 +1,133 @@
+use assert_cmd::prelude::*;
+use serde_json::Value;
+use std::fs;
+use std::process::Command;
+
+fn write(path: &std::path::Path, contents: &str) {
+    fs::write(path, contents).unwrap();
+}
+
+#[test]
+fn add_toml_local_filters_non_stdio_and_lists() {
+    let codex_home = tempfile::tempdir().unwrap();
+    let project_dir = tempfile::tempdir().unwrap();
+    write(&project_dir.path().join(".git"), "gitdir: nowhere");
+
+    let import = tempfile::NamedTempFile::new().unwrap();
+    write(
+        import.path(),
+        r#"[mcp_servers.ok]
+type = "stdio"
+command = "tool"
+args = ["--x"]
+env = { K = "V" }
+
+[mcp_servers.bad]
+type = "http"
+url = "https://example.invalid/mcp"
+
+[mcp_servers.missing]
+type = "stdio"
+"#,
+    );
+
+    // Import into local scope
+    Command::cargo_bin("codex")
+        .unwrap()
+        .current_dir(project_dir.path())
+        .env("CODEX_HOME", codex_home.path())
+        .args([
+            "mcp",
+            "add-toml",
+            "--scope",
+            "local",
+            import.path().to_str().unwrap(),
+        ])
+        .assert()
+        .success();
+
+    // Verify file contents
+    let local_contents = fs::read_to_string(project_dir.path().join(".mcp.local.toml")).unwrap();
+    assert!(local_contents.contains("[mcp_servers.ok]"));
+    assert!(local_contents.contains("command = \"tool\""));
+    assert!(!local_contents.contains("[mcp_servers.bad]"));
+    assert!(!local_contents.contains("[mcp_servers.missing]"));
+
+    // And list shows only the accepted entry, with local scope
+    let out = Command::cargo_bin("codex")
+        .unwrap()
+        .current_dir(project_dir.path())
+        .env("CODEX_HOME", codex_home.path())
+        .args(["mcp", "list", "--json"])
+        .assert()
+        .success()
+        .get_output()
+        .stdout
+        .clone();
+    let v: Value = serde_json::from_slice(&out).unwrap();
+    let arr = v.as_array().unwrap();
+    let mut seen_ok = false;
+    for e in arr {
+        if e.get("name").and_then(|x| x.as_str()) == Some("ok") {
+            assert_eq!(e.get("scope").and_then(|x| x.as_str()), Some("local"));
+            seen_ok = true;
+        }
+        assert_ne!(e.get("name").and_then(|x| x.as_str()), Some("bad"));
+        assert_ne!(e.get("name").and_then(|x| x.as_str()), Some("missing"));
+    }
+    assert!(
+        seen_ok,
+        "expected to find imported 'ok' entry in list output"
+    );
+}
+
+#[test]
+fn add_toml_user_and_get() {
+    let codex_home = tempfile::tempdir().unwrap();
+    let project_dir = tempfile::tempdir().unwrap();
+    write(&project_dir.path().join(".git"), "gitdir: nowhere");
+
+    let import = tempfile::NamedTempFile::new().unwrap();
+    write(
+        import.path(),
+        r#"[mcp_servers.userok]
+type = "stdio"
+command = "utool"
+"#,
+    );
+
+    // Import into user scope
+    Command::cargo_bin("codex")
+        .unwrap()
+        .current_dir(project_dir.path())
+        .env("CODEX_HOME", codex_home.path())
+        .args([
+            "mcp",
+            "add-toml",
+            "--scope",
+            "user",
+            import.path().to_str().unwrap(),
+        ])
+        .assert()
+        .success();
+
+    // Get shows the user scope
+    let out = Command::cargo_bin("codex")
+        .unwrap()
+        .current_dir(project_dir.path())
+        .env("CODEX_HOME", codex_home.path())
+        .args(["mcp", "get", "userok", "--json"])
+        .assert()
+        .success()
+        .get_output()
+        .stdout
+        .clone();
+    let v: Value = serde_json::from_slice(&out).unwrap();
+    assert_eq!(v.get("scope").and_then(|x| x.as_str()), Some("user"));
+    assert_eq!(
+        v.get("config")
+            .and_then(|c| c.get("command"))
+            .and_then(|x| x.as_str()),
+        Some("utool")
+    );
+}

codex-rs/cli/tests/mcp_get.rs

@@ -0,0 +1,52 @@
+use assert_cmd::prelude::*;
+use serde_json::Value;
+use std::fs;
+use std::process::Command;
+
+fn write(path: &std::path::Path, contents: &str) {
+    fs::write(path, contents).unwrap();
+}
+
+#[test]
+fn get_returns_winning_scope() {
+    let codex_home = tempfile::tempdir().unwrap();
+    write(
+        &codex_home.path().join("config.toml"),
+        r#"[mcp_servers.svc]
+command = "user-cmd"
+"#,
+    );
+
+    let project_dir = tempfile::tempdir().unwrap();
+    write(&project_dir.path().join(".git"), "gitdir: nowhere");
+    write(
+        &project_dir.path().join(".mcp.toml"),
+        r#"[mcp_servers.svc]
+command = "project-cmd"
+"#,
+    );
+    write(
+        &project_dir.path().join(".mcp.local.toml"),
+        r#"[mcp_servers.svc]
+command = "local-cmd"
+"#,
+    );
+
+    let assert = Command::cargo_bin("codex")
+        .unwrap()
+        .current_dir(project_dir.path())
+        .env("CODEX_HOME", codex_home.path())
+        .args(["mcp", "get", "svc", "--json"])
+        .assert()
+        .success();
+    let out = String::from_utf8(assert.get_output().stdout.clone()).unwrap();
+    let v: Value = serde_json::from_str(&out).unwrap();
+    assert_eq!(v.get("name").and_then(|x| x.as_str()), Some("svc"));
+    assert_eq!(v.get("scope").and_then(|x| x.as_str()), Some("local"));
+    assert_eq!(
+        v.get("config")
+            .and_then(|c| c.get("command"))
+            .and_then(|x| x.as_str()),
+        Some("local-cmd")
+    );
+}

codex-rs/cli/tests/mcp_list.rs

@@ -0,0 +1,71 @@
+use assert_cmd::prelude::*;
+use serde_json::Value;
+use std::fs;
+use std::process::Command;
+
+fn write(path: &std::path::Path, contents: &str) {
+    fs::write(path, contents).unwrap();
+}
+
+#[test]
+fn list_shows_scopes_for_user_project_local() {
+    let codex_home = tempfile::tempdir().unwrap();
+    write(
+        &codex_home.path().join("config.toml"),
+        r#"[mcp_servers.user_svc]
+command = "user-cmd"
+"#,
+    );
+
+    let project_dir = tempfile::tempdir().unwrap();
+    // Mark git root for nicer parity with real use
+    write(&project_dir.path().join(".git"), "gitdir: nowhere");
+    write(
+        &project_dir.path().join(".mcp.toml"),
+        r#"[mcp_servers.proj_svc]
+command = "proj-cmd"
+"#,
+    );
+    write(
+        &project_dir.path().join(".mcp.local.toml"),
+        r#"[mcp_servers.local_svc]
+command = "local-cmd"
+"#,
+    );
+
+    let assert = Command::cargo_bin("codex")
+        .unwrap()
+        .current_dir(project_dir.path())
+        .env("CODEX_HOME", codex_home.path())
+        .args(["mcp", "list", "--json"])
+        .assert()
+        .success();
+    let out = String::from_utf8(assert.get_output().stdout.clone()).unwrap();
+    let v: Value = serde_json::from_str(&out).unwrap();
+    let arr = v.as_array().unwrap();
+
+    let mut found = (false, false, false);
+    for e in arr {
+        let name = e.get("name").and_then(|x| x.as_str()).unwrap();
+        let scope = e.get("scope").and_then(|x| x.as_str()).unwrap();
+        match name {
+            "user_svc" => {
+                assert_eq!(scope, "user");
+                found.0 = true;
+            }
+            "proj_svc" => {
+                assert_eq!(scope, "project");
+                found.1 = true;
+            }
+            "local_svc" => {
+                assert_eq!(scope, "local");
+                found.2 = true;
+            }
+            _ => {}
+        }
+    }
+    assert!(
+        found.0 && found.1 && found.2,
+        "expected three entries across scopes"
+    );
+}

codex-rs/config.md

@@ -1,6 +1,564 @@
-# Configuration docs moved
+# Config
 
-This file has moved. Please see the latest configuration documentation here:
+Codex supports several mechanisms for setting config values:
 
-- Full config docs: [docs/config.md](../docs/config.md)
-- MCP servers section: [docs/config.md#mcp_servers](../docs/config.md#mcp_servers) 
+- Config-specific command-line flags, such as `--model o3` (highest precedence).
+- A generic `-c`/`--config` flag that takes a `key=value` pair, such as `--config model="o3"`.
+  - The key can contain dots to set a value deeper than the root, e.g. `--config model_providers.openai.wire_api="chat"`.
+  - Values can contain objects, such as `--config shell_environment_policy.include_only=["PATH", "HOME", "USER"]`.
+  - For consistency with `config.toml`, values are in TOML format rather than JSON format, so use `{a = 1, b = 2}` rather than `{"a": 1, "b": 2}`.
+  - If `value` cannot be parsed as a valid TOML value, it is treated as a string value. This means that both `-c model="o3"` and `-c model=o3` are equivalent.
+- The `$CODEX_HOME/config.toml` configuration file where the `CODEX_HOME` environment value defaults to `~/.codex`. (Note `CODEX_HOME` will also be where logs and other Codex-related information are stored.)
+
+Both the `--config` flag and the `config.toml` file support the following options:
+
+## model
+
+The model that Codex should use.
+
+```toml
+model = "o3"  # overrides the default of "gpt-5"
+```
+
+## model_providers
+
+This option lets you override and amend the default set of model providers bundled with Codex. This value is a map where the key is the value to use with `model_provider` to select the corresponding provider.
+
+For example, if you wanted to add a provider that uses the OpenAI 4o model via the chat completions API, then you could add the following configuration:
+
+```toml
+# Recall that in TOML, root keys must be listed before tables.
+model = "gpt-4o"
+model_provider = "openai-chat-completions"
+
+[model_providers.openai-chat-completions]
+# Name of the provider that will be displayed in the Codex UI.
+name = "OpenAI using Chat Completions"
+# The path `/chat/completions` will be amended to this URL to make the POST
+# request for the chat completions.
+base_url = "https://api.openai.com/v1"
+# If `env_key` is set, identifies an environment variable that must be set when
+# using Codex with this provider. The value of the environment variable must be
+# non-empty and will be used in the `Bearer TOKEN` HTTP header for the POST request.
+env_key = "OPENAI_API_KEY"
+# Valid values for wire_api are "chat" and "responses". Defaults to "chat" if omitted.
+wire_api = "chat"
+# If necessary, extra query params that need to be added to the URL.
+# See the Azure example below.
+query_params = {}
+```
+
+Note this makes it possible to use Codex CLI with non-OpenAI models, so long as they use a wire API that is compatible with the OpenAI chat completions API. For example, you could define the following provider to use Codex CLI with Ollama running locally:
+
+```toml
+[model_providers.ollama]
+name = "Ollama"
+base_url = "http://localhost:11434/v1"
+```
+
+Or a third-party provider (using a distinct environment variable for the API key):
+
+```toml
+[model_providers.mistral]
+name = "Mistral"
+base_url = "https://api.mistral.ai/v1"
+env_key = "MISTRAL_API_KEY"
+```
+
+Note that Azure requires `api-version` to be passed as a query parameter, so be sure to specify it as part of `query_params` when defining the Azure provider:
+
+```toml
+[model_providers.azure]
+name = "Azure"
+# Make sure you set the appropriate subdomain for this URL.
+base_url = "https://YOUR_PROJECT_NAME.openai.azure.com/openai"
+env_key = "AZURE_OPENAI_API_KEY"  # Or "OPENAI_API_KEY", whichever you use.
+query_params = { api-version = "2025-04-01-preview" }
+```
+
+It is also possible to configure a provider to include extra HTTP headers with a request. These can be hardcoded values (`http_headers`) or values read from environment variables (`env_http_headers`):
+
+```toml
+[model_providers.example]
+# name, base_url, ...
+
+# This will add the HTTP header `X-Example-Header` with value `example-value`
+# to each request to the model provider.
+http_headers = { "X-Example-Header" = "example-value" }
+
+# This will add the HTTP header `X-Example-Features` with the value of the
+# `EXAMPLE_FEATURES` environment variable to each request to the model provider
+# _if_ the environment variable is set and its value is non-empty.
+env_http_headers = { "X-Example-Features": "EXAMPLE_FEATURES" }
+```
+
+### Per-provider network tuning
+
+The following optional settings control retry behaviour and streaming idle timeouts **per model provider**. They must be specified inside the corresponding `[model_providers.<id>]` block in `config.toml`. (Older releases accepted top‑level keys; those are now ignored.)
+
+Example:
+
+```toml
+[model_providers.openai]
+name = "OpenAI"
+base_url = "https://api.openai.com/v1"
+env_key = "OPENAI_API_KEY"
+# network tuning overrides (all optional; falls back to built‑in defaults)
+request_max_retries = 4            # retry failed HTTP requests
+stream_max_retries = 10            # retry dropped SSE streams
+stream_idle_timeout_ms = 300000    # 5m idle timeout
+```
+
+#### request_max_retries
+
+How many times Codex will retry a failed HTTP request to the model provider. Defaults to `4`.
+
+#### stream_max_retries
+
+Number of times Codex will attempt to reconnect when a streaming response is interrupted. Defaults to `10`.
+
+#### stream_idle_timeout_ms
+
+How long Codex will wait for activity on a streaming response before treating the connection as lost. Defaults to `300_000` (5 minutes).
+
+## model_provider
+
+Identifies which provider to use from the `model_providers` map. Defaults to `"openai"`. You can override the `base_url` for the built-in `openai` provider via the `OPENAI_BASE_URL` environment variable.
+
+Note that if you override `model_provider`, then you likely want to override
+`model`, as well. For example, if you are running ollama with Mistral locally,
+then you would need to add the following to your config in addition to the new entry in the `model_providers` map:
+
+```toml
+model_provider = "ollama"
+model = "mistral"
+```
+
+## approval_policy
+
+Determines when the user should be prompted to approve whether Codex can execute a command:
+
+```toml
+# Codex has hardcoded logic that defines a set of "trusted" commands.
+# Setting the approval_policy to `untrusted` means that Codex will prompt the
+# user before running a command not in the "trusted" set.
+#
+# See https://github.com/openai/codex/issues/1260 for the plan to enable
+# end-users to define their own trusted commands.
+approval_policy = "untrusted"
+```
+
+If you want to be notified whenever a command fails, use "on-failure":
+
+```toml
+# If the command fails when run in the sandbox, Codex asks for permission to
+# retry the command outside the sandbox.
+approval_policy = "on-failure"
+```
+
+If you want the model to run until it decides that it needs to ask you for escalated permissions, use "on-request":
+
+```toml
+# The model decides when to escalate
+approval_policy = "on-request"
+```
+
+Alternatively, you can have the model run until it is done, and never ask to run a command with escalated permissions:
+
+```toml
+# User is never prompted: if the command fails, Codex will automatically try
+# something out. Note the `exec` subcommand always uses this mode.
+approval_policy = "never"
+```
+
+## profiles
+
+A _profile_ is a collection of configuration values that can be set together. Multiple profiles can be defined in `config.toml` and you can specify the one you
+want to use at runtime via the `--profile` flag.
+
+Here is an example of a `config.toml` that defines multiple profiles:
+
+```toml
+model = "o3"
+approval_policy = "unless-allow-listed"
+disable_response_storage = false
+
+# Setting `profile` is equivalent to specifying `--profile o3` on the command
+# line, though the `--profile` flag can still be used to override this value.
+profile = "o3"
+
+[model_providers.openai-chat-completions]
+name = "OpenAI using Chat Completions"
+base_url = "https://api.openai.com/v1"
+env_key = "OPENAI_API_KEY"
+wire_api = "chat"
+
+[profiles.o3]
+model = "o3"
+model_provider = "openai"
+approval_policy = "never"
+model_reasoning_effort = "high"
+model_reasoning_summary = "detailed"
+
+[profiles.gpt3]
+model = "gpt-3.5-turbo"
+model_provider = "openai-chat-completions"
+
+[profiles.zdr]
+model = "o3"
+model_provider = "openai"
+approval_policy = "on-failure"
+disable_response_storage = true
+```
+
+Users can specify config values at multiple levels. Order of precedence is as follows:
+
+1. custom command-line argument, e.g., `--model o3`
+2. as part of a profile, where the `--profile` is specified via a CLI (or in the config file itself)
+3. as an entry in `config.toml`, e.g., `model = "o3"`
+4. the default value that comes with Codex CLI (i.e., Codex CLI defaults to `gpt-5`)
+
+## model_reasoning_effort
+
+If the selected model is known to support reasoning (for example: `o3`, `o4-mini`, `codex-*`, `gpt-5`), reasoning is enabled by default when using the Responses API. As explained in the [OpenAI Platform documentation](https://platform.openai.com/docs/guides/reasoning?api-mode=responses#get-started-with-reasoning), this can be set to:
+
+- `"minimal"`
+- `"low"`
+- `"medium"` (default)
+- `"high"`
+
+Note: to minimize reasoning, choose `"minimal"`.
+
+## model_reasoning_summary
+
+If the model name starts with `"o"` (as in `"o3"` or `"o4-mini"`) or `"codex"`, reasoning is enabled by default when using the Responses API. As explained in the [OpenAI Platform documentation](https://platform.openai.com/docs/guides/reasoning?api-mode=responses#reasoning-summaries), this can be set to:
+
+- `"auto"` (default)
+- `"concise"`
+- `"detailed"`
+
+To disable reasoning summaries, set `model_reasoning_summary` to `"none"` in your config:
+
+```toml
+model_reasoning_summary = "none"  # disable reasoning summaries
+```
+
+## model_verbosity
+
+Controls output length/detail on GPT‑5 family models when using the Responses API. Supported values:
+
+- `"low"`
+- `"medium"` (default when omitted)
+- `"high"`
+
+When set, Codex includes a `text` object in the request payload with the configured verbosity, for example: `"text": { "verbosity": "low" }`.
+
+Example:
+
+```toml
+model = "gpt-5"
+model_verbosity = "low"
+```
+
+Note: This applies only to providers using the Responses API. Chat Completions providers are unaffected.
+
+## model_supports_reasoning_summaries
+
+By default, `reasoning` is only set on requests to OpenAI models that are known to support them. To force `reasoning` to set on requests to the current model, you can force this behavior by setting the following in `config.toml`:
+
+```toml
+model_supports_reasoning_summaries = true
+```
+
+## sandbox_mode
+
+Codex executes model-generated shell commands inside an OS-level sandbox.
+
+In most cases you can pick the desired behaviour with a single option:
+
+```toml
+# same as `--sandbox read-only`
+sandbox_mode = "read-only"
+```
+
+The default policy is `read-only`, which means commands can read any file on
+disk, but attempts to write a file or access the network will be blocked.
+
+A more relaxed policy is `workspace-write`. When specified, the current working directory for the Codex task will be writable (as well as `$TMPDIR` on macOS). Note that the CLI defaults to using the directory where it was spawned as `cwd`, though this can be overridden using `--cwd/-C`.
+
+On macOS (and soon Linux), all writable roots (including `cwd`) that contain a `.git/` folder _as an immediate child_ will configure the `.git/` folder to be read-only while the rest of the Git repository will be writable. This means that commands like `git commit` will fail, by default (as it entails writing to `.git/`), and will require Codex to ask for permission.
+
+```toml
+# same as `--sandbox workspace-write`
+sandbox_mode = "workspace-write"
+
+# Extra settings that only apply when `sandbox = "workspace-write"`.
+[sandbox_workspace_write]
+# By default, the cwd for the Codex session will be writable as well as $TMPDIR
+# (if set) and /tmp (if it exists). Setting the respective options to `true`
+# will override those defaults.
+exclude_tmpdir_env_var = false
+exclude_slash_tmp = false
+
+# Optional list of _additional_ writable roots beyond $TMPDIR and /tmp.
+writable_roots = ["/Users/YOU/.pyenv/shims"]
+
+# Allow the command being run inside the sandbox to make outbound network
+# requests. Disabled by default.
+network_access = false
+```
+
+To disable sandboxing altogether, specify `danger-full-access` like so:
+
+```toml
+# same as `--sandbox danger-full-access`
+sandbox_mode = "danger-full-access"
+```
+
+This is reasonable to use if Codex is running in an environment that provides its own sandboxing (such as a Docker container) such that further sandboxing is unnecessary.
+
+Though using this option may also be necessary if you try to use Codex in environments where its native sandboxing mechanisms are unsupported, such as older Linux kernels or on Windows.
+
+## Approval presets
+
+Codex provides three main Approval Presets:
+
+- Read Only: Codex can read files and answer questions; edits, running commands, and network access require approval.
+- Auto: Codex can read files, make edits, and run commands in the workspace without approval; asks for approval outside the workspace or for network access.
+- Full Access: Full disk and network access without prompts; extremely risky.
+
+You can further customize how Codex runs at the command line using the `--ask-for-approval` and `--sandbox` options.
+
+## mcp_servers
+
+Defines the list of MCP servers that Codex can consult for tool use. Currently, only servers that are launched by executing a program that communicate over stdio are supported. For servers that use the SSE transport, consider an adapter like [mcp-proxy](https://github.com/sparfenyuk/mcp-proxy).
+
+**Note:** Codex may cache the list of tools and resources from an MCP server so that Codex can include this information in context at startup without spawning all the servers. This is designed to save resources by loading MCP servers lazily.
+
+This config option is comparable to how Claude and Cursor define `mcpServers` in their respective JSON config files, though because Codex uses TOML for its config language, the format is slightly different. For example, the following config in JSON:
+
+```json
+{
+  "mcpServers": {
+    "server-name": {
+      "command": "npx",
+      "args": ["-y", "mcp-server"],
+      "env": {
+        "API_KEY": "value"
+      }
+    }
+  }
+}
+```
+
+Should be represented as follows in `~/.codex/config.toml`:
+
+```toml
+# IMPORTANT: the top-level key is `mcp_servers` rather than `mcpServers`.
+[mcp_servers.server-name]
+command = "npx"
+args = ["-y", "mcp-server"]
+env = { "API_KEY" = "value" }
+```
+
+## disable_response_storage
+
+Currently, customers whose accounts are set to use Zero Data Retention (ZDR) must set `disable_response_storage` to `true` so that Codex uses an alternative to the Responses API that works with ZDR:
+
+```toml
+disable_response_storage = true
+```
+
+## shell_environment_policy
+
+Codex spawns subprocesses (e.g. when executing a `local_shell` tool-call suggested by the assistant). By default it now passes **your full environment** to those subprocesses. You can tune this behavior via the **`shell_environment_policy`** block in `config.toml`:
+
+```toml
+[shell_environment_policy]
+# inherit can be "all" (default), "core", or "none"
+inherit = "core"
+# set to true to *skip* the filter for `"*KEY*"` and `"*TOKEN*"`
+ignore_default_excludes = false
+# exclude patterns (case-insensitive globs)
+exclude = ["AWS_*", "AZURE_*"]
+# force-set / override values
+set = { CI = "1" }
+# if provided, *only* vars matching these patterns are kept
+include_only = ["PATH", "HOME"]
+```
+
+| Field                     | Type                       | Default | Description                                                                                                                                     |
+| ------------------------- | -------------------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+| `inherit`                 | string                     | `all`   | Starting template for the environment:<br>`all` (clone full parent env), `core` (`HOME`, `PATH`, `USER`, …), or `none` (start empty).           |
+| `ignore_default_excludes` | boolean                    | `false` | When `false`, Codex removes any var whose **name** contains `KEY`, `SECRET`, or `TOKEN` (case-insensitive) before other rules run.              |
+| `exclude`                 | array&lt;string&gt;        | `[]`    | Case-insensitive glob patterns to drop after the default filter.<br>Examples: `"AWS_*"`, `"AZURE_*"`.                                           |
+| `set`                     | table&lt;string,string&gt; | `{}`    | Explicit key/value overrides or additions – always win over inherited values.                                                                   |
+| `include_only`            | array&lt;string&gt;        | `[]`    | If non-empty, a whitelist of patterns; only variables that match _one_ pattern survive the final step. (Generally used with `inherit = "all"`.) |
+
+The patterns are **glob style**, not full regular expressions: `*` matches any
+number of characters, `?` matches exactly one, and character classes like
+`[A-Z]`/`[^0-9]` are supported. Matching is always **case-insensitive**. This
+syntax is documented in code as `EnvironmentVariablePattern` (see
+`core/src/config_types.rs`).
+
+If you just need a clean slate with a few custom entries you can write:
+
+```toml
+[shell_environment_policy]
+inherit = "none"
+set = { PATH = "/usr/bin", MY_FLAG = "1" }
+```
+
+Currently, `CODEX_SANDBOX_NETWORK_DISABLED=1` is also added to the environment, assuming network is disabled. This is not configurable.
+
+## notify
+
+Specify a program that will be executed to get notified about events generated by Codex. Note that the program will receive the notification argument as a string of JSON, e.g.:
+
+```json
+{
+  "type": "agent-turn-complete",
+  "turn-id": "12345",
+  "input-messages": ["Rename `foo` to `bar` and update the callsites."],
+  "last-assistant-message": "Rename complete and verified `cargo build` succeeds."
+}
+```
+
+The `"type"` property will always be set. Currently, `"agent-turn-complete"` is the only notification type that is supported.
+
+As an example, here is a Python script that parses the JSON and decides whether to show a desktop push notification using [terminal-notifier](https://github.com/julienXX/terminal-notifier) on macOS:
+
+```python
+#!/usr/bin/env python3
+
+import json
+import subprocess
+import sys
+
+
+def main() -> int:
+    if len(sys.argv) != 2:
+        print("Usage: notify.py <NOTIFICATION_JSON>")
+        return 1
+
+    try:
+        notification = json.loads(sys.argv[1])
+    except json.JSONDecodeError:
+        return 1
+
+    match notification_type := notification.get("type"):
+        case "agent-turn-complete":
+            assistant_message = notification.get("last-assistant-message")
+            if assistant_message:
+                title = f"Codex: {assistant_message}"
+            else:
+                title = "Codex: Turn Complete!"
+            input_messages = notification.get("input_messages", [])
+            message = " ".join(input_messages)
+            title += message
+        case _:
+            print(f"not sending a push notification for: {notification_type}")
+            return 0
+
+    subprocess.check_output(
+        [
+            "terminal-notifier",
+            "-title",
+            title,
+            "-message",
+            message,
+            "-group",
+            "codex",
+            "-ignoreDnD",
+            "-activate",
+            "com.googlecode.iterm2",
+        ]
+    )
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+```
+
+To have Codex use this script for notifications, you would configure it via `notify` in `~/.codex/config.toml` using the appropriate path to `notify.py` on your computer:
+
+```toml
+notify = ["python3", "/Users/mbolin/.codex/notify.py"]
+```
+
+## history
+
+By default, Codex CLI records messages sent to the model in `$CODEX_HOME/history.jsonl`. Note that on UNIX, the file permissions are set to `o600`, so it should only be readable and writable by the owner.
+
+To disable this behavior, configure `[history]` as follows:
+
+```toml
+[history]
+persistence = "none"  # "save-all" is the default value
+```
+
+## file_opener
+
+Identifies the editor/URI scheme to use for hyperlinking citations in model output. If set, citations to files in the model output will be hyperlinked using the specified URI scheme so they can be ctrl/cmd-clicked from the terminal to open them.
+
+For example, if the model output includes a reference such as `【F:/home/user/project/main.py†L42-L50】`, then this would be rewritten to link to the URI `vscode://file/home/user/project/main.py:42`.
+
+Note this is **not** a general editor setting (like `$EDITOR`), as it only accepts a fixed set of values:
+
+- `"vscode"` (default)
+- `"vscode-insiders"`
+- `"windsurf"`
+- `"cursor"`
+- `"none"` to explicitly disable this feature
+
+Currently, `"vscode"` is the default, though Codex does not verify VS Code is installed. As such, `file_opener` may default to `"none"` or something else in the future.
+
+## hide_agent_reasoning
+
+Codex intermittently emits "reasoning" events that show the model's internal "thinking" before it produces a final answer. Some users may find these events distracting, especially in CI logs or minimal terminal output.
+
+Setting `hide_agent_reasoning` to `true` suppresses these events in **both** the TUI as well as the headless `exec` sub-command:
+
+```toml
+hide_agent_reasoning = true   # defaults to false
+```
+
+## show_raw_agent_reasoning
+
+Surfaces the model’s raw chain-of-thought ("raw reasoning content") when available.
+
+Notes:
+
+- Only takes effect if the selected model/provider actually emits raw reasoning content. Many models do not. When unsupported, this option has no visible effect.
+- Raw reasoning may include intermediate thoughts or sensitive context. Enable only if acceptable for your workflow.
+
+Example:
+
+```toml
+show_raw_agent_reasoning = true  # defaults to false
+```
+
+## model_context_window
+
+The size of the context window for the model, in tokens.
+
+In general, Codex knows the context window for the most common OpenAI models, but if you are using a new model with an old version of the Codex CLI, then you can use `model_context_window` to tell Codex what value to use to determine how much context is left during a conversation.
+
+## model_max_output_tokens
+
+This is analogous to `model_context_window`, but for the maximum number of output tokens for the model.
+
+## project_doc_max_bytes
+
+Maximum number of bytes to read from an `AGENTS.md` file to include in the instructions sent with the first turn of a session. Defaults to 32 KiB.
+
+## tui
+
+Options that are specific to the TUI.
+
+```toml
+[tui]
+# More to come here
+```

codex-rs/core/Cargo.toml

@@ -18,6 +18,7 @@ base64 = "0.22"
 bytes = "1.10.1"
 chrono = { version = "0.4", features = ["serde"] }
 codex-apply-patch = { path = "../apply-patch" }
+codex-login = { path = "../login" }
 codex-mcp-client = { path = "../mcp-client" }
 codex-protocol = { path = "../protocol" }
 dirs = "6"
@@ -30,7 +31,7 @@ mime_guess = "2.0"
 os_info = "3.12.0"
 portable-pty = "0.9.0"
 rand = "0.9"
-regex-lite = "0.1.7"
+regex-lite = "0.1.6"
 reqwest = { version = "0.12", features = ["json", "stream"] }
 serde = { version = "1", features = ["derive"] }
 serde_bytes = "0.11"
@@ -40,8 +41,8 @@ shlex = "1.3.0"
 similar = "2.7.0"
 strum_macros = "0.27.2"
 tempfile = "3"
-thiserror = "2.0.16"
-time = { version = "0.3", features = ["formatting", "parsing", "local-offset", "macros"] }
+thiserror = "2.0.12"
+time = { version = "0.3", features = ["formatting", "local-offset", "macros"] }
 tokio = { version = "1", features = [
     "io-std",
     "macros",

codex-rs/core/src/apply_patch.rs

@@ -109,9 +109,7 @@ pub(crate) fn convert_apply_patch_to_protocol(
             ApplyPatchFileChange::Add { content } => FileChange::Add {
                 content: content.clone(),
             },
-            ApplyPatchFileChange::Delete { content } => FileChange::Delete {
-                content: content.clone(),
-            },
+            ApplyPatchFileChange::Delete => FileChange::Delete,
             ApplyPatchFileChange::Update {
                 unified_diff,
                 move_path,

codex-rs/core/src/auth.rs

@@ -1,766 +0,0 @@
-use chrono::DateTime;
-use chrono::Utc;
-use serde::Deserialize;
-use serde::Serialize;
-use std::env;
-use std::fs::File;
-use std::fs::OpenOptions;
-use std::io::Read;
-use std::io::Write;
-#[cfg(unix)]
-use std::os::unix::fs::OpenOptionsExt;
-use std::path::Path;
-use std::path::PathBuf;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::time::Duration;
-
-use codex_protocol::mcp_protocol::AuthMode;
-
-use crate::token_data::TokenData;
-use crate::token_data::parse_id_token;
-
-#[derive(Debug, Clone)]
-pub struct CodexAuth {
-    pub mode: AuthMode,
-
-    pub(crate) api_key: Option<String>,
-    pub(crate) auth_dot_json: Arc<Mutex<Option<AuthDotJson>>>,
-    pub(crate) auth_file: PathBuf,
-}
-
-impl PartialEq for CodexAuth {
-    fn eq(&self, other: &Self) -> bool {
-        self.mode == other.mode
-    }
-}
-
-impl CodexAuth {
-    pub fn from_api_key(api_key: &str) -> Self {
-        Self {
-            api_key: Some(api_key.to_owned()),
-            mode: AuthMode::ApiKey,
-            auth_file: PathBuf::new(),
-            auth_dot_json: Arc::new(Mutex::new(None)),
-        }
-    }
-
-    pub async fn refresh_token(&self) -> Result<String, std::io::Error> {
-        let token_data = self
-            .get_current_token_data()
-            .ok_or(std::io::Error::other("Token data is not available."))?;
-        let token = token_data.refresh_token;
-
-        let refresh_response = try_refresh_token(token)
-            .await
-            .map_err(std::io::Error::other)?;
-
-        let updated = update_tokens(
-            &self.auth_file,
-            refresh_response.id_token,
-            refresh_response.access_token,
-            refresh_response.refresh_token,
-        )
-        .await?;
-
-        if let Ok(mut auth_lock) = self.auth_dot_json.lock() {
-            *auth_lock = Some(updated.clone());
-        }
-
-        let access = match updated.tokens {
-            Some(t) => t.access_token,
-            None => {
-                return Err(std::io::Error::other(
-                    "Token data is not available after refresh.",
-                ));
-            }
-        };
-        Ok(access)
-    }
-
-    /// Loads the available auth information from the auth.json or
-    /// OPENAI_API_KEY environment variable.
-    pub fn from_codex_home(
-        codex_home: &Path,
-        preferred_auth_method: AuthMode,
-    ) -> std::io::Result<Option<CodexAuth>> {
-        load_auth(codex_home, true, preferred_auth_method)
-    }
-
-    pub async fn get_token_data(&self) -> Result<TokenData, std::io::Error> {
-        let auth_dot_json: Option<AuthDotJson> = self.get_current_auth_json();
-        match auth_dot_json {
-            Some(AuthDotJson {
-                tokens: Some(mut tokens),
-                last_refresh: Some(last_refresh),
-                ..
-            }) => {
-                if last_refresh < Utc::now() - chrono::Duration::days(28) {
-                    let refresh_response = tokio::time::timeout(
-                        Duration::from_secs(60),
-                        try_refresh_token(tokens.refresh_token.clone()),
-                    )
-                    .await
-                    .map_err(|_| {
-                        std::io::Error::other("timed out while refreshing OpenAI API key")
-                    })?
-                    .map_err(std::io::Error::other)?;
-
-                    let updated_auth_dot_json = update_tokens(
-                        &self.auth_file,
-                        refresh_response.id_token,
-                        refresh_response.access_token,
-                        refresh_response.refresh_token,
-                    )
-                    .await?;
-
-                    tokens = updated_auth_dot_json
-                        .tokens
-                        .clone()
-                        .ok_or(std::io::Error::other(
-                            "Token data is not available after refresh.",
-                        ))?;
-
-                    #[expect(clippy::unwrap_used)]
-                    let mut auth_lock = self.auth_dot_json.lock().unwrap();
-                    *auth_lock = Some(updated_auth_dot_json);
-                }
-
-                Ok(tokens)
-            }
-            _ => Err(std::io::Error::other("Token data is not available.")),
-        }
-    }
-
-    pub async fn get_token(&self) -> Result<String, std::io::Error> {
-        match self.mode {
-            AuthMode::ApiKey => Ok(self.api_key.clone().unwrap_or_default()),
-            AuthMode::ChatGPT => {
-                let id_token = self.get_token_data().await?.access_token;
-                Ok(id_token)
-            }
-        }
-    }
-
-    pub fn get_account_id(&self) -> Option<String> {
-        self.get_current_token_data()
-            .and_then(|t| t.account_id.clone())
-    }
-
-    pub fn get_plan_type(&self) -> Option<String> {
-        self.get_current_token_data()
-            .and_then(|t| t.id_token.chatgpt_plan_type.as_ref().map(|p| p.as_string()))
-    }
-
-    fn get_current_auth_json(&self) -> Option<AuthDotJson> {
-        #[expect(clippy::unwrap_used)]
-        self.auth_dot_json.lock().unwrap().clone()
-    }
-
-    fn get_current_token_data(&self) -> Option<TokenData> {
-        self.get_current_auth_json().and_then(|t| t.tokens.clone())
-    }
-
-    /// Consider this private to integration tests.
-    pub fn create_dummy_chatgpt_auth_for_testing() -> Self {
-        let auth_dot_json = AuthDotJson {
-            openai_api_key: None,
-            tokens: Some(TokenData {
-                id_token: Default::default(),
-                access_token: "Access Token".to_string(),
-                refresh_token: "test".to_string(),
-                account_id: Some("account_id".to_string()),
-            }),
-            last_refresh: Some(Utc::now()),
-        };
-
-        let auth_dot_json = Arc::new(Mutex::new(Some(auth_dot_json)));
-        Self {
-            api_key: None,
-            mode: AuthMode::ChatGPT,
-            auth_file: PathBuf::new(),
-            auth_dot_json,
-        }
-    }
-}
-
-pub const OPENAI_API_KEY_ENV_VAR: &str = "OPENAI_API_KEY";
-
-fn read_openai_api_key_from_env() -> Option<String> {
-    env::var(OPENAI_API_KEY_ENV_VAR)
-        .ok()
-        .filter(|s| !s.is_empty())
-}
-
-pub fn get_auth_file(codex_home: &Path) -> PathBuf {
-    codex_home.join("auth.json")
-}
-
-/// Delete the auth.json file inside `codex_home` if it exists. Returns `Ok(true)`
-/// if a file was removed, `Ok(false)` if no auth file was present.
-pub fn logout(codex_home: &Path) -> std::io::Result<bool> {
-    let auth_file = get_auth_file(codex_home);
-    match std::fs::remove_file(&auth_file) {
-        Ok(_) => Ok(true),
-        Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(false),
-        Err(err) => Err(err),
-    }
-}
-
-/// Writes an `auth.json` that contains only the API key. Intended for CLI use.
-pub fn login_with_api_key(codex_home: &Path, api_key: &str) -> std::io::Result<()> {
-    let auth_dot_json = AuthDotJson {
-        openai_api_key: Some(api_key.to_string()),
-        tokens: None,
-        last_refresh: None,
-    };
-    write_auth_json(&get_auth_file(codex_home), &auth_dot_json)
-}
-
-fn load_auth(
-    codex_home: &Path,
-    include_env_var: bool,
-    preferred_auth_method: AuthMode,
-) -> std::io::Result<Option<CodexAuth>> {
-    // First, check to see if there is a valid auth.json file. If not, we fall
-    // back to AuthMode::ApiKey using the OPENAI_API_KEY environment variable
-    // (if it is set).
-    let auth_file = get_auth_file(codex_home);
-    let auth_dot_json = match try_read_auth_json(&auth_file) {
-        Ok(auth) => auth,
-        // If auth.json does not exist, try to read the OPENAI_API_KEY from the
-        // environment variable.
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound && include_env_var => {
-            return match read_openai_api_key_from_env() {
-                Some(api_key) => Ok(Some(CodexAuth::from_api_key(&api_key))),
-                None => Ok(None),
-            };
-        }
-        // Though if auth.json exists but is malformed, do not fall back to the
-        // env var because the user may be expecting to use AuthMode::ChatGPT.
-        Err(e) => {
-            return Err(e);
-        }
-    };
-
-    let AuthDotJson {
-        openai_api_key: auth_json_api_key,
-        tokens,
-        last_refresh,
-    } = auth_dot_json;
-
-    // If the auth.json has an API key AND does not appear to be on a plan that
-    // should prefer AuthMode::ChatGPT, use AuthMode::ApiKey.
-    if let Some(api_key) = &auth_json_api_key {
-        // Should any of these be AuthMode::ChatGPT with the api_key set?
-        // Does AuthMode::ChatGPT indicate that there is an auth.json that is
-        // "refreshable" even if we are using the API key for auth?
-        match &tokens {
-            Some(tokens) => {
-                if tokens.should_use_api_key(preferred_auth_method, tokens.is_openai_email()) {
-                    return Ok(Some(CodexAuth::from_api_key(api_key)));
-                } else {
-                    // Ignore the API key and fall through to ChatGPT auth.
-                }
-            }
-            None => {
-                // We have an API key but no tokens in the auth.json file.
-                // Perhaps the user ran `codex login --api-key <KEY>` or updated
-                // auth.json by hand. Either way, let's assume they are trying
-                // to use their API key.
-                return Ok(Some(CodexAuth::from_api_key(api_key)));
-            }
-        }
-    }
-
-    // For the AuthMode::ChatGPT variant, perhaps neither api_key nor
-    // openai_api_key should exist?
-    Ok(Some(CodexAuth {
-        api_key: None,
-        mode: AuthMode::ChatGPT,
-        auth_file,
-        auth_dot_json: Arc::new(Mutex::new(Some(AuthDotJson {
-            openai_api_key: None,
-            tokens,
-            last_refresh,
-        }))),
-    }))
-}
-
-/// Attempt to read and refresh the `auth.json` file in the given `CODEX_HOME` directory.
-/// Returns the full AuthDotJson structure after refreshing if necessary.
-pub fn try_read_auth_json(auth_file: &Path) -> std::io::Result<AuthDotJson> {
-    let mut file = File::open(auth_file)?;
-    let mut contents = String::new();
-    file.read_to_string(&mut contents)?;
-    let auth_dot_json: AuthDotJson = serde_json::from_str(&contents)?;
-
-    Ok(auth_dot_json)
-}
-
-pub fn write_auth_json(auth_file: &Path, auth_dot_json: &AuthDotJson) -> std::io::Result<()> {
-    let json_data = serde_json::to_string_pretty(auth_dot_json)?;
-    let mut options = OpenOptions::new();
-    options.truncate(true).write(true).create(true);
-    #[cfg(unix)]
-    {
-        options.mode(0o600);
-    }
-    let mut file = options.open(auth_file)?;
-    file.write_all(json_data.as_bytes())?;
-    file.flush()?;
-    Ok(())
-}
-
-async fn update_tokens(
-    auth_file: &Path,
-    id_token: String,
-    access_token: Option<String>,
-    refresh_token: Option<String>,
-) -> std::io::Result<AuthDotJson> {
-    let mut auth_dot_json = try_read_auth_json(auth_file)?;
-
-    let tokens = auth_dot_json.tokens.get_or_insert_with(TokenData::default);
-    tokens.id_token = parse_id_token(&id_token).map_err(std::io::Error::other)?;
-    if let Some(access_token) = access_token {
-        tokens.access_token = access_token.to_string();
-    }
-    if let Some(refresh_token) = refresh_token {
-        tokens.refresh_token = refresh_token.to_string();
-    }
-    auth_dot_json.last_refresh = Some(Utc::now());
-    write_auth_json(auth_file, &auth_dot_json)?;
-    Ok(auth_dot_json)
-}
-
-async fn try_refresh_token(refresh_token: String) -> std::io::Result<RefreshResponse> {
-    let refresh_request = RefreshRequest {
-        client_id: CLIENT_ID,
-        grant_type: "refresh_token",
-        refresh_token,
-        scope: "openid profile email",
-    };
-
-    let client = reqwest::Client::new();
-    let response = client
-        .post("https://auth.openai.com/oauth/token")
-        .header("Content-Type", "application/json")
-        .json(&refresh_request)
-        .send()
-        .await
-        .map_err(std::io::Error::other)?;
-
-    if response.status().is_success() {
-        let refresh_response = response
-            .json::<RefreshResponse>()
-            .await
-            .map_err(std::io::Error::other)?;
-        Ok(refresh_response)
-    } else {
-        Err(std::io::Error::other(format!(
-            "Failed to refresh token: {}",
-            response.status()
-        )))
-    }
-}
-
-#[derive(Serialize)]
-struct RefreshRequest {
-    client_id: &'static str,
-    grant_type: &'static str,
-    refresh_token: String,
-    scope: &'static str,
-}
-
-#[derive(Deserialize, Clone)]
-struct RefreshResponse {
-    id_token: String,
-    access_token: Option<String>,
-    refresh_token: Option<String>,
-}
-
-/// Expected structure for $CODEX_HOME/auth.json.
-#[derive(Deserialize, Serialize, Clone, Debug, PartialEq)]
-pub struct AuthDotJson {
-    #[serde(rename = "OPENAI_API_KEY")]
-    pub openai_api_key: Option<String>,
-
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub tokens: Option<TokenData>,
-
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub last_refresh: Option<DateTime<Utc>>,
-}
-
-// Shared constant for token refresh (client id used for oauth token refresh flow)
-pub const CLIENT_ID: &str = "app_EMoamEEZ73f0CkXaXp7hrann";
-
-use std::sync::RwLock;
-
-/// Internal cached auth state.
-#[derive(Clone, Debug)]
-struct CachedAuth {
-    preferred_auth_mode: AuthMode,
-    auth: Option<CodexAuth>,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::token_data::IdTokenInfo;
-    use crate::token_data::KnownPlan;
-    use crate::token_data::PlanType;
-    use base64::Engine;
-    use pretty_assertions::assert_eq;
-    use serde::Serialize;
-    use serde_json::json;
-    use tempfile::tempdir;
-
-    const LAST_REFRESH: &str = "2025-08-06T20:41:36.232376Z";
-
-    #[tokio::test]
-    async fn roundtrip_auth_dot_json() {
-        let codex_home = tempdir().unwrap();
-        let _ = write_auth_file(
-            AuthFileParams {
-                openai_api_key: None,
-                chatgpt_plan_type: "pro".to_string(),
-            },
-            codex_home.path(),
-        )
-        .expect("failed to write auth file");
-
-        let file = get_auth_file(codex_home.path());
-        let auth_dot_json = try_read_auth_json(&file).unwrap();
-        write_auth_json(&file, &auth_dot_json).unwrap();
-
-        let same_auth_dot_json = try_read_auth_json(&file).unwrap();
-        assert_eq!(auth_dot_json, same_auth_dot_json);
-    }
-
-    #[tokio::test]
-    async fn pro_account_with_no_api_key_uses_chatgpt_auth() {
-        let codex_home = tempdir().unwrap();
-        let fake_jwt = write_auth_file(
-            AuthFileParams {
-                openai_api_key: None,
-                chatgpt_plan_type: "pro".to_string(),
-            },
-            codex_home.path(),
-        )
-        .expect("failed to write auth file");
-
-        let CodexAuth {
-            api_key,
-            mode,
-            auth_dot_json,
-            auth_file: _,
-        } = super::load_auth(codex_home.path(), false, AuthMode::ChatGPT)
-            .unwrap()
-            .unwrap();
-        assert_eq!(None, api_key);
-        assert_eq!(AuthMode::ChatGPT, mode);
-
-        let guard = auth_dot_json.lock().unwrap();
-        let auth_dot_json = guard.as_ref().expect("AuthDotJson should exist");
-        assert_eq!(
-            &AuthDotJson {
-                openai_api_key: None,
-                tokens: Some(TokenData {
-                    id_token: IdTokenInfo {
-                        email: Some("user@example.com".to_string()),
-                        chatgpt_plan_type: Some(PlanType::Known(KnownPlan::Pro)),
-                        raw_jwt: fake_jwt,
-                    },
-                    access_token: "test-access-token".to_string(),
-                    refresh_token: "test-refresh-token".to_string(),
-                    account_id: None,
-                }),
-                last_refresh: Some(
-                    DateTime::parse_from_rfc3339(LAST_REFRESH)
-                        .unwrap()
-                        .with_timezone(&Utc)
-                ),
-            },
-            auth_dot_json
-        )
-    }
-
-    /// Even if the OPENAI_API_KEY is set in auth.json, if the plan is not in
-    /// [`TokenData::is_plan_that_should_use_api_key`], it should use
-    /// [`AuthMode::ChatGPT`].
-    #[tokio::test]
-    async fn pro_account_with_api_key_still_uses_chatgpt_auth() {
-        let codex_home = tempdir().unwrap();
-        let fake_jwt = write_auth_file(
-            AuthFileParams {
-                openai_api_key: Some("sk-test-key".to_string()),
-                chatgpt_plan_type: "pro".to_string(),
-            },
-            codex_home.path(),
-        )
-        .expect("failed to write auth file");
-
-        let CodexAuth {
-            api_key,
-            mode,
-            auth_dot_json,
-            auth_file: _,
-        } = super::load_auth(codex_home.path(), false, AuthMode::ChatGPT)
-            .unwrap()
-            .unwrap();
-        assert_eq!(None, api_key);
-        assert_eq!(AuthMode::ChatGPT, mode);
-
-        let guard = auth_dot_json.lock().unwrap();
-        let auth_dot_json = guard.as_ref().expect("AuthDotJson should exist");
-        assert_eq!(
-            &AuthDotJson {
-                openai_api_key: None,
-                tokens: Some(TokenData {
-                    id_token: IdTokenInfo {
-                        email: Some("user@example.com".to_string()),
-                        chatgpt_plan_type: Some(PlanType::Known(KnownPlan::Pro)),
-                        raw_jwt: fake_jwt,
-                    },
-                    access_token: "test-access-token".to_string(),
-                    refresh_token: "test-refresh-token".to_string(),
-                    account_id: None,
-                }),
-                last_refresh: Some(
-                    DateTime::parse_from_rfc3339(LAST_REFRESH)
-                        .unwrap()
-                        .with_timezone(&Utc)
-                ),
-            },
-            auth_dot_json
-        )
-    }
-
-    /// If the OPENAI_API_KEY is set in auth.json and it is an enterprise
-    /// account, then it should use [`AuthMode::ApiKey`].
-    #[tokio::test]
-    async fn enterprise_account_with_api_key_uses_apikey_auth() {
-        let codex_home = tempdir().unwrap();
-        write_auth_file(
-            AuthFileParams {
-                openai_api_key: Some("sk-test-key".to_string()),
-                chatgpt_plan_type: "enterprise".to_string(),
-            },
-            codex_home.path(),
-        )
-        .expect("failed to write auth file");
-
-        let CodexAuth {
-            api_key,
-            mode,
-            auth_dot_json,
-            auth_file: _,
-        } = super::load_auth(codex_home.path(), false, AuthMode::ChatGPT)
-            .unwrap()
-            .unwrap();
-        assert_eq!(Some("sk-test-key".to_string()), api_key);
-        assert_eq!(AuthMode::ApiKey, mode);
-
-        let guard = auth_dot_json.lock().expect("should unwrap");
-        assert!(guard.is_none(), "auth_dot_json should be None");
-    }
-
-    #[tokio::test]
-    async fn loads_api_key_from_auth_json() {
-        let dir = tempdir().unwrap();
-        let auth_file = dir.path().join("auth.json");
-        std::fs::write(
-            auth_file,
-            r#"{"OPENAI_API_KEY":"sk-test-key","tokens":null,"last_refresh":null}"#,
-        )
-        .unwrap();
-
-        let auth = super::load_auth(dir.path(), false, AuthMode::ChatGPT)
-            .unwrap()
-            .unwrap();
-        assert_eq!(auth.mode, AuthMode::ApiKey);
-        assert_eq!(auth.api_key, Some("sk-test-key".to_string()));
-
-        assert!(auth.get_token_data().await.is_err());
-    }
-
-    #[test]
-    fn logout_removes_auth_file() -> Result<(), std::io::Error> {
-        let dir = tempdir()?;
-        let auth_dot_json = AuthDotJson {
-            openai_api_key: Some("sk-test-key".to_string()),
-            tokens: None,
-            last_refresh: None,
-        };
-        write_auth_json(&get_auth_file(dir.path()), &auth_dot_json)?;
-        assert!(dir.path().join("auth.json").exists());
-        let removed = logout(dir.path())?;
-        assert!(removed);
-        assert!(!dir.path().join("auth.json").exists());
-        Ok(())
-    }
-
-    struct AuthFileParams {
-        openai_api_key: Option<String>,
-        chatgpt_plan_type: String,
-    }
-
-    fn write_auth_file(params: AuthFileParams, codex_home: &Path) -> std::io::Result<String> {
-        let auth_file = get_auth_file(codex_home);
-        // Create a minimal valid JWT for the id_token field.
-        #[derive(Serialize)]
-        struct Header {
-            alg: &'static str,
-            typ: &'static str,
-        }
-        let header = Header {
-            alg: "none",
-            typ: "JWT",
-        };
-        let payload = serde_json::json!({
-            "email": "user@example.com",
-            "email_verified": true,
-            "https://api.openai.com/auth": {
-                "chatgpt_account_id": "bc3618e3-489d-4d49-9362-1561dc53ba53",
-                "chatgpt_plan_type": params.chatgpt_plan_type,
-                "chatgpt_user_id": "user-12345",
-                "user_id": "user-12345",
-            }
-        });
-        let b64 = |b: &[u8]| base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(b);
-        let header_b64 = b64(&serde_json::to_vec(&header)?);
-        let payload_b64 = b64(&serde_json::to_vec(&payload)?);
-        let signature_b64 = b64(b"sig");
-        let fake_jwt = format!("{header_b64}.{payload_b64}.{signature_b64}");
-
-        let auth_json_data = json!({
-            "OPENAI_API_KEY": params.openai_api_key,
-            "tokens": {
-                "id_token": fake_jwt,
-                "access_token": "test-access-token",
-                "refresh_token": "test-refresh-token"
-            },
-            "last_refresh": LAST_REFRESH,
-        });
-        let auth_json = serde_json::to_string_pretty(&auth_json_data)?;
-        std::fs::write(auth_file, auth_json)?;
-        Ok(fake_jwt)
-    }
-}
-
-/// Central manager providing a single source of truth for auth.json derived
-/// authentication data. It loads once (or on preference change) and then
-/// hands out cloned `CodexAuth` values so the rest of the program has a
-/// consistent snapshot.
-///
-/// External modifications to `auth.json` will NOT be observed until
-/// `reload()` is called explicitly. This matches the design goal of avoiding
-/// different parts of the program seeing inconsistent auth data mid‑run.
-#[derive(Debug)]
-pub struct AuthManager {
-    codex_home: PathBuf,
-    inner: RwLock<CachedAuth>,
-}
-
-impl AuthManager {
-    /// Create a new manager loading the initial auth using the provided
-    /// preferred auth method. Errors loading auth are swallowed; `auth()` will
-    /// simply return `None` in that case so callers can treat it as an
-    /// unauthenticated state.
-    pub fn new(codex_home: PathBuf, preferred_auth_mode: AuthMode) -> Self {
-        let auth = CodexAuth::from_codex_home(&codex_home, preferred_auth_mode)
-            .ok()
-            .flatten();
-        Self {
-            codex_home,
-            inner: RwLock::new(CachedAuth {
-                preferred_auth_mode,
-                auth,
-            }),
-        }
-    }
-
-    /// Create an AuthManager with a specific CodexAuth, for testing only.
-    pub fn from_auth_for_testing(auth: CodexAuth) -> Arc<Self> {
-        let preferred_auth_mode = auth.mode;
-        let cached = CachedAuth {
-            preferred_auth_mode,
-            auth: Some(auth),
-        };
-        Arc::new(Self {
-            codex_home: PathBuf::new(),
-            inner: RwLock::new(cached),
-        })
-    }
-
-    /// Current cached auth (clone). May be `None` if not logged in or load failed.
-    pub fn auth(&self) -> Option<CodexAuth> {
-        self.inner.read().ok().and_then(|c| c.auth.clone())
-    }
-
-    /// Preferred auth method used when (re)loading.
-    pub fn preferred_auth_method(&self) -> AuthMode {
-        self.inner
-            .read()
-            .map(|c| c.preferred_auth_mode)
-            .unwrap_or(AuthMode::ApiKey)
-    }
-
-    /// Force a reload using the existing preferred auth method. Returns
-    /// whether the auth value changed.
-    pub fn reload(&self) -> bool {
-        let preferred = self.preferred_auth_method();
-        let new_auth = CodexAuth::from_codex_home(&self.codex_home, preferred)
-            .ok()
-            .flatten();
-        if let Ok(mut guard) = self.inner.write() {
-            let changed = !AuthManager::auths_equal(&guard.auth, &new_auth);
-            guard.auth = new_auth;
-            changed
-        } else {
-            false
-        }
-    }
-
-    fn auths_equal(a: &Option<CodexAuth>, b: &Option<CodexAuth>) -> bool {
-        match (a, b) {
-            (None, None) => true,
-            (Some(a), Some(b)) => a == b,
-            _ => false,
-        }
-    }
-
-    /// Convenience constructor returning an `Arc` wrapper.
-    pub fn shared(codex_home: PathBuf, preferred_auth_mode: AuthMode) -> Arc<Self> {
-        Arc::new(Self::new(codex_home, preferred_auth_mode))
-    }
-
-    /// Attempt to refresh the current auth token (if any). On success, reload
-    /// the auth state from disk so other components observe refreshed token.
-    pub async fn refresh_token(&self) -> std::io::Result<Option<String>> {
-        let auth = match self.auth() {
-            Some(a) => a,
-            None => return Ok(None),
-        };
-        match auth.refresh_token().await {
-            Ok(token) => {
-                // Reload to pick up persisted changes.
-                self.reload();
-                Ok(Some(token))
-            }
-            Err(e) => Err(e),
-        }
-    }
-
-    /// Log out by deleting the on‑disk auth.json (if present). Returns Ok(true)
-    /// if a file was removed, Ok(false) if no auth file existed. On success,
-    /// reloads the in‑memory auth cache so callers immediately observe the
-    /// unauthenticated state.
-    pub fn logout(&self) -> std::io::Result<bool> {
-        let removed = super::auth::logout(&self.codex_home)?;
-        // Always reload to clear any cached auth (even if file absent).
-        self.reload();
-        Ok(removed)
-    }
-}

codex-rs/core/src/chat_completions.rs

@@ -43,107 +43,7 @@ pub(crate) async fn stream_chat_completions(
 
     let input = prompt.get_formatted_input();
 
-    // Pre-scan: map Reasoning blocks to the adjacent assistant anchor after the last user.
-    // - If the last emitted message is a user message, drop all reasoning.
-    // - Otherwise, for each Reasoning item after the last user message, attach it
-    //   to the immediate previous assistant message (stop turns) or the immediate
-    //   next assistant anchor (tool-call turns: function/local shell call, or assistant message).
-    let mut reasoning_by_anchor_index: std::collections::HashMap<usize, String> =
-        std::collections::HashMap::new();
-
-    // Determine the last role that would be emitted to Chat Completions.
-    let mut last_emitted_role: Option<&str> = None;
     for item in &input {
-        match item {
-            ResponseItem::Message { role, .. } => last_emitted_role = Some(role.as_str()),
-            ResponseItem::FunctionCall { .. } | ResponseItem::LocalShellCall { .. } => {
-                last_emitted_role = Some("assistant")
-            }
-            ResponseItem::FunctionCallOutput { .. } => last_emitted_role = Some("tool"),
-            ResponseItem::Reasoning { .. } | ResponseItem::Other => {}
-            ResponseItem::CustomToolCall { .. } => {}
-            ResponseItem::CustomToolCallOutput { .. } => {}
-            ResponseItem::WebSearchCall { .. } => {}
-        }
-    }
-
-    // Find the last user message index in the input.
-    let mut last_user_index: Option<usize> = None;
-    for (idx, item) in input.iter().enumerate() {
-        if let ResponseItem::Message { role, .. } = item
-            && role == "user"
-        {
-            last_user_index = Some(idx);
-        }
-    }
-
-    // Attach reasoning only if the conversation does not end with a user message.
-    if !matches!(last_emitted_role, Some("user")) {
-        for (idx, item) in input.iter().enumerate() {
-            // Only consider reasoning that appears after the last user message.
-            if let Some(u_idx) = last_user_index
-                && idx <= u_idx
-            {
-                continue;
-            }
-
-            if let ResponseItem::Reasoning {
-                content: Some(items),
-                ..
-            } = item
-            {
-                let mut text = String::new();
-                for c in items {
-                    match c {
-                        ReasoningItemContent::ReasoningText { text: t }
-                        | ReasoningItemContent::Text { text: t } => text.push_str(t),
-                    }
-                }
-                if text.trim().is_empty() {
-                    continue;
-                }
-
-                // Prefer immediate previous assistant message (stop turns)
-                let mut attached = false;
-                if idx > 0
-                    && let ResponseItem::Message { role, .. } = &input[idx - 1]
-                    && role == "assistant"
-                {
-                    reasoning_by_anchor_index
-                        .entry(idx - 1)
-                        .and_modify(|v| v.push_str(&text))
-                        .or_insert(text.clone());
-                    attached = true;
-                }
-
-                // Otherwise, attach to immediate next assistant anchor (tool-calls or assistant message)
-                if !attached && idx + 1 < input.len() {
-                    match &input[idx + 1] {
-                        ResponseItem::FunctionCall { .. } | ResponseItem::LocalShellCall { .. } => {
-                            reasoning_by_anchor_index
-                                .entry(idx + 1)
-                                .and_modify(|v| v.push_str(&text))
-                                .or_insert(text.clone());
-                        }
-                        ResponseItem::Message { role, .. } if role == "assistant" => {
-                            reasoning_by_anchor_index
-                                .entry(idx + 1)
-                                .and_modify(|v| v.push_str(&text))
-                                .or_insert(text.clone());
-                        }
-                        _ => {}
-                    }
-                }
-            }
-        }
-    }
-
-    // Track last assistant text we emitted to avoid duplicate assistant messages
-    // in the outbound Chat Completions payload (can happen if a final
-    // aggregated assistant message was recorded alongside an earlier partial).
-    let mut last_assistant_text: Option<String> = None;
-
-    for (idx, item) in input.iter().enumerate() {
         match item {
             ResponseItem::Message { role, content, .. } => {
                 let mut text = String::new();
@@ -156,24 +56,7 @@ pub(crate) async fn stream_chat_completions(
                         _ => {}
                     }
                 }
-                // Skip exact-duplicate assistant messages.
-                if role == "assistant" {
-                    if let Some(prev) = &last_assistant_text
-                        && prev == &text
-                    {
-                        continue;
-                    }
-                    last_assistant_text = Some(text.clone());
-                }
-
-                let mut msg = json!({"role": role, "content": text});
-                if role == "assistant"
-                    && let Some(reasoning) = reasoning_by_anchor_index.get(&idx)
-                    && let Some(obj) = msg.as_object_mut()
-                {
-                    obj.insert("reasoning".to_string(), json!(reasoning));
-                }
-                messages.push(msg);
+                messages.push(json!({"role": role, "content": text}));
             }
             ResponseItem::FunctionCall {
                 name,
@@ -181,7 +64,7 @@ pub(crate) async fn stream_chat_completions(
                 call_id,
                 ..
             } => {
-                let mut msg = json!({
+                messages.push(json!({
                     "role": "assistant",
                     "content": null,
                     "tool_calls": [{
@@ -192,13 +75,7 @@ pub(crate) async fn stream_chat_completions(
                             "arguments": arguments,
                         }
                     }]
-                });
-                if let Some(reasoning) = reasoning_by_anchor_index.get(&idx)
-                    && let Some(obj) = msg.as_object_mut()
-                {
-                    obj.insert("reasoning".to_string(), json!(reasoning));
-                }
-                messages.push(msg);
+                }));
             }
             ResponseItem::LocalShellCall {
                 id,
@@ -207,7 +84,7 @@ pub(crate) async fn stream_chat_completions(
                 action,
             } => {
                 // Confirm with API team.
-                let mut msg = json!({
+                messages.push(json!({
                     "role": "assistant",
                     "content": null,
                     "tool_calls": [{
@@ -216,13 +93,7 @@ pub(crate) async fn stream_chat_completions(
                         "status": status,
                         "action": action,
                     }]
-                });
-                if let Some(reasoning) = reasoning_by_anchor_index.get(&idx)
-                    && let Some(obj) = msg.as_object_mut()
-                {
-                    obj.insert("reasoning".to_string(), json!(reasoning));
-                }
-                messages.push(msg);
+                }));
             }
             ResponseItem::FunctionCallOutput { call_id, output } => {
                 messages.push(json!({
@@ -258,9 +129,7 @@ pub(crate) async fn stream_chat_completions(
                     "content": output,
                 }));
             }
-            ResponseItem::Reasoning { .. }
-            | ResponseItem::WebSearchCall { .. }
-            | ResponseItem::Other => {
+            ResponseItem::Reasoning { .. } | ResponseItem::Other => {
                 // Omit these items from the conversation history.
                 continue;
             }
@@ -460,10 +329,7 @@ async fn process_chat_sse<S>(
             // Some providers stream `reasoning` as a plain string while others
             // nest the text under an object (e.g. `{ "reasoning": { "text": "…" } }`).
             if let Some(reasoning_val) = choice.get("delta").and_then(|d| d.get("reasoning")) {
-                let mut maybe_text = reasoning_val
-                    .as_str()
-                    .map(|s| s.to_string())
-                    .filter(|s| !s.is_empty());
+                let mut maybe_text = reasoning_val.as_str().map(|s| s.to_string());
 
                 if maybe_text.is_none() && reasoning_val.is_object() {
                     if let Some(s) = reasoning_val
@@ -482,39 +348,12 @@ async fn process_chat_sse<S>(
                 }
 
                 if let Some(reasoning) = maybe_text {
-                    // Accumulate so we can emit a terminal Reasoning item at the end.
-                    reasoning_text.push_str(&reasoning);
                     let _ = tx_event
                         .send(Ok(ResponseEvent::ReasoningContentDelta(reasoning)))
                         .await;
                 }
             }
 
-            // Some providers only include reasoning on the final message object.
-            if let Some(message_reasoning) = choice.get("message").and_then(|m| m.get("reasoning"))
-            {
-                // Accept either a plain string or an object with { text | content }
-                if let Some(s) = message_reasoning.as_str() {
-                    if !s.is_empty() {
-                        reasoning_text.push_str(s);
-                        let _ = tx_event
-                            .send(Ok(ResponseEvent::ReasoningContentDelta(s.to_string())))
-                            .await;
-                    }
-                } else if let Some(obj) = message_reasoning.as_object()
-                    && let Some(s) = obj
-                        .get("text")
-                        .and_then(|v| v.as_str())
-                        .or_else(|| obj.get("content").and_then(|v| v.as_str()))
-                    && !s.is_empty()
-                {
-                    reasoning_text.push_str(s);
-                    let _ = tx_event
-                        .send(Ok(ResponseEvent::ReasoningContentDelta(s.to_string())))
-                        .await;
-                }
-            }
-
             // Handle streaming function / tool calls.
             if let Some(tool_calls) = choice
                 .get("delta")
@@ -670,47 +509,27 @@ where
                     // do NOT emit yet. Forward any other item (e.g. FunctionCall) right
                     // away so downstream consumers see it.
 
-                    let is_assistant_message = matches!(
-                        &item,
-                        codex_protocol::models::ResponseItem::Message { role, .. } if role == "assistant"
-                    );
+                    let is_assistant_delta = matches!(&item, codex_protocol::models::ResponseItem::Message { role, .. } if role == "assistant");
 
-                    if is_assistant_message {
-                        match this.mode {
-                            AggregateMode::AggregatedOnly => {
-                                // Only use the final assistant message if we have not
-                                // seen any deltas; otherwise, deltas already built the
-                                // cumulative text and this would duplicate it.
-                                if this.cumulative.is_empty()
-                                    && let codex_protocol::models::ResponseItem::Message {
-                                        content,
-                                        ..
-                                    } = &item
-                                    && let Some(text) = content.iter().find_map(|c| match c {
-                                        codex_protocol::models::ContentItem::OutputText {
-                                            text,
-                                        } => Some(text),
-                                        _ => None,
-                                    })
-                                {
-                                    this.cumulative.push_str(text);
+                    if is_assistant_delta {
+                        // Only use the final assistant message if we have not
+                        // seen any deltas; otherwise, deltas already built the
+                        // cumulative text and this would duplicate it.
+                        if this.cumulative.is_empty()
+                            && let codex_protocol::models::ResponseItem::Message { content, .. } =
+                                &item
+                            && let Some(text) = content.iter().find_map(|c| match c {
+                                codex_protocol::models::ContentItem::OutputText { text } => {
+                                    Some(text)
                                 }
-                                // Swallow assistant message here; emit on Completed.
-                                continue;
-                            }
-                            AggregateMode::Streaming => {
-                                // In streaming mode, if we have not seen any deltas, forward
-                                // the final assistant message directly. If deltas were seen,
-                                // suppress the final message to avoid duplication.
-                                if this.cumulative.is_empty() {
-                                    return Poll::Ready(Some(Ok(ResponseEvent::OutputItemDone(
-                                        item,
-                                    ))));
-                                } else {
-                                    continue;
-                                }
-                            }
+                                _ => None,
+                            })
+                        {
+                            this.cumulative.push_str(text);
                         }
+
+                        // Swallow assistant message here; emit on Completed.
+                        continue;
                     }
 
                     // Not an assistant message – forward immediately.
@@ -742,11 +561,6 @@ where
                         emitted_any = true;
                     }
 
-                    // Always emit the final aggregated assistant message when any
-                    // content deltas have been observed. In AggregatedOnly mode this
-                    // is the sole assistant output; in Streaming mode this finalizes
-                    // the streamed deltas into a terminal OutputItemDone so callers
-                    // can persist/render the message once per turn.
                     if !this.cumulative.is_empty() {
                         let aggregated_message = codex_protocol::models::ResponseItem::Message {
                             id: None,
@@ -809,8 +623,11 @@ where
                 Poll::Ready(Some(Ok(ResponseEvent::ReasoningSummaryPartAdded))) => {
                     continue;
                 }
-                Poll::Ready(Some(Ok(ResponseEvent::WebSearchCallBegin { call_id }))) => {
-                    return Poll::Ready(Some(Ok(ResponseEvent::WebSearchCallBegin { call_id })));
+                Poll::Ready(Some(Ok(ResponseEvent::WebSearchCallBegin { .. }))) => {
+                    return Poll::Ready(Some(Ok(ResponseEvent::WebSearchCallBegin {
+                        call_id: String::new(),
+                        query: None,
+                    })));
                 }
             }
         }

codex-rs/core/src/client.rs

@@ -1,14 +1,12 @@
 use std::io::BufRead;
 use std::path::Path;
-use std::sync::OnceLock;
 use std::time::Duration;
 
-use crate::AuthManager;
 use bytes::Bytes;
-use codex_protocol::mcp_protocol::AuthMode;
+use codex_login::AuthManager;
+use codex_login::AuthMode;
 use eventsource_stream::Eventsource;
 use futures::prelude::*;
-use regex_lite::Regex;
 use reqwest::StatusCode;
 use serde::Deserialize;
 use serde::Serialize;
@@ -55,8 +53,6 @@ struct ErrorResponse {
 #[derive(Debug, Deserialize)]
 struct Error {
     r#type: Option<String>,
-    #[allow(dead_code)]
-    code: Option<String>,
     message: Option<String>,
 
     // Optional fields available on "usage_limit_reached" and "usage_not_included" errors
@@ -164,7 +160,21 @@ impl ModelClient {
         let store = prompt.store && auth_mode != Some(AuthMode::ChatGPT);
 
         let full_instructions = prompt.get_full_instructions(&self.config.model_family);
-        let tools_json = create_tools_json_for_responses_api(&prompt.tools)?;
+        let mut tools_json = create_tools_json_for_responses_api(&prompt.tools)?;
+        // ChatGPT backend expects the preview name for web search.
+        if auth_mode == Some(AuthMode::ChatGPT) {
+            for tool in &mut tools_json {
+                if let Some(map) = tool.as_object_mut()
+                    && map.get("type").and_then(|v| v.as_str()) == Some("web_search")
+                {
+                    map.insert(
+                        "type".to_string(),
+                        serde_json::Value::String("web_search_preview".to_string()),
+                    );
+                }
+            }
+        }
+
         let reasoning = create_reasoning_param_for_request(
             &self.config.model_family,
             self.effort,
@@ -568,9 +578,8 @@ async fn process_sse<S>(
                     if let Some(error) = error {
                         match serde_json::from_value::<Error>(error.clone()) {
                             Ok(error) => {
-                                let delay = try_parse_retry_after(&error);
                                 let message = error.message.unwrap_or_default();
-                                response_error = Some(CodexErr::Stream(message, delay));
+                                response_error = Some(CodexErr::Stream(message, None));
                             }
                             Err(e) => {
                                 debug!("failed to parse ErrorResponse: {e}");
@@ -598,9 +607,11 @@ async fn process_sse<S>(
             | "response.custom_tool_call_input.delta"
             | "response.custom_tool_call_input.done" // also emitted as response.output_item.done
             | "response.in_progress"
-            | "response.output_text.done" => {}
-            "response.output_item.added" => {
-                if let Some(item) = event.item.as_ref() {
+            | "response.output_item.added"
+            | "response.output_text.done" => {
+                if event.kind == "response.output_item.added"
+                    && let Some(item) = event.item.as_ref()
+                {
                     // Detect web_search_call begin and forward a synthetic event upstream.
                     if let Some(ty) = item.get("type").and_then(|v| v.as_str())
                         && ty == "web_search_call"
@@ -610,7 +621,7 @@ async fn process_sse<S>(
                             .and_then(|v| v.as_str())
                             .unwrap_or("")
                             .to_string();
-                        let ev = ResponseEvent::WebSearchCallBegin { call_id };
+                        let ev = ResponseEvent::WebSearchCallBegin { call_id, query: None };
                         if tx_event.send(Ok(ev)).await.is_err() {
                             return;
                         }
@@ -656,40 +667,6 @@ async fn stream_from_fixture(
     Ok(ResponseStream { rx_event })
 }
 
-fn rate_limit_regex() -> &'static Regex {
-    static RE: OnceLock<Regex> = OnceLock::new();
-
-    #[expect(clippy::unwrap_used)]
-    RE.get_or_init(|| Regex::new(r"Please try again in (\d+(?:\.\d+)?)(s|ms)").unwrap())
-}
-
-fn try_parse_retry_after(err: &Error) -> Option<Duration> {
-    if err.code != Some("rate_limit_exceeded".to_string()) {
-        return None;
-    }
-
-    // parse the Please try again in 1.898s format using regex
-    let re = rate_limit_regex();
-    if let Some(message) = &err.message
-        && let Some(captures) = re.captures(message)
-    {
-        let seconds = captures.get(1);
-        let unit = captures.get(2);
-
-        if let (Some(value), Some(unit)) = (seconds, unit) {
-            let value = value.as_str().parse::<f64>().ok()?;
-            let unit = unit.as_str();
-
-            if unit == "s" {
-                return Some(Duration::from_secs_f64(value));
-            } else if unit == "ms" {
-                return Some(Duration::from_millis(value as u64));
-            }
-        }
-    }
-    None
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -910,7 +887,7 @@ mod tests {
                     msg,
                     "Rate limit reached for gpt-5 in organization org-AAA on tokens per min (TPM): Limit 30000, Used 22999, Requested 12528. Please try again in 11.054s. Visit https://platform.openai.com/account/rate-limits to learn more."
                 );
-                assert_eq!(*delay, Some(Duration::from_secs_f64(11.054)));
+                assert_eq!(*delay, None);
             }
             other => panic!("unexpected second event: {other:?}"),
         }
@@ -1014,31 +991,4 @@ mod tests {
             );
         }
     }
-
-    #[test]
-    fn test_try_parse_retry_after() {
-        let err = Error {
-            r#type: None,
-            message: Some("Rate limit reached for gpt-5 in organization org- on tokens per min (TPM): Limit 1, Used 1, Requested 19304. Please try again in 28ms. Visit https://platform.openai.com/account/rate-limits to learn more.".to_string()),
-            code: Some("rate_limit_exceeded".to_string()),
-            plan_type: None,
-            resets_in_seconds: None
-        };
-
-        let delay = try_parse_retry_after(&err);
-        assert_eq!(delay, Some(Duration::from_millis(28)));
-    }
-
-    #[test]
-    fn test_try_parse_retry_after_no_delay() {
-        let err = Error {
-            r#type: None,
-            message: Some("Rate limit reached for gpt-5 in organization <ORG> on tokens per min (TPM): Limit 30000, Used 6899, Requested 24050. Please try again in 1.898s. Visit https://platform.openai.com/account/rate-limits to learn more.".to_string()),
-            code: Some("rate_limit_exceeded".to_string()),
-            plan_type: None,
-            resets_in_seconds: None
-        };
-        let delay = try_parse_retry_after(&err);
-        assert_eq!(delay, Some(Duration::from_secs_f64(1.898)));
-    }
 }

codex-rs/core/src/client_common.rs

@@ -35,7 +35,7 @@ pub struct Prompt {
 
     /// Tools available to the model, including additional tools sourced from
     /// external MCP servers.
-    pub(crate) tools: Vec<OpenAiTool>,
+    pub tools: Vec<OpenAiTool>,
 
     /// Optional override for the built-in BASE_INSTRUCTIONS.
     pub base_instructions_override: Option<String>,
@@ -95,6 +95,7 @@ pub enum ResponseEvent {
     ReasoningSummaryPartAdded,
     WebSearchCallBegin {
         call_id: String,
+        query: Option<String>,
     },
 }
 
@@ -174,7 +175,7 @@ pub(crate) fn create_text_param_for_request(
     })
 }
 
-pub struct ResponseStream {
+pub(crate) struct ResponseStream {
     pub(crate) rx_event: mpsc::Receiver<Result<ResponseEvent>>,
 }
 

codex-rs/core/src/codex.rs

@@ -8,12 +8,12 @@ use std::sync::MutexGuard;
 use std::sync::atomic::AtomicU64;
 use std::time::Duration;
 
-use crate::AuthManager;
 use async_channel::Receiver;
 use async_channel::Sender;
 use codex_apply_patch::ApplyPatchAction;
 use codex_apply_patch::MaybeApplyPatchVerified;
 use codex_apply_patch::maybe_parse_apply_patch_verified;
+use codex_login::AuthManager;
 use codex_protocol::protocol::ConversationHistoryResponseEvent;
 use codex_protocol::protocol::TaskStartedEvent;
 use codex_protocol::protocol::TurnAbortReason;
@@ -43,7 +43,6 @@ use crate::client_common::ResponseEvent;
 use crate::config::Config;
 use crate::config_types::ShellEnvironmentPolicy;
 use crate::conversation_history::ConversationHistory;
-use crate::conversation_manager::InitialHistory;
 use crate::environment_context::EnvironmentContext;
 use crate::error::CodexErr;
 use crate::error::Result as CodexResult;
@@ -90,7 +89,6 @@ use crate::protocol::ExecCommandBeginEvent;
 use crate::protocol::ExecCommandEndEvent;
 use crate::protocol::FileChange;
 use crate::protocol::InputItem;
-use crate::protocol::ListCustomPromptsResponseEvent;
 use crate::protocol::Op;
 use crate::protocol::PatchApplyBeginEvent;
 use crate::protocol::PatchApplyEndEvent;
@@ -102,7 +100,6 @@ use crate::protocol::Submission;
 use crate::protocol::TaskCompleteEvent;
 use crate::protocol::TurnDiffEvent;
 use crate::protocol::WebSearchBeginEvent;
-use crate::protocol::WebSearchEndEvent;
 use crate::rollout::RolloutRecorder;
 use crate::safety::SafetyCheck;
 use crate::safety::assess_command_safety;
@@ -113,7 +110,6 @@ use crate::user_notification::UserNotification;
 use crate::util::backoff;
 use codex_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
 use codex_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig;
-use codex_protocol::custom_prompts::CustomPrompt;
 use codex_protocol::models::ContentItem;
 use codex_protocol::models::FunctionCallOutputPayload;
 use codex_protocol::models::LocalShellAction;
@@ -122,7 +118,6 @@ use codex_protocol::models::ReasoningItemReasoningSummary;
 use codex_protocol::models::ResponseInputItem;
 use codex_protocol::models::ResponseItem;
 use codex_protocol::models::ShellToolCallParams;
-use codex_protocol::models::WebSearchAction;
 
 // A convenience extension trait for acquiring mutex locks where poisoning is
 // unrecoverable and should abort the program. This avoids scattered `.unwrap()`
@@ -170,7 +165,7 @@ impl Codex {
     pub async fn spawn(
         config: Config,
         auth_manager: Arc<AuthManager>,
-        conversation_history: InitialHistory,
+        initial_history: Option<Vec<ResponseItem>>,
     ) -> CodexResult<CodexSpawnOk> {
         let (tx_sub, rx_sub) = async_channel::bounded(SUBMISSION_CHANNEL_CAPACITY);
         let (tx_event, rx_event) = async_channel::unbounded();
@@ -178,6 +173,7 @@ impl Codex {
         let user_instructions = get_user_instructions(&config).await;
 
         let config = Arc::new(config);
+        let resume_path = config.experimental_resume.clone();
 
         let configure_session = ConfigureSession {
             provider: config.model_provider.clone(),
@@ -191,6 +187,7 @@ impl Codex {
             disable_response_storage: config.disable_response_storage,
             notify: config.notify.clone(),
             cwd: config.cwd.clone(),
+            resume_path,
         };
 
         // Generate a unique ID for the lifetime of this Codex session.
@@ -199,15 +196,13 @@ impl Codex {
             config.clone(),
             auth_manager.clone(),
             tx_event.clone(),
+            initial_history,
         )
         .await
         .map_err(|e| {
             error!("Failed to create session: {e:#}");
             CodexErr::InternalAgentDied
         })?;
-        session
-            .record_initial_history(&turn_context, conversation_history)
-            .await;
         let session_id = session.session_id;
 
         // This task will run until Op::Shutdown is received.
@@ -353,6 +348,8 @@ struct ConfigureSession {
     /// `ConfigureSession` operation so that the business-logic layer can
     /// operate deterministically.
     cwd: PathBuf,
+
+    resume_path: Option<PathBuf>,
 }
 
 impl Session {
@@ -361,8 +358,8 @@ impl Session {
         config: Arc<Config>,
         auth_manager: Arc<AuthManager>,
         tx_event: Sender<Event>,
+        initial_history: Option<Vec<ResponseItem>>,
     ) -> anyhow::Result<(Arc<Self>, TurnContext)> {
-        let session_id = Uuid::new_v4();
         let ConfigureSession {
             provider,
             model,
@@ -375,6 +372,7 @@ impl Session {
             disable_response_storage,
             notify,
             cwd,
+            resume_path,
         } = configure_session;
         debug!("Configuring session: model={model}; provider={provider:?}");
         if !cwd.is_absolute() {
@@ -390,25 +388,89 @@ impl Session {
         // - spin up MCP connection manager
         // - perform default shell discovery
         // - load history metadata
-        let rollout_fut = RolloutRecorder::new(&config, session_id, user_instructions.clone());
+        let rollout_fut = async {
+            match resume_path.as_ref() {
+                Some(path) => RolloutRecorder::resume(path, cwd.clone())
+                    .await
+                    .map(|(rec, saved)| (saved.session_id, Some(saved), rec)),
+                None => {
+                    let session_id = Uuid::new_v4();
+                    RolloutRecorder::new(&config, session_id, user_instructions.clone())
+                        .await
+                        .map(|rec| (session_id, None, rec))
+                }
+            }
+        };
 
         let mcp_fut = McpConnectionManager::new(config.mcp_servers.clone());
         let default_shell_fut = shell::default_user_shell();
         let history_meta_fut = crate::message_history::history_metadata(&config);
 
         // Join all independent futures.
-        let (rollout_recorder, mcp_res, default_shell, (history_log_id, history_entry_count)) =
+        let (rollout_res, mcp_res, default_shell, (history_log_id, history_entry_count)) =
             tokio::join!(rollout_fut, mcp_fut, default_shell_fut, history_meta_fut);
 
-        let rollout_recorder = rollout_recorder.map_err(|e| {
-            error!("failed to initialize rollout recorder: {e:#}");
-            anyhow::anyhow!("failed to initialize rollout recorder: {e:#}")
-        })?;
+        // Handle rollout result, which determines the session_id.
+        struct RolloutResult {
+            session_id: Uuid,
+            rollout_recorder: Option<RolloutRecorder>,
+            restored_items: Option<Vec<ResponseItem>>,
+        }
+        let rollout_result = match rollout_res {
+            Ok((session_id, maybe_saved, recorder)) => {
+                let restored_items: Option<Vec<ResponseItem>> = initial_history.or_else(|| {
+                    maybe_saved.and_then(|saved_session| {
+                        if saved_session.items.is_empty() {
+                            None
+                        } else {
+                            Some(saved_session.items)
+                        }
+                    })
+                });
+                RolloutResult {
+                    session_id,
+                    rollout_recorder: Some(recorder),
+                    restored_items,
+                }
+            }
+            Err(e) => {
+                if let Some(path) = resume_path.as_ref() {
+                    return Err(anyhow::anyhow!(
+                        "failed to resume rollout from {path:?}: {e}"
+                    ));
+                }
+
+                let message = format!("failed to initialize rollout recorder: {e}");
+                post_session_configured_error_events.push(Event {
+                    id: INITIAL_SUBMIT_ID.to_owned(),
+                    msg: EventMsg::Error(ErrorEvent {
+                        message: message.clone(),
+                    }),
+                });
+                warn!("{message}");
+
+                RolloutResult {
+                    session_id: Uuid::new_v4(),
+                    rollout_recorder: None,
+                    restored_items: None,
+                }
+            }
+        };
+
+        let RolloutResult {
+            session_id,
+            rollout_recorder,
+            restored_items,
+        } = rollout_result;
+
         // Create the mutable state for the Session.
-        let state = State {
+        let mut state = State {
             history: ConversationHistory::new(),
             ..Default::default()
         };
+        if let Some(restored_items) = restored_items {
+            state.history.record_items(&restored_items);
+        }
 
         // Handle MCP manager result and record any startup failures.
         let (mcp_connection_manager, failed_clients) = match mcp_res {
@@ -456,7 +518,6 @@ impl Session {
                 include_apply_patch_tool: config.include_apply_patch_tool,
                 include_web_search_request: config.tools_web_search_request,
                 use_streamable_shell_tool: config.use_experimental_streamable_shell_tool,
-                include_view_image_tool: config.include_view_image_tool,
             }),
             user_instructions,
             base_instructions,
@@ -473,12 +534,26 @@ impl Session {
             session_manager: ExecSessionManager::default(),
             notify,
             state: Mutex::new(state),
-            rollout: Mutex::new(Some(rollout_recorder)),
+            rollout: Mutex::new(rollout_recorder),
             codex_linux_sandbox_exe: config.codex_linux_sandbox_exe.clone(),
             user_shell: default_shell,
             show_raw_agent_reasoning: config.show_raw_agent_reasoning,
         });
 
+        // record the initial user instructions and environment context,
+        // regardless of whether we restored items.
+        let mut conversation_items = Vec::<ResponseItem>::with_capacity(2);
+        if let Some(user_instructions) = turn_context.user_instructions.as_deref() {
+            conversation_items.push(Prompt::format_user_instructions_message(user_instructions));
+        }
+        conversation_items.push(ResponseItem::from(EnvironmentContext::new(
+            Some(turn_context.cwd.clone()),
+            Some(turn_context.approval_policy),
+            Some(turn_context.sandbox_policy.clone()),
+            Some(sess.user_shell.clone()),
+        )));
+        sess.record_conversation_items(&conversation_items).await;
+
         // Dispatch the SessionConfiguredEvent first and then report any errors.
         let events = std::iter::once(Event {
             id: INITIAL_SUBMIT_ID.to_owned(),
@@ -516,42 +591,6 @@ impl Session {
         }
     }
 
-    async fn record_initial_history(
-        &self,
-        turn_context: &TurnContext,
-        conversation_history: InitialHistory,
-    ) {
-        match conversation_history {
-            InitialHistory::New => {
-                self.record_initial_history_new(turn_context).await;
-            }
-            InitialHistory::Resumed(items) => {
-                self.record_initial_history_resumed(items).await;
-            }
-        }
-    }
-
-    async fn record_initial_history_new(&self, turn_context: &TurnContext) {
-        // record the initial user instructions and environment context,
-        // regardless of whether we restored items.
-        // TODO: Those items shouldn't be "user messages" IMO. Maybe developer messages.
-        let mut conversation_items = Vec::<ResponseItem>::with_capacity(2);
-        if let Some(user_instructions) = turn_context.user_instructions.as_deref() {
-            conversation_items.push(Prompt::format_user_instructions_message(user_instructions));
-        }
-        conversation_items.push(ResponseItem::from(EnvironmentContext::new(
-            Some(turn_context.cwd.clone()),
-            Some(turn_context.approval_policy),
-            Some(turn_context.sandbox_policy.clone()),
-            Some(self.user_shell.clone()),
-        )));
-        self.record_conversation_items(&conversation_items).await;
-    }
-
-    async fn record_initial_history_resumed(&self, items: Vec<ResponseItem>) {
-        self.record_conversation_items(&items).await;
-    }
-
     /// Sends the given event to the client and swallows the send event, if
     /// any, logging it as an error.
     pub(crate) async fn send_event(&self, event: Event) {
@@ -613,17 +652,9 @@ impl Session {
     }
 
     pub fn notify_approval(&self, sub_id: &str, decision: ReviewDecision) {
-        let entry = {
-            let mut state = self.state.lock_unchecked();
-            state.pending_approvals.remove(sub_id)
-        };
-        match entry {
-            Some(tx_approve) => {
-                tx_approve.send(decision).ok();
-            }
-            None => {
-                warn!("No pending approval found for sub_id: {sub_id}");
-            }
+        let mut state = self.state.lock_unchecked();
+        if let Some(tx_approve) = state.pending_approvals.remove(sub_id) {
+            tx_approve.send(decision).ok();
         }
     }
 
@@ -1077,7 +1108,6 @@ async fn submission_loop(
                     include_apply_patch_tool: config.include_apply_patch_tool,
                     include_web_search_request: config.tools_web_search_request,
                     use_streamable_shell_tool: config.use_experimental_streamable_shell_tool,
-                    include_view_image_tool: config.include_view_image_tool,
                 });
 
                 let new_turn_context = TurnContext {
@@ -1163,7 +1193,6 @@ async fn submission_loop(
                             include_web_search_request: config.tools_web_search_request,
                             use_streamable_shell_tool: config
                                 .use_experimental_streamable_shell_tool,
-                            include_view_image_tool: config.include_view_image_tool,
                         }),
                         user_instructions: turn_context.user_instructions.clone(),
                         base_instructions: turn_context.base_instructions.clone(),
@@ -1254,27 +1283,6 @@ async fn submission_loop(
                     warn!("failed to send McpListToolsResponse event: {e}");
                 }
             }
-            Op::ListCustomPrompts => {
-                let tx_event = sess.tx_event.clone();
-                let sub_id = sub.id.clone();
-
-                let custom_prompts: Vec<CustomPrompt> =
-                    if let Some(dir) = crate::custom_prompts::default_prompts_dir() {
-                        crate::custom_prompts::discover_prompts_in(&dir).await
-                    } else {
-                        Vec::new()
-                    };
-
-                let event = Event {
-                    id: sub_id,
-                    msg: EventMsg::ListCustomPromptsResponse(ListCustomPromptsResponseEvent {
-                        custom_prompts,
-                    }),
-                };
-                if let Err(e) = tx_event.send(event).await {
-                    warn!("failed to send ListCustomPromptsResponse event: {e}");
-                }
-            }
             Op::Compact => {
                 // Create a summarization request as user input
                 const SUMMARIZATION_PROMPT: &str = include_str!("prompt_for_compact_command.md");
@@ -1735,12 +1743,13 @@ async fn try_run_turn(
                 .await?;
                 output.push(ProcessedResponseItem { item, response });
             }
-            ResponseEvent::WebSearchCallBegin { call_id } => {
+            ResponseEvent::WebSearchCallBegin { call_id, query } => {
+                let q = query.unwrap_or_else(|| "Searching Web...".to_string());
                 let _ = sess
                     .tx_event
                     .send(Event {
                         id: sub_id.to_string(),
-                        msg: EventMsg::WebSearchBegin(WebSearchBeginEvent { call_id }),
+                        msg: EventMsg::WebSearchBegin(WebSearchBeginEvent { call_id, query: q }),
                     })
                     .await;
             }
@@ -1872,12 +1881,6 @@ async fn run_compact_task(
     }
 
     sess.remove_task(&sub_id);
-
-    {
-        let mut state = sess.state.lock_unchecked();
-        state.history.keep_last_messages(1);
-    }
-
     let event = Event {
         id: sub_id.clone(),
         msg: EventMsg::AgentMessage(AgentMessageEvent {
@@ -1892,6 +1895,9 @@ async fn run_compact_task(
         }),
     };
     sess.send_event(event).await;
+
+    let mut state = sess.state.lock_unchecked();
+    state.history.keep_last_messages(1);
 }
 
 async fn handle_response_item(
@@ -2039,17 +2045,6 @@ async fn handle_response_item(
             debug!("unexpected CustomToolCallOutput from stream");
             None
         }
-        ResponseItem::WebSearchCall { id, action, .. } => {
-            if let WebSearchAction::Search { query } = action {
-                let call_id = id.unwrap_or_else(|| "".to_string());
-                let event = Event {
-                    id: sub_id.to_string(),
-                    msg: EventMsg::WebSearchEnd(WebSearchEndEvent { call_id, query }),
-                };
-                sess.tx_event.send(event).await.ok();
-            }
-            None
-        }
         ResponseItem::Other => None,
     };
     Ok(output)
@@ -2082,36 +2077,6 @@ async fn handle_function_call(
             )
             .await
         }
-        "view_image" => {
-            #[derive(serde::Deserialize)]
-            struct SeeImageArgs {
-                path: String,
-            }
-            let args = match serde_json::from_str::<SeeImageArgs>(&arguments) {
-                Ok(a) => a,
-                Err(e) => {
-                    return ResponseInputItem::FunctionCallOutput {
-                        call_id,
-                        output: FunctionCallOutputPayload {
-                            content: format!("failed to parse function arguments: {e}"),
-                            success: Some(false),
-                        },
-                    };
-                }
-            };
-            let abs = turn_context.resolve_path(Some(args.path));
-            let output = match sess.inject_input(vec![InputItem::LocalImage { path: abs }]) {
-                Ok(()) => FunctionCallOutputPayload {
-                    content: "attached local image path".to_string(),
-                    success: Some(true),
-                },
-                Err(_) => FunctionCallOutputPayload {
-                    content: "unable to attach image (no active task)".to_string(),
-                    success: Some(false),
-                },
-            };
-            ResponseInputItem::FunctionCallOutput { call_id, output }
-        }
         "apply_patch" => {
             let args = match serde_json::from_str::<ApplyPatchToolArgs>(&arguments) {
                 Ok(a) => a,

codex-rs/core/src/config.rs

@@ -8,6 +8,8 @@ use crate::config_types::Tui;
 use crate::config_types::UriBasedFileOpener;
 use crate::config_types::Verbosity;
 use crate::git_info::resolve_root_git_project_for_trust;
+use crate::mcp_toml::load_project_overlays;
+use crate::mcp_toml::to_mcp_server_config;
 use crate::model_family::ModelFamily;
 use crate::model_family::find_family_for_model;
 use crate::model_provider_info::ModelProviderInfo;
@@ -15,10 +17,10 @@ use crate::model_provider_info::built_in_model_providers;
 use crate::openai_model_info::get_model_info;
 use crate::protocol::AskForApproval;
 use crate::protocol::SandboxPolicy;
+use codex_login::AuthMode;
 use codex_protocol::config_types::ReasoningEffort;
 use codex_protocol::config_types::ReasoningSummary;
 use codex_protocol::config_types::SandboxMode;
-use codex_protocol::mcp_protocol::AuthMode;
 use dirs::home_dir;
 use serde::Deserialize;
 use std::collections::HashMap;
@@ -178,15 +180,6 @@ pub struct Config {
     pub preferred_auth_method: AuthMode,
 
     pub use_experimental_streamable_shell_tool: bool,
-
-    /// Include the `view_image` tool that lets the agent attach a local image path to context.
-    pub include_view_image_tool: bool,
-    /// When true, disables burst-paste detection for typed input entirely.
-    /// All characters are inserted as they are received, and no buffering
-    /// or placeholder replacement will occur for fast keypress bursts.
-    pub disable_paste_burst: bool,
-
-    pub use_experimental_reasoning_summary: bool,
 }
 
 impl Config {
@@ -484,8 +477,6 @@ pub struct ConfigToml {
 
     pub experimental_use_exec_command_tool: Option<bool>,
 
-    pub use_experimental_reasoning_summary: Option<bool>,
-
     /// The value for the `originator` header included with Responses API requests.
     pub responses_originator_header_internal_override: Option<String>,
 
@@ -496,11 +487,6 @@ pub struct ConfigToml {
 
     /// Nested tools section for feature toggles
     pub tools: Option<ToolsToml>,
-
-    /// When true, disables burst-paste detection for typed input entirely.
-    /// All characters are inserted as they are received, and no buffering
-    /// or placeholder replacement will occur for fast keypress bursts.
-    pub disable_paste_burst: Option<bool>,
 }
 
 #[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
@@ -510,12 +496,9 @@ pub struct ProjectConfig {
 
 #[derive(Deserialize, Debug, Clone, Default)]
 pub struct ToolsToml {
+    // Renamed from `web_search_request`; keep alias for backwards compatibility.
     #[serde(default, alias = "web_search_request")]
     pub web_search: Option<bool>,
-
-    /// Enable the `view_image` tool that lets the agent attach local images.
-    #[serde(default)]
-    pub view_image: Option<bool>,
 }
 
 impl ConfigToml {
@@ -605,7 +588,6 @@ pub struct ConfigOverrides {
     pub base_instructions: Option<String>,
     pub include_plan_tool: Option<bool>,
     pub include_apply_patch_tool: Option<bool>,
-    pub include_view_image_tool: Option<bool>,
     pub disable_response_storage: Option<bool>,
     pub show_raw_agent_reasoning: Option<bool>,
     pub tools_web_search_request: Option<bool>,
@@ -619,6 +601,7 @@ impl Config {
         overrides: ConfigOverrides,
         codex_home: PathBuf,
     ) -> std::io::Result<Self> {
+        let mut cfg = cfg;
         let user_instructions = Self::load_instructions(Some(&codex_home));
 
         // Destructure ConfigOverrides fully to ensure all overrides are applied.
@@ -633,7 +616,6 @@ impl Config {
             base_instructions,
             include_plan_tool,
             include_apply_patch_tool,
-            include_view_image_tool,
             disable_response_storage,
             show_raw_agent_reasoning,
             tools_web_search_request: override_tools_web_search_request,
@@ -675,7 +657,7 @@ impl Config {
             })?
             .clone();
 
-        let shell_environment_policy = cfg.shell_environment_policy.into();
+        let shell_environment_policy = cfg.shell_environment_policy.clone().into();
 
         let resolved_cwd = {
             use std::env;
@@ -696,16 +678,12 @@ impl Config {
             }
         };
 
-        let history = cfg.history.unwrap_or_default();
+        let history = cfg.history.clone().unwrap_or_default();
 
         let tools_web_search_request = override_tools_web_search_request
             .or(cfg.tools.as_ref().and_then(|t| t.web_search))
             .unwrap_or(false);
 
-        let include_view_image_tool = include_view_image_tool
-            .or(cfg.tools.as_ref().and_then(|t| t.view_image))
-            .unwrap_or(true);
-
         let model = model
             .or(config_profile.model)
             .or(cfg.model)
@@ -735,6 +713,37 @@ impl Config {
 
         let experimental_resume = cfg.experimental_resume;
 
+        // Merge project overlays (.mcp.toml and .mcp.local.toml) with precedence:
+        // user (config.toml) < project < local. Skip invalid or non-stdio entries.
+        // Determine project root using the same logic as trust checks.
+        let project_root =
+            resolve_root_git_project_for_trust(&resolved_cwd).unwrap_or(resolved_cwd.clone());
+        if let Ok(overlays) = load_project_overlays(&project_root) {
+            // Start from user-defined servers from config.toml
+            let mut merged = std::mem::take(&mut cfg.mcp_servers);
+
+            // Apply in ascending precedence order: project then local.
+            for (scope, overlay) in overlays.iter().rev() {
+                for (name, entry) in overlay.mcp_servers.iter() {
+                    match to_mcp_server_config(entry, |k| std::env::var(k).ok()) {
+                        Ok(server_cfg) => {
+                            merged.insert(name.clone(), server_cfg);
+                        }
+                        Err(e) => {
+                            tracing::warn!(
+                                "Skipping MCP server `{}` from {:?} overlay: {:#}",
+                                name,
+                                scope,
+                                e
+                            );
+                        }
+                    }
+                }
+            }
+
+            cfg.mcp_servers = merged;
+        }
+
         // Load base instructions override from a file if specified. If the
         // path is relative, resolve it against the effective cwd so the
         // behaviour matches other path-like config values.
@@ -778,7 +787,7 @@ impl Config {
             codex_home,
             history,
             file_opener: cfg.file_opener.unwrap_or(UriBasedFileOpener::VsCode),
-            tui: cfg.tui.unwrap_or_default(),
+            tui: cfg.tui.clone().unwrap_or_default(),
             codex_linux_sandbox_exe,
 
             hide_agent_reasoning: cfg.hide_agent_reasoning.unwrap_or(false),
@@ -797,7 +806,7 @@ impl Config {
             model_verbosity: config_profile.model_verbosity.or(cfg.model_verbosity),
             chatgpt_base_url: config_profile
                 .chatgpt_base_url
-                .or(cfg.chatgpt_base_url)
+                .or(cfg.chatgpt_base_url.clone())
                 .unwrap_or("https://chatgpt.com/backend-api/".to_string()),
 
             experimental_resume,
@@ -809,11 +818,6 @@ impl Config {
             use_experimental_streamable_shell_tool: cfg
                 .experimental_use_exec_command_tool
                 .unwrap_or(false),
-            include_view_image_tool,
-            disable_paste_burst: cfg.disable_paste_burst.unwrap_or(false),
-            use_experimental_reasoning_summary: cfg
-                .use_experimental_reasoning_summary
-                .unwrap_or(false),
         };
         Ok(config)
     }
@@ -1182,9 +1186,6 @@ disable_response_storage = true
                 responses_originator_header: "codex_cli_rs".to_string(),
                 preferred_auth_method: AuthMode::ChatGPT,
                 use_experimental_streamable_shell_tool: false,
-                include_view_image_tool: true,
-                disable_paste_burst: false,
-                use_experimental_reasoning_summary: false,
             },
             o3_profile_config
         );
@@ -1241,9 +1242,6 @@ disable_response_storage = true
             responses_originator_header: "codex_cli_rs".to_string(),
             preferred_auth_method: AuthMode::ChatGPT,
             use_experimental_streamable_shell_tool: false,
-            include_view_image_tool: true,
-            disable_paste_burst: false,
-            use_experimental_reasoning_summary: false,
         };
 
         assert_eq!(expected_gpt3_profile_config, gpt3_profile_config);
@@ -1315,9 +1313,6 @@ disable_response_storage = true
             responses_originator_header: "codex_cli_rs".to_string(),
             preferred_auth_method: AuthMode::ChatGPT,
             use_experimental_streamable_shell_tool: false,
-            include_view_image_tool: true,
-            disable_paste_burst: false,
-            use_experimental_reasoning_summary: false,
         };
 
         assert_eq!(expected_zdr_profile_config, zdr_profile_config);
@@ -1339,9 +1334,9 @@ disable_response_storage = true
 
         let raw_path = project_dir.path().to_string_lossy();
         let path_str = if raw_path.contains('\\') {
-            format!("'{raw_path}'")
+            format!("'{}'", raw_path)
         } else {
-            format!("\"{raw_path}\"")
+            format!("\"{}\"", raw_path)
         };
         let expected = format!(
             r#"[projects.{path_str}]
@@ -1362,9 +1357,9 @@ trust_level = "trusted"
         let config_path = codex_home.path().join(CONFIG_TOML_FILE);
         let raw_path = project_dir.path().to_string_lossy();
         let path_str = if raw_path.contains('\\') {
-            format!("'{raw_path}'")
+            format!("'{}'", raw_path)
         } else {
-            format!("\"{raw_path}\"")
+            format!("\"{}\"", raw_path)
         };
         // Use a quoted key so backslashes don't require escaping on Windows
         let initial = format!(

codex-rs/core/src/conversation_history.rs

@@ -72,7 +72,7 @@ fn is_api_message(message: &ResponseItem) -> bool {
         | ResponseItem::CustomToolCallOutput { .. }
         | ResponseItem::LocalShellCall { .. }
         | ResponseItem::Reasoning { .. } => true,
-        ResponseItem::WebSearchCall { .. } | ResponseItem::Other => false,
+        ResponseItem::Other => false,
     }
 }
 

codex-rs/core/src/conversation_manager.rs

@@ -1,9 +1,8 @@
 use std::collections::HashMap;
-use std::path::PathBuf;
 use std::sync::Arc;
 
-use crate::AuthManager;
-use crate::CodexAuth;
+use codex_login::AuthManager;
+use codex_login::CodexAuth;
 use tokio::sync::RwLock;
 use uuid::Uuid;
 
@@ -17,15 +16,8 @@ use crate::error::Result as CodexResult;
 use crate::protocol::Event;
 use crate::protocol::EventMsg;
 use crate::protocol::SessionConfiguredEvent;
-use crate::rollout::RolloutRecorder;
 use codex_protocol::models::ResponseItem;
 
-#[derive(Debug, Clone, PartialEq)]
-pub enum InitialHistory {
-    New,
-    Resumed(Vec<ResponseItem>),
-}
-
 /// Represents a newly created Codex conversation, including the first event
 /// (which is [`EventMsg::SessionConfigured`]).
 pub struct NewConversation {
@@ -52,7 +44,7 @@ impl ConversationManager {
     /// Construct with a dummy AuthManager containing the provided CodexAuth.
     /// Used for integration tests: should not be used by ordinary business logic.
     pub fn with_auth(auth: CodexAuth) -> Self {
-        Self::new(crate::AuthManager::from_auth_for_testing(auth))
+        Self::new(codex_login::AuthManager::from_auth_for_testing(auth))
     }
 
     pub async fn new_conversation(&self, config: Config) -> CodexResult<NewConversation> {
@@ -65,21 +57,14 @@ impl ConversationManager {
         config: Config,
         auth_manager: Arc<AuthManager>,
     ) -> CodexResult<NewConversation> {
-        // TO BE REFACTORED: use the config experimental_resume field until we have a mainstream way.
-        if let Some(resume_path) = config.experimental_resume.as_ref() {
-            let initial_history = RolloutRecorder::get_rollout_history(resume_path).await?;
-            let CodexSpawnOk {
-                codex,
-                session_id: conversation_id,
-            } = Codex::spawn(config, auth_manager, initial_history).await?;
-            self.finalize_spawn(codex, conversation_id).await
-        } else {
-            let CodexSpawnOk {
-                codex,
-                session_id: conversation_id,
-            } = { Codex::spawn(config, auth_manager, InitialHistory::New).await? };
-            self.finalize_spawn(codex, conversation_id).await
-        }
+        let CodexSpawnOk {
+            codex,
+            session_id: conversation_id,
+        } = {
+            let initial_history = None;
+            Codex::spawn(config, auth_manager, initial_history).await?
+        };
+        self.finalize_spawn(codex, conversation_id).await
     }
 
     async fn finalize_spawn(
@@ -125,20 +110,6 @@ impl ConversationManager {
             .ok_or_else(|| CodexErr::ConversationNotFound(conversation_id))
     }
 
-    pub async fn resume_conversation_from_rollout(
-        &self,
-        config: Config,
-        rollout_path: PathBuf,
-        auth_manager: Arc<AuthManager>,
-    ) -> CodexResult<NewConversation> {
-        let initial_history = RolloutRecorder::get_rollout_history(&rollout_path).await?;
-        let CodexSpawnOk {
-            codex,
-            session_id: conversation_id,
-        } = Codex::spawn(config, auth_manager, initial_history).await?;
-        self.finalize_spawn(codex, conversation_id).await
-    }
-
     pub async fn remove_conversation(&self, conversation_id: Uuid) {
         self.conversations.write().await.remove(&conversation_id);
     }
@@ -154,7 +125,7 @@ impl ConversationManager {
         config: Config,
     ) -> CodexResult<NewConversation> {
         // Compute the prefix up to the cut point.
-        let history =
+        let truncated_history =
             truncate_after_dropping_last_messages(conversation_history, num_messages_to_drop);
 
         // Spawn a new conversation with the computed initial history.
@@ -162,7 +133,7 @@ impl ConversationManager {
         let CodexSpawnOk {
             codex,
             session_id: conversation_id,
-        } = Codex::spawn(config, auth_manager, history).await?;
+        } = Codex::spawn(config, auth_manager, Some(truncated_history)).await?;
 
         self.finalize_spawn(codex, conversation_id).await
     }
@@ -170,9 +141,9 @@ impl ConversationManager {
 
 /// Return a prefix of `items` obtained by dropping the last `n` user messages
 /// and all items that follow them.
-fn truncate_after_dropping_last_messages(items: Vec<ResponseItem>, n: usize) -> InitialHistory {
-    if n == 0 {
-        return InitialHistory::Resumed(items);
+fn truncate_after_dropping_last_messages(items: Vec<ResponseItem>, n: usize) -> Vec<ResponseItem> {
+    if n == 0 || items.is_empty() {
+        return items;
     }
 
     // Walk backwards counting only `user` Message items, find cut index.
@@ -190,11 +161,11 @@ fn truncate_after_dropping_last_messages(items: Vec<ResponseItem>, n: usize) ->
             }
         }
     }
-    if cut_index == 0 {
-        // No prefix remains after dropping; start a new conversation.
-        InitialHistory::New
+    if count < n {
+        // If fewer than n messages exist, drop everything.
+        Vec::new()
     } else {
-        InitialHistory::Resumed(items.into_iter().take(cut_index).collect())
+        items.into_iter().take(cut_index).collect()
     }
 }
 
@@ -252,10 +223,10 @@ mod tests {
         let truncated = truncate_after_dropping_last_messages(items.clone(), 1);
         assert_eq!(
             truncated,
-            InitialHistory::Resumed(vec![items[0].clone(), items[1].clone(), items[2].clone(),])
+            vec![items[0].clone(), items[1].clone(), items[2].clone()]
         );
 
         let truncated2 = truncate_after_dropping_last_messages(items, 2);
-        assert_eq!(truncated2, InitialHistory::New);
+        assert!(truncated2.is_empty());
     }
 }

codex-rs/core/src/custom_prompts.rs

@@ -1,127 +0,0 @@
-use codex_protocol::custom_prompts::CustomPrompt;
-use std::collections::HashSet;
-use std::path::Path;
-use std::path::PathBuf;
-use tokio::fs;
-
-/// Return the default prompts directory: `$CODEX_HOME/prompts`.
-/// If `CODEX_HOME` cannot be resolved, returns `None`.
-pub fn default_prompts_dir() -> Option<PathBuf> {
-    crate::config::find_codex_home()
-        .ok()
-        .map(|home| home.join("prompts"))
-}
-
-/// Discover prompt files in the given directory, returning entries sorted by name.
-/// Non-files are ignored. If the directory does not exist or cannot be read, returns empty.
-pub async fn discover_prompts_in(dir: &Path) -> Vec<CustomPrompt> {
-    discover_prompts_in_excluding(dir, &HashSet::new()).await
-}
-
-/// Discover prompt files in the given directory, excluding any with names in `exclude`.
-/// Returns entries sorted by name. Non-files are ignored. Missing/unreadable dir yields empty.
-pub async fn discover_prompts_in_excluding(
-    dir: &Path,
-    exclude: &HashSet<String>,
-) -> Vec<CustomPrompt> {
-    let mut out: Vec<CustomPrompt> = Vec::new();
-    let mut entries = match fs::read_dir(dir).await {
-        Ok(entries) => entries,
-        Err(_) => return out,
-    };
-
-    while let Ok(Some(entry)) = entries.next_entry().await {
-        let path = entry.path();
-        let is_file = entry
-            .file_type()
-            .await
-            .map(|ft| ft.is_file())
-            .unwrap_or(false);
-        if !is_file {
-            continue;
-        }
-        // Only include Markdown files with a .md extension.
-        let is_md = path
-            .extension()
-            .and_then(|s| s.to_str())
-            .map(|ext| ext.eq_ignore_ascii_case("md"))
-            .unwrap_or(false);
-        if !is_md {
-            continue;
-        }
-        let Some(name) = path
-            .file_stem()
-            .and_then(|s| s.to_str())
-            .map(|s| s.to_string())
-        else {
-            continue;
-        };
-        if exclude.contains(&name) {
-            continue;
-        }
-        let content = match fs::read_to_string(&path).await {
-            Ok(s) => s,
-            Err(_) => continue,
-        };
-        out.push(CustomPrompt {
-            name,
-            path,
-            content,
-        });
-    }
-    out.sort_by(|a, b| a.name.cmp(&b.name));
-    out
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs;
-    use tempfile::tempdir;
-
-    #[tokio::test]
-    async fn empty_when_dir_missing() {
-        let tmp = tempdir().expect("create TempDir");
-        let missing = tmp.path().join("nope");
-        let found = discover_prompts_in(&missing).await;
-        assert!(found.is_empty());
-    }
-
-    #[tokio::test]
-    async fn discovers_and_sorts_files() {
-        let tmp = tempdir().expect("create TempDir");
-        let dir = tmp.path();
-        fs::write(dir.join("b.md"), b"b").unwrap();
-        fs::write(dir.join("a.md"), b"a").unwrap();
-        fs::create_dir(dir.join("subdir")).unwrap();
-        let found = discover_prompts_in(dir).await;
-        let names: Vec<String> = found.into_iter().map(|e| e.name).collect();
-        assert_eq!(names, vec!["a", "b"]);
-    }
-
-    #[tokio::test]
-    async fn excludes_builtins() {
-        let tmp = tempdir().expect("create TempDir");
-        let dir = tmp.path();
-        fs::write(dir.join("init.md"), b"ignored").unwrap();
-        fs::write(dir.join("foo.md"), b"ok").unwrap();
-        let mut exclude = HashSet::new();
-        exclude.insert("init".to_string());
-        let found = discover_prompts_in_excluding(dir, &exclude).await;
-        let names: Vec<String> = found.into_iter().map(|e| e.name).collect();
-        assert_eq!(names, vec!["foo"]);
-    }
-
-    #[tokio::test]
-    async fn skips_non_utf8_files() {
-        let tmp = tempdir().expect("create TempDir");
-        let dir = tmp.path();
-        // Valid UTF-8 file
-        fs::write(dir.join("good.md"), b"hello").unwrap();
-        // Invalid UTF-8 content in .md file (e.g., lone 0xFF byte)
-        fs::write(dir.join("bad.md"), vec![0xFF, 0xFE, b'\n']).unwrap();
-        let found = discover_prompts_in(dir).await;
-        let names: Vec<String> = found.into_iter().map(|e| e.name).collect();
-        assert_eq!(names, vec!["good"]);
-    }
-}

codex-rs/core/src/environment_context.rs

@@ -85,21 +85,23 @@ impl EnvironmentContext {
         }
         if let Some(approval_policy) = self.approval_policy {
             lines.push(format!(
-                "  <approval_policy>{approval_policy}</approval_policy>"
+                "  <approval_policy>{}</approval_policy>",
+                approval_policy
             ));
         }
         if let Some(sandbox_mode) = self.sandbox_mode {
-            lines.push(format!("  <sandbox_mode>{sandbox_mode}</sandbox_mode>"));
+            lines.push(format!("  <sandbox_mode>{}</sandbox_mode>", sandbox_mode));
         }
         if let Some(network_access) = self.network_access {
             lines.push(format!(
-                "  <network_access>{network_access}</network_access>"
+                "  <network_access>{}</network_access>",
+                network_access
             ));
         }
         if let Some(shell) = self.shell
             && let Some(shell_name) = shell.name()
         {
-            lines.push(format!("  <shell>{shell_name}</shell>"));
+            lines.push(format!("  <shell>{}</shell>", shell_name));
         }
         lines.push(ENVIRONMENT_CONTEXT_END.to_string());
         lines.join("\n")

codex-rs/core/src/error.rs

@@ -170,15 +170,15 @@ fn format_reset_duration(total_secs: u64) -> String {
     let mut parts: Vec<String> = Vec::new();
     if days > 0 {
         let unit = if days == 1 { "day" } else { "days" };
-        parts.push(format!("{days} {unit}"));
+        parts.push(format!("{} {}", days, unit));
     }
     if hours > 0 {
         let unit = if hours == 1 { "hour" } else { "hours" };
-        parts.push(format!("{hours} {unit}"));
+        parts.push(format!("{} {}", hours, unit));
     }
     if minutes > 0 {
         let unit = if minutes == 1 { "minute" } else { "minutes" };
-        parts.push(format!("{minutes} {unit}"));
+        parts.push(format!("{} {}", minutes, unit));
     }
 
     if parts.is_empty() {

codex-rs/core/src/exec.rs

@@ -40,10 +40,6 @@ const EXIT_CODE_SIGNAL_BASE: i32 = 128; // conventional shell: 128 + signal
 const READ_CHUNK_SIZE: usize = 8192; // bytes per read
 const AGGREGATE_BUFFER_INITIAL_CAPACITY: usize = 8 * 1024; // 8 KiB
 
-/// Limit the number of ExecCommandOutputDelta events emitted per exec call.
-/// Aggregation still collects full output; only the live event stream is capped.
-pub(crate) const MAX_EXEC_OUTPUT_DELTAS_PER_CALL: usize = 10_000;
-
 #[derive(Debug, Clone)]
 pub struct ExecParams {
     pub command: Vec<String>,
@@ -348,7 +344,6 @@ async fn read_capped<R: AsyncRead + Unpin + Send + 'static>(
 ) -> io::Result<StreamOutput<Vec<u8>>> {
     let mut buf = Vec::with_capacity(AGGREGATE_BUFFER_INITIAL_CAPACITY);
     let mut tmp = [0u8; READ_CHUNK_SIZE];
-    let mut emitted_deltas: usize = 0;
 
     // No caps: append all bytes
 
@@ -358,9 +353,7 @@ async fn read_capped<R: AsyncRead + Unpin + Send + 'static>(
             break;
         }
 
-        if let Some(stream) = &stream
-            && emitted_deltas < MAX_EXEC_OUTPUT_DELTAS_PER_CALL
-        {
+        if let Some(stream) = &stream {
             let chunk = tmp[..n].to_vec();
             let msg = EventMsg::ExecCommandOutputDelta(ExecCommandOutputDeltaEvent {
                 call_id: stream.call_id.clone(),
@@ -377,7 +370,6 @@ async fn read_capped<R: AsyncRead + Unpin + Send + 'static>(
             };
             #[allow(clippy::let_unit_value)]
             let _ = stream.tx_event.send(event).await;
-            emitted_deltas += 1;
         }
 
         if let Some(tx) = &aggregate_tx {

codex-rs/core/src/exec_command/session_manager.rs

@@ -359,7 +359,10 @@ fn truncate_middle(s: &str, max_bytes: usize) -> (String, Option<u64>) {
     let est_tokens = (s.len() as u64).div_ceil(4);
     if max_bytes == 0 {
         // Cannot keep any content; still return a full marker (never truncated).
-        return (format!("…{est_tokens} tokens truncated…"), Some(est_tokens));
+        return (
+            format!("…{} tokens truncated…", est_tokens),
+            Some(est_tokens),
+        );
     }
 
     // Helper to truncate a string to a given byte length on a char boundary.
@@ -403,13 +406,16 @@ fn truncate_middle(s: &str, max_bytes: usize) -> (String, Option<u64>) {
     // Refine marker length and budgets until stable. Marker is never truncated.
     let mut guess_tokens = est_tokens; // worst-case: everything truncated
     for _ in 0..4 {
-        let marker = format!("…{guess_tokens} tokens truncated…");
+        let marker = format!("…{} tokens truncated…", guess_tokens);
         let marker_len = marker.len();
         let keep_budget = max_bytes.saturating_sub(marker_len);
         if keep_budget == 0 {
             // No room for any content within the cap; return a full, untruncated marker
             // that reflects the entire truncated content.
-            return (format!("…{est_tokens} tokens truncated…"), Some(est_tokens));
+            return (
+                format!("…{} tokens truncated…", est_tokens),
+                Some(est_tokens),
+            );
         }
 
         let left_budget = keep_budget / 2;
@@ -435,11 +441,14 @@ fn truncate_middle(s: &str, max_bytes: usize) -> (String, Option<u64>) {
     }
 
     // Fallback: use last guess to build output.
-    let marker = format!("…{guess_tokens} tokens truncated…");
+    let marker = format!("…{} tokens truncated…", guess_tokens);
     let marker_len = marker.len();
     let keep_budget = max_bytes.saturating_sub(marker_len);
     if keep_budget == 0 {
-        return (format!("…{est_tokens} tokens truncated…"), Some(est_tokens));
+        return (
+            format!("…{} tokens truncated…", est_tokens),
+            Some(est_tokens),
+        );
     }
     let left_budget = keep_budget / 2;
     let right_budget = keep_budget - left_budget;

codex-rs/core/src/git_info.rs

@@ -10,35 +10,7 @@ use tokio::process::Command;
 use tokio::time::Duration as TokioDuration;
 use tokio::time::timeout;
 
-/// Return `true` if the project folder specified by the `Config` is inside a
-/// Git repository.
-///
-/// The check walks up the directory hierarchy looking for a `.git` file or
-/// directory (note `.git` can be a file that contains a `gitdir` entry). This
-/// approach does **not** require the `git` binary or the `git2` crate and is
-/// therefore fairly lightweight.
-///
-/// Note that this does **not** detect *work‑trees* created with
-/// `git worktree add` where the checkout lives outside the main repository
-/// directory. If you need Codex to work from such a checkout simply pass the
-/// `--allow-no-git-exec` CLI flag that disables the repo requirement.
-pub fn get_git_repo_root(base_dir: &Path) -> Option<PathBuf> {
-    let mut dir = base_dir.to_path_buf();
-
-    loop {
-        if dir.join(".git").exists() {
-            return Some(dir);
-        }
-
-        // Pop one component (go up one directory).  `pop` returns false when
-        // we have reached the filesystem root.
-        if !dir.pop() {
-            break;
-        }
-    }
-
-    None
-}
+use crate::util::is_inside_git_repo;
 
 /// Timeout for git commands to prevent freezing on large repositories
 const GIT_COMMAND_TIMEOUT: TokioDuration = TokioDuration::from_secs(5);
@@ -122,7 +94,9 @@ pub async fn collect_git_info(cwd: &Path) -> Option<GitInfo> {
 
 /// Returns the closest git sha to HEAD that is on a remote as well as the diff to that sha.
 pub async fn git_diff_to_remote(cwd: &Path) -> Option<GitDiffToRemote> {
-    get_git_repo_root(cwd)?;
+    if !is_inside_git_repo(cwd) {
+        return None;
+    }
 
     let remotes = get_git_remotes(cwd).await?;
     let branches = branch_ancestry(cwd).await?;
@@ -466,7 +440,7 @@ async fn diff_against_sha(cwd: &Path, sha: &GitSha) -> Option<String> {
 }
 
 /// Resolve the path that should be used for trust checks. Similar to
-/// `[get_git_repo_root]`, but resolves to the root of the main
+/// `[utils::is_inside_git_repo]`, but resolves to the root of the main
 /// repository. Handles worktrees.
 pub fn resolve_root_git_project_for_trust(cwd: &Path) -> Option<PathBuf> {
     let base = if cwd.is_dir() { cwd } else { cwd.parent()? };

codex-rs/core/src/lib.rs

@@ -6,20 +6,17 @@
 #![deny(clippy::print_stdout, clippy::print_stderr)]
 
 mod apply_patch;
-pub mod auth;
 mod bash;
 mod chat_completions;
 mod client;
 mod client_common;
 pub mod codex;
 mod codex_conversation;
-pub mod token_data;
 pub use codex_conversation::CodexConversation;
 pub mod config;
 pub mod config_profile;
 pub mod config_types;
 mod conversation_history;
-pub mod custom_prompts;
 mod environment_context;
 pub mod error;
 pub mod exec;
@@ -30,6 +27,7 @@ pub mod git_info;
 mod is_safe_command;
 pub mod landlock;
 mod mcp_connection_manager;
+pub mod mcp_toml;
 mod mcp_tool_call;
 mod message_history;
 mod model_provider_info;
@@ -42,9 +40,6 @@ pub use model_provider_info::create_oss_provider_with_base_url;
 mod conversation_manager;
 pub use conversation_manager::ConversationManager;
 pub use conversation_manager::NewConversation;
-// Re-export common auth types for workspace consumers
-pub use auth::AuthManager;
-pub use auth::CodexAuth;
 pub mod model_family;
 mod openai_model_info;
 mod openai_tools;
@@ -59,7 +54,6 @@ pub mod terminal;
 mod tool_apply_patch;
 pub mod turn_diff_tracker;
 pub mod user_agent;
-pub use rollout::list::ConversationsPage;
 mod user_notification;
 pub mod util;
 pub use apply_patch::CODEX_APPLY_PATCH_ARG1;
@@ -70,14 +64,3 @@ pub use codex_protocol::protocol;
 // Re-export protocol config enums to ensure call sites can use the same types
 // as those in the protocol crate when constructing protocol messages.
 pub use codex_protocol::config_types as protocol_config_types;
-
-pub use client::ModelClient;
-pub use client_common::Prompt;
-pub use client_common::ResponseEvent;
-pub use client_common::ResponseStream;
-pub use codex_protocol::models::ContentItem;
-pub use codex_protocol::models::LocalShellAction;
-pub use codex_protocol::models::LocalShellExecAction;
-pub use codex_protocol::models::LocalShellStatus;
-pub use codex_protocol::models::ReasoningItemContent;
-pub use codex_protocol::models::ResponseItem;

codex-rs/core/src/mcp_connection_manager.rs

@@ -36,8 +36,33 @@ use crate::config_types::McpServerConfig;
 const MCP_TOOL_NAME_DELIMITER: &str = "__";
 const MAX_TOOL_NAME_LENGTH: usize = 64;
 
-/// Timeout for the `tools/list` request.
-const LIST_TOOLS_TIMEOUT: Duration = Duration::from_secs(10);
+/// Read MCP timeout (milliseconds) from the environment.
+///
+/// Falls back to 10_000 ms (10s) if the variable is not set or cannot be
+/// parsed as an integer.
+pub(crate) fn mcp_timeout_from_env() -> Duration {
+    match std::env::var("MCP_TIMEOUT") {
+        Ok(val) => parse_mcp_timeout(Some(val.trim())),
+        Err(_) => parse_mcp_timeout(None),
+    }
+}
+
+pub(crate) fn parse_mcp_timeout(val: Option<&str>) -> Duration {
+    const DEFAULT_MS: u64 = 10_000;
+    match val {
+        Some(s) => match s.parse::<u64>() {
+            Ok(ms) => Duration::from_millis(ms),
+            Err(_) => {
+                tracing::warn!(
+                    "Invalid MCP_TIMEOUT value, using default of {} ms",
+                    DEFAULT_MS
+                );
+                Duration::from_millis(DEFAULT_MS)
+            }
+        },
+        None => Duration::from_millis(DEFAULT_MS),
+    }
+}
 
 /// Map that holds a startup error for every MCP server that could **not** be
 /// spawned successfully.
@@ -154,7 +179,7 @@ impl McpConnectionManager {
                             protocol_version: mcp_types::MCP_SCHEMA_VERSION.to_owned(),
                         };
                         let initialize_notification_params = None;
-                        let timeout = Some(Duration::from_secs(10));
+                        let timeout = Some(mcp_timeout_from_env());
                         match client
                             .initialize(params, initialize_notification_params, timeout)
                             .await
@@ -242,7 +267,7 @@ async fn list_all_tools(
         let client_clone = client.clone();
         join_set.spawn(async move {
             let res = client_clone
-                .list_tools(None, Some(LIST_TOOLS_TIMEOUT))
+                .list_tools(None, Some(mcp_timeout_from_env()))
                 .await;
             (server_name_cloned, res)
         });
@@ -285,6 +310,24 @@ mod tests {
     use super::*;
     use mcp_types::ToolInputSchema;
 
+    #[test]
+    fn test_mcp_timeout_default_is_10s() {
+        let d = parse_mcp_timeout(None);
+        assert_eq!(d, Duration::from_millis(10_000));
+    }
+
+    #[test]
+    fn test_mcp_timeout_parses_ms() {
+        let d = parse_mcp_timeout(Some("1234"));
+        assert_eq!(d, Duration::from_millis(1234));
+    }
+
+    #[test]
+    fn test_mcp_timeout_invalid_uses_default() {
+        let d = parse_mcp_timeout(Some("abc"));
+        assert_eq!(d, Duration::from_millis(10_000));
+    }
+
     fn create_test_tool(server_name: &str, tool_name: &str) -> ToolInfo {
         ToolInfo {
             server_name: server_name.to_string(),

codex-rs/core/src/mcp_toml.rs

@@ -0,0 +1,395 @@
+use anyhow::Result;
+use anyhow::anyhow;
+use serde::Deserialize;
+use std::collections::HashMap;
+use std::path::Path;
+
+use crate::config_types::McpServerConfig;
+
+/// Expand `${VAR}` and `${VAR:-default}` sequences in `input`.
+///
+/// - `${VAR}`: replaced by `lookup(VAR)` or returns an error if unset.
+/// - `${VAR:-default}`: replaced by `lookup(VAR)` if set; otherwise `default`.
+///
+/// No whitespace is trimmed. Defaults are treated as literal strings (no nested
+/// expansions inside the default value). Variable names must match
+/// `^[A-Za-z_][A-Za-z0-9_]*$`.
+pub(crate) fn expand_vars(
+    input: &str,
+    mut lookup: impl FnMut(&str) -> Option<String>,
+    source_label: &str,
+) -> Result<String> {
+    let mut out = String::with_capacity(input.len());
+    let bytes = input.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] == b'$' && i + 1 < bytes.len() && bytes[i + 1] == b'{' {
+            // Find closing brace
+            let start_inner = i + 2;
+            let mut end = start_inner;
+            let mut found = false;
+            while end < bytes.len() {
+                if bytes[end] == b'}' {
+                    found = true;
+                    break;
+                }
+                end += 1;
+            }
+            if !found {
+                return Err(anyhow!(
+                    "unterminated variable expansion starting at byte {i} in {source_label}"
+                ));
+            }
+            let inner = &input[start_inner..end];
+            let (name, default) = match inner.split_once(":-") {
+                Some((n, d)) => (n, Some(d)),
+                None => (inner, None),
+            };
+
+            if !is_valid_var_name(name) {
+                return Err(anyhow!(
+                    "invalid variable name `{}` in {} (must match ^[A-Za-z_][A-Za-z0-9_]*$)",
+                    name,
+                    source_label
+                ));
+            }
+
+            let replacement = match (lookup(name), default) {
+                (Some(v), _) => v,
+                (None, Some(d)) => d.to_string(),
+                (None, None) => {
+                    return Err(anyhow!(
+                        "environment variable `{}` not set and no default provided in {}",
+                        name,
+                        source_label
+                    ));
+                }
+            };
+            out.push_str(&replacement);
+            i = end + 1;
+            continue;
+        }
+        // Copy through single byte as UTF-8 is preserved by slicing boundaries here.
+        out.push(bytes[i] as char);
+        i += 1;
+    }
+    Ok(out)
+}
+
+fn is_valid_var_name(name: &str) -> bool {
+    let mut chars = name.chars();
+    match chars.next() {
+        Some(c) if is_alpha_or_underscore(c) => (),
+        _ => return false,
+    }
+    chars.all(|c| is_alnum_or_underscore(c))
+}
+
+fn is_alpha_or_underscore(c: char) -> bool {
+    (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_'
+}
+
+fn is_alnum_or_underscore(c: char) -> bool {
+    is_alpha_or_underscore(c) || (c >= '0' && c <= '9')
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_expand_vars_simple() {
+        let lookup = |k: &str| match k {
+            "USER" => Some("alice".into()),
+            _ => None,
+        };
+        let res = expand_vars("/home/${USER}/bin", lookup, "test");
+        match res {
+            Ok(s) => assert_eq!(s, "/home/alice/bin"),
+            Err(e) => panic!("unexpected error: {e:#}"),
+        }
+    }
+
+    #[test]
+    fn test_expand_vars_with_default() {
+        let lookup = |_k: &str| None;
+        let res = expand_vars("${REGION:-us-east}", lookup, "test");
+        match res {
+            Ok(s) => assert_eq!(s, "us-east"),
+            Err(e) => panic!("unexpected error: {e:#}"),
+        }
+    }
+
+    #[test]
+    fn test_expand_vars_missing_errors() {
+        let lookup = |_k: &str| None;
+        let res = expand_vars("x${REQUIRED}y", lookup, "test");
+        let msg = match res {
+            Ok(v) => panic!("expected error, got {v}"),
+            Err(e) => format!("{e:#}"),
+        };
+        assert!(msg.contains("environment variable `REQUIRED` not set"));
+    }
+
+    #[test]
+    fn test_expand_vars_multiple() {
+        let lookup = |k: &str| match k {
+            "A" => Some("1".into()),
+            "B" => Some("2".into()),
+            _ => None,
+        };
+        let res = expand_vars("${A}-${B}-${C:-x}", lookup, "test");
+        match res {
+            Ok(s) => assert_eq!(s, "1-2-x"),
+            Err(e) => panic!("unexpected error: {e:#}"),
+        }
+    }
+
+    #[test]
+    fn test_expand_vars_invalid_name() {
+        let lookup = |_k: &str| None;
+        let res = expand_vars("${1BAD}", lookup, "test");
+        let msg = match res {
+            Ok(v) => panic!("expected error, got {v}"),
+            Err(e) => format!("{e:#}"),
+        };
+        assert!(msg.contains("invalid variable name"));
+    }
+
+    #[test]
+    fn test_expand_vars_unterminated() {
+        let lookup = |_k: &str| None;
+        let res = expand_vars("abc ${FOO", lookup, "test-file");
+        let msg = match res {
+            Ok(v) => panic!("expected error, got {v}"),
+            Err(e) => format!("{e:#}"),
+        };
+        assert!(msg.contains("unterminated variable expansion"));
+        assert!(msg.contains("test-file"));
+    }
+}
+
+// -------------------------------
+// Serde types and converters
+// -------------------------------
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Scope {
+    User,
+    Project,
+    Local,
+}
+
+#[derive(Debug, Deserialize, Default)]
+pub struct McpToml {
+    #[serde(default)]
+    pub mcp_servers: HashMap<String, McpTomlEntry>,
+}
+
+#[derive(Debug, Deserialize, Default)]
+pub struct McpTomlEntry {
+    #[serde(default)]
+    pub r#type: Option<String>,
+    pub command: Option<String>,
+    #[serde(default)]
+    pub args: Vec<String>,
+    #[serde(default)]
+    pub env: HashMap<String, String>,
+}
+
+/// Convert a permissive TOML entry to the strict `McpServerConfig` used by Codex.
+///
+/// - Only `stdio` (or missing) transport is accepted; anything else returns an error.
+/// - Expands variables in `command`, each `args[]`, and each `env` value.
+/// - Returns an error if `command` is missing (after expansion) or if any
+///   `${VAR}` expansion fails with no default.
+pub fn to_mcp_server_config(
+    entry: &McpTomlEntry,
+    mut lookup: impl FnMut(&str) -> Option<String>,
+) -> Result<McpServerConfig> {
+    // Transport check: only allow stdio or unspecified
+    if let Some(t) = entry.r#type.as_deref() {
+        let t_lower = t.to_ascii_lowercase();
+        if t_lower != "stdio" {
+            return Err(anyhow!(
+                "unsupported MCP transport `{}` (only `stdio` supported)",
+                t
+            ));
+        }
+    }
+
+    // Command is required
+    let command_raw = entry
+        .command
+        .as_ref()
+        .ok_or_else(|| anyhow!("missing `command` for stdio MCP server"))?;
+    let command = expand_vars(command_raw, &mut lookup, "overlay:command")?;
+
+    // Args with expansion
+    let mut args = Vec::with_capacity(entry.args.len());
+    for a in &entry.args {
+        args.push(expand_vars(a, &mut lookup, "overlay:args")?);
+    }
+
+    // Env values with expansion; keep as None if empty
+    let mut env_out: HashMap<String, String> = HashMap::with_capacity(entry.env.len());
+    for (k, v) in &entry.env {
+        env_out.insert(k.clone(), expand_vars(v, &mut lookup, "overlay:env")?);
+    }
+
+    Ok(McpServerConfig {
+        command,
+        args,
+        env: if env_out.is_empty() {
+            None
+        } else {
+            Some(env_out)
+        },
+    })
+}
+
+#[cfg(test)]
+mod convert_tests {
+    use super::*;
+
+    #[test]
+    fn test_to_mcp_server_config_stdio_ok() {
+        let entry = McpTomlEntry {
+            r#type: None,
+            command: Some("${HOME}/bin/svc".to_string()),
+            args: vec!["--region".into(), "${REGION:-us-east}".into()],
+            env: HashMap::from([(String::from("API_KEY"), String::from("${KEY}"))]),
+        };
+        let mut map = HashMap::new();
+        map.insert("HOME".to_string(), "/home/alice".to_string());
+        map.insert("KEY".to_string(), "secret".to_string());
+        let lookup = |k: &str| map.get(k).cloned();
+        let cfg = match to_mcp_server_config(&entry, lookup) {
+            Ok(c) => c,
+            Err(e) => panic!("unexpected error: {e:#}"),
+        };
+        assert_eq!(cfg.command, "/home/alice/bin/svc");
+        assert_eq!(cfg.args, vec!["--region", "us-east"]);
+        let api_key = cfg.env.as_ref().and_then(|m| m.get("API_KEY")).cloned();
+        assert_eq!(api_key.as_deref(), Some("secret"));
+    }
+
+    #[test]
+    fn test_to_mcp_server_config_reject_non_stdio() {
+        for t in ["http", "sse", "HTTP", "SSe"] {
+            let entry = McpTomlEntry {
+                r#type: Some(t.to_string()),
+                command: Some("tool".to_string()),
+                ..Default::default()
+            };
+            let msg = match to_mcp_server_config(&entry, |_k| None) {
+                Ok(v) => panic!("expected error, got {v:?}"),
+                Err(e) => format!("{e:#}"),
+            };
+            assert!(msg.to_lowercase().contains("unsupported mcp transport"));
+        }
+    }
+
+    #[test]
+    fn test_to_mcp_server_config_missing_command_errors() {
+        let entry = McpTomlEntry {
+            command: None,
+            ..Default::default()
+        };
+        let msg = match to_mcp_server_config(&entry, |_k| None) {
+            Ok(v) => panic!("expected error, got {v:?}"),
+            Err(e) => format!("{e:#}"),
+        };
+        assert!(msg.contains("missing `command`"));
+    }
+
+    #[test]
+    fn test_to_mcp_server_config_missing_env_var_errors() {
+        let entry = McpTomlEntry {
+            command: Some("tool".into()),
+            args: vec!["${REQUIRED}".into()],
+            ..Default::default()
+        };
+        let msg = match to_mcp_server_config(&entry, |_k| None) {
+            Ok(v) => panic!("expected error, got {v:?}"),
+            Err(e) => format!("{e:#}"),
+        };
+        assert!(msg.contains("environment variable `REQUIRED` not set"));
+    }
+}
+
+// -------------------------------
+// Overlay loader
+// -------------------------------
+
+/// Load `.mcp.local.toml` and `.mcp.toml` from `project_root` if they exist.
+///
+/// Returns the successfully parsed overlays in precedence order: Local then Project.
+/// Invalid TOML is logged and skipped.
+pub fn load_project_overlays(project_root: &Path) -> Result<Vec<(Scope, McpToml)>> {
+    let mut overlays = Vec::new();
+
+    let local_path = project_root.join(".mcp.local.toml");
+    if local_path.exists() {
+        match std::fs::read_to_string(&local_path) {
+            Ok(contents) => match toml::from_str::<McpToml>(&contents) {
+                Ok(parsed) => overlays.push((Scope::Local, parsed)),
+                Err(e) => tracing::warn!("Failed to parse {}: {e}", local_path.display()),
+            },
+            Err(e) => tracing::warn!("Failed to read {}: {e}", local_path.display()),
+        }
+    }
+
+    let project_path = project_root.join(".mcp.toml");
+    if project_path.exists() {
+        match std::fs::read_to_string(&project_path) {
+            Ok(contents) => match toml::from_str::<McpToml>(&contents) {
+                Ok(parsed) => overlays.push((Scope::Project, parsed)),
+                Err(e) => tracing::warn!("Failed to parse {}: {e}", project_path.display()),
+            },
+            Err(e) => tracing::warn!("Failed to read {}: {e}", project_path.display()),
+        }
+    }
+
+    Ok(overlays)
+}
+
+#[cfg(test)]
+mod overlay_tests {
+    use super::*;
+    use std::fs;
+
+    #[test]
+    fn test_load_project_overlays_reads_both_files() -> Result<()> {
+        let dir = tempfile::tempdir()?;
+        let root = dir.path();
+        // Pretend it's a git repo to mirror typical layout; not required by loader.
+        fs::write(root.join(".git"), "gitdir: nowhere")?;
+
+        // Write project overlay
+        fs::write(
+            root.join(".mcp.toml"),
+            r#"[mcp_servers.alpha]
+command = "alpha"
+"#,
+        )?;
+
+        // Write local overlay
+        fs::write(
+            root.join(".mcp.local.toml"),
+            r#"[mcp_servers.beta]
+command = "beta"
+"#,
+        )?;
+
+        let overlays = load_project_overlays(root)?;
+        assert_eq!(overlays.len(), 2);
+
+        // Expect Local first, then Project (our precedence order for merging later)
+        assert!(matches!(overlays[0].0, Scope::Local));
+        assert!(overlays[0].1.mcp_servers.contains_key("beta"));
+        assert!(matches!(overlays[1].0, Scope::Project));
+        assert!(overlays[1].1.mcp_servers.contains_key("alpha"));
+        Ok(())
+    }
+}

codex-rs/core/src/message_history.rs

@@ -105,34 +105,47 @@ pub(crate) async fn append_entry(text: &str, session_id: &Uuid, config: &Config)
     // Ensure permissions.
     ensure_owner_only_permissions(&history_file).await?;
 
-    // Perform a blocking write under an advisory write lock using std::fs.
-    tokio::task::spawn_blocking(move || -> Result<()> {
-        // Retry a few times to avoid indefinite blocking when contended.
-        for _ in 0..MAX_RETRIES {
-            match history_file.try_lock() {
-                Ok(()) => {
-                    // While holding the exclusive lock, write the full line.
-                    history_file.write_all(line.as_bytes())?;
-                    history_file.flush()?;
-                    return Ok(());
-                }
-                Err(std::fs::TryLockError::WouldBlock) => {
-                    std::thread::sleep(RETRY_SLEEP);
-                }
-                Err(e) => return Err(e.into()),
-            }
-        }
+    // Lock file.
+    acquire_exclusive_lock_with_retry(&history_file).await?;
 
-        Err(std::io::Error::new(
-            std::io::ErrorKind::WouldBlock,
-            "could not acquire exclusive lock on history file after multiple attempts",
-        ))
+    // We use sync I/O with spawn_blocking() because we are using a
+    // [`std::fs::File`] instead of a [`tokio::fs::File`] to leverage an
+    // advisory file locking API that is not available in the async API.
+    tokio::task::spawn_blocking(move || -> Result<()> {
+        history_file.write_all(line.as_bytes())?;
+        history_file.flush()?;
+        Ok(())
     })
     .await??;
 
     Ok(())
 }
 
+/// Attempt to acquire an exclusive advisory lock on `file`, retrying up to 10
+/// times if the lock is currently held by another process. This prevents a
+/// potential indefinite wait while still giving other writers some time to
+/// finish their operation.
+async fn acquire_exclusive_lock_with_retry(file: &File) -> Result<()> {
+    use tokio::time::sleep;
+
+    for _ in 0..MAX_RETRIES {
+        match file.try_lock() {
+            Ok(()) => return Ok(()),
+            Err(e) => match e {
+                std::fs::TryLockError::WouldBlock => {
+                    sleep(RETRY_SLEEP).await;
+                }
+                other => return Err(other.into()),
+            },
+        }
+    }
+
+    Err(std::io::Error::new(
+        std::io::ErrorKind::WouldBlock,
+        "could not acquire exclusive lock on history file after multiple attempts",
+    ))
+}
+
 /// Asynchronously fetch the history file's *identifier* (inode on Unix) and
 /// the current number of entries by counting newline characters.
 pub(crate) async fn history_metadata(config: &Config) -> (u64, usize) {
@@ -208,43 +221,30 @@ pub(crate) fn lookup(log_id: u64, offset: usize, config: &Config) -> Option<Hist
         return None;
     }
 
-    // Open & lock file for reading using a shared lock.
-    // Retry a few times to avoid indefinite blocking.
-    for _ in 0..MAX_RETRIES {
-        let lock_result = file.try_lock_shared();
+    // Open & lock file for reading.
+    if let Err(e) = acquire_shared_lock_with_retry(&file) {
+        tracing::warn!(error = %e, "failed to acquire shared lock on history file");
+        return None;
+    }
 
-        match lock_result {
-            Ok(()) => {
-                let reader = BufReader::new(&file);
-                for (idx, line_res) in reader.lines().enumerate() {
-                    let line = match line_res {
-                        Ok(l) => l,
-                        Err(e) => {
-                            tracing::warn!(error = %e, "failed to read line from history file");
-                            return None;
-                        }
-                    };
-
-                    if idx == offset {
-                        match serde_json::from_str::<HistoryEntry>(&line) {
-                            Ok(entry) => return Some(entry),
-                            Err(e) => {
-                                tracing::warn!(error = %e, "failed to parse history entry");
-                                return None;
-                            }
-                        }
-                    }
-                }
-                // Not found at requested offset.
-                return None;
-            }
-            Err(std::fs::TryLockError::WouldBlock) => {
-                std::thread::sleep(RETRY_SLEEP);
-            }
+    let reader = BufReader::new(&file);
+    for (idx, line_res) in reader.lines().enumerate() {
+        let line = match line_res {
+            Ok(l) => l,
             Err(e) => {
-                tracing::warn!(error = %e, "failed to acquire shared lock on history file");
+                tracing::warn!(error = %e, "failed to read line from history file");
                 return None;
             }
+        };
+
+        if idx == offset {
+            match serde_json::from_str::<HistoryEntry>(&line) {
+                Ok(entry) => return Some(entry),
+                Err(e) => {
+                    tracing::warn!(error = %e, "failed to parse history entry");
+                    return None;
+                }
+            }
         }
     }
 
@@ -258,6 +258,26 @@ pub(crate) fn lookup(log_id: u64, offset: usize, config: &Config) -> Option<Hist
     None
 }
 
+#[cfg(unix)]
+fn acquire_shared_lock_with_retry(file: &File) -> Result<()> {
+    for _ in 0..MAX_RETRIES {
+        match file.try_lock_shared() {
+            Ok(()) => return Ok(()),
+            Err(e) => match e {
+                std::fs::TryLockError::WouldBlock => {
+                    std::thread::sleep(RETRY_SLEEP);
+                }
+                other => return Err(other.into()),
+            },
+        }
+    }
+
+    Err(std::io::Error::new(
+        std::io::ErrorKind::WouldBlock,
+        "could not acquire shared lock on history file after multiple attempts",
+    ))
+}
+
 /// On Unix systems ensure the file permissions are `0o600` (rw-------). If the
 /// permissions cannot be changed the error is propagated to the caller.
 #[cfg(unix)]

codex-rs/core/src/model_provider_info.rs

@@ -5,8 +5,8 @@
 //!   2. User-defined entries inside `~/.codex/config.toml` under the `model_providers`
 //!      key. These override or extend the defaults at runtime.
 
-use crate::CodexAuth;
-use codex_protocol::mcp_protocol::AuthMode;
+use codex_login::AuthMode;
+use codex_login::CodexAuth;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;

codex-rs/core/src/openai_tools.rs

@@ -47,8 +47,6 @@ pub(crate) enum OpenAiTool {
     Function(ResponsesApiTool),
     #[serde(rename = "local_shell")]
     LocalShell {},
-    // TODO: Understand why we get an error on web_search although the API docs say it's supported.
-    // https://platform.openai.com/docs/guides/tools-web-search?api-mode=responses#:~:text=%7B%20type%3A%20%22web_search%22%20%7D%2C
     #[serde(rename = "web_search")]
     WebSearch {},
     #[serde(rename = "custom")]
@@ -69,7 +67,6 @@ pub(crate) struct ToolsConfig {
     pub plan_tool: bool,
     pub apply_patch_tool_type: Option<ApplyPatchToolType>,
     pub web_search_request: bool,
-    pub include_view_image_tool: bool,
 }
 
 pub(crate) struct ToolsConfigParams<'a> {
@@ -80,7 +77,6 @@ pub(crate) struct ToolsConfigParams<'a> {
     pub(crate) include_apply_patch_tool: bool,
     pub(crate) include_web_search_request: bool,
     pub(crate) use_streamable_shell_tool: bool,
-    pub(crate) include_view_image_tool: bool,
 }
 
 impl ToolsConfig {
@@ -93,7 +89,6 @@ impl ToolsConfig {
             include_apply_patch_tool,
             include_web_search_request,
             use_streamable_shell_tool,
-            include_view_image_tool,
         } = params;
         let mut shell_type = if *use_streamable_shell_tool {
             ConfigShellToolType::StreamableShell
@@ -125,7 +120,6 @@ impl ToolsConfig {
             plan_tool: *include_plan_tool,
             apply_patch_tool_type,
             web_search_request: *include_web_search_request,
-            include_view_image_tool: *include_view_image_tool,
         }
     }
 }
@@ -298,30 +292,6 @@ The shell tool is used to execute shell commands.
         },
     })
 }
-
-fn create_view_image_tool() -> OpenAiTool {
-    // Support only local filesystem path.
-    let mut properties = BTreeMap::new();
-    properties.insert(
-        "path".to_string(),
-        JsonSchema::String {
-            description: Some("Local filesystem path to an image file".to_string()),
-        },
-    );
-
-    OpenAiTool::Function(ResponsesApiTool {
-        name: "view_image".to_string(),
-        description:
-            "Attach a local image (by filesystem path) to the conversation context for this turn."
-                .to_string(),
-        strict: false,
-        parameters: JsonSchema::Object {
-            properties,
-            required: Some(vec!["path".to_string()]),
-            additional_properties: Some(false),
-        },
-    })
-}
 /// TODO(dylan): deprecate once we get rid of json tool
 #[derive(Serialize, Deserialize)]
 pub(crate) struct ApplyPatchToolArgs {
@@ -337,12 +307,12 @@ pub fn create_tools_json_for_responses_api(
     let mut tools_json = Vec::new();
 
     for tool in tools {
-        let json = serde_json::to_value(tool)?;
-        tools_json.push(json);
+        tools_json.push(serde_json::to_value(tool)?);
     }
 
     Ok(tools_json)
 }
+
 /// Returns JSON values that are compatible with Function Calling in the
 /// Chat Completions API:
 /// https://platform.openai.com/docs/guides/function-calling?api-mode=chat
@@ -571,11 +541,6 @@ pub(crate) fn get_openai_tools(
         tools.push(OpenAiTool::WebSearch {});
     }
 
-    // Include the view_image tool so the agent can attach images to context.
-    if config.include_view_image_tool {
-        tools.push(create_view_image_tool());
-    }
-
     if let Some(mcp_tools) = mcp_tools {
         // Ensure deterministic ordering to maximize prompt cache hits.
         // HashMap iteration order is non-deterministic, so sort by fully-qualified tool name.
@@ -639,14 +604,10 @@ mod tests {
             include_apply_patch_tool: false,
             include_web_search_request: true,
             use_streamable_shell_tool: false,
-            include_view_image_tool: true,
         });
         let tools = get_openai_tools(&config, Some(HashMap::new()));
 
-        assert_eq_tool_names(
-            &tools,
-            &["local_shell", "update_plan", "web_search", "view_image"],
-        );
+        assert_eq_tool_names(&tools, &["local_shell", "update_plan", "web_search"]);
     }
 
     #[test]
@@ -660,14 +621,10 @@ mod tests {
             include_apply_patch_tool: false,
             include_web_search_request: true,
             use_streamable_shell_tool: false,
-            include_view_image_tool: true,
         });
         let tools = get_openai_tools(&config, Some(HashMap::new()));
 
-        assert_eq_tool_names(
-            &tools,
-            &["shell", "update_plan", "web_search", "view_image"],
-        );
+        assert_eq_tool_names(&tools, &["shell", "update_plan", "web_search"]);
     }
 
     #[test]
@@ -681,7 +638,6 @@ mod tests {
             include_apply_patch_tool: false,
             include_web_search_request: true,
             use_streamable_shell_tool: false,
-            include_view_image_tool: true,
         });
         let tools = get_openai_tools(
             &config,
@@ -704,8 +660,8 @@ mod tests {
                                     "number_property": { "type": "number" },
                                 },
                                 "required": [
-                                    "string_property",
-                                    "number_property",
+                                    "string_property".to_string(),
+                                    "number_property".to_string()
                                 ],
                                 "additionalProperties": Some(false),
                             },
@@ -723,16 +679,11 @@ mod tests {
 
         assert_eq_tool_names(
             &tools,
-            &[
-                "shell",
-                "web_search",
-                "view_image",
-                "test_server/do_something_cool",
-            ],
+            &["shell", "web_search", "test_server/do_something_cool"],
         );
 
         assert_eq!(
-            tools[3],
+            tools[2],
             OpenAiTool::Function(ResponsesApiTool {
                 name: "test_server/do_something_cool".to_string(),
                 parameters: JsonSchema::Object {
@@ -786,7 +737,6 @@ mod tests {
             include_apply_patch_tool: false,
             include_web_search_request: false,
             use_streamable_shell_tool: false,
-            include_view_image_tool: true,
         });
 
         // Intentionally construct a map with keys that would sort alphabetically.
@@ -844,7 +794,6 @@ mod tests {
             &tools,
             &[
                 "shell",
-                "view_image",
                 "test_server/cool",
                 "test_server/do",
                 "test_server/something",
@@ -863,7 +812,6 @@ mod tests {
             include_apply_patch_tool: false,
             include_web_search_request: true,
             use_streamable_shell_tool: false,
-            include_view_image_tool: true,
         });
 
         let tools = get_openai_tools(
@@ -889,13 +837,10 @@ mod tests {
             )])),
         );
 
-        assert_eq_tool_names(
-            &tools,
-            &["shell", "web_search", "view_image", "dash/search"],
-        );
+        assert_eq_tool_names(&tools, &["shell", "web_search", "dash/search"]);
 
         assert_eq!(
-            tools[3],
+            tools[2],
             OpenAiTool::Function(ResponsesApiTool {
                 name: "dash/search".to_string(),
                 parameters: JsonSchema::Object {
@@ -925,7 +870,6 @@ mod tests {
             include_apply_patch_tool: false,
             include_web_search_request: true,
             use_streamable_shell_tool: false,
-            include_view_image_tool: true,
         });
 
         let tools = get_openai_tools(
@@ -949,12 +893,9 @@ mod tests {
             )])),
         );
 
-        assert_eq_tool_names(
-            &tools,
-            &["shell", "web_search", "view_image", "dash/paginate"],
-        );
+        assert_eq_tool_names(&tools, &["shell", "web_search", "dash/paginate"]);
         assert_eq!(
-            tools[3],
+            tools[2],
             OpenAiTool::Function(ResponsesApiTool {
                 name: "dash/paginate".to_string(),
                 parameters: JsonSchema::Object {
@@ -982,7 +923,6 @@ mod tests {
             include_apply_patch_tool: false,
             include_web_search_request: true,
             use_streamable_shell_tool: false,
-            include_view_image_tool: true,
         });
 
         let tools = get_openai_tools(
@@ -1006,9 +946,9 @@ mod tests {
             )])),
         );
 
-        assert_eq_tool_names(&tools, &["shell", "web_search", "view_image", "dash/tags"]);
+        assert_eq_tool_names(&tools, &["shell", "web_search", "dash/tags"]);
         assert_eq!(
-            tools[3],
+            tools[2],
             OpenAiTool::Function(ResponsesApiTool {
                 name: "dash/tags".to_string(),
                 parameters: JsonSchema::Object {
@@ -1039,7 +979,6 @@ mod tests {
             include_apply_patch_tool: false,
             include_web_search_request: true,
             use_streamable_shell_tool: false,
-            include_view_image_tool: true,
         });
 
         let tools = get_openai_tools(
@@ -1063,9 +1002,9 @@ mod tests {
             )])),
         );
 
-        assert_eq_tool_names(&tools, &["shell", "web_search", "view_image", "dash/value"]);
+        assert_eq_tool_names(&tools, &["shell", "web_search", "dash/value"]);
         assert_eq!(
-            tools[3],
+            tools[2],
             OpenAiTool::Function(ResponsesApiTool {
                 name: "dash/value".to_string(),
                 parameters: JsonSchema::Object {

codex-rs/core/src/parse_command.rs

@@ -20,6 +20,22 @@ pub enum ParsedCommand {
         query: Option<String>,
         path: Option<String>,
     },
+    Format {
+        cmd: String,
+        tool: Option<String>,
+        targets: Option<Vec<String>>,
+    },
+    Test {
+        cmd: String,
+    },
+    Lint {
+        cmd: String,
+        tool: Option<String>,
+        targets: Option<Vec<String>>,
+    },
+    Noop {
+        cmd: String,
+    },
     Unknown {
         cmd: String,
     },
@@ -34,6 +50,10 @@ impl From<ParsedCommand> for codex_protocol::parse_command::ParsedCommand {
             ParsedCommand::Read { cmd, name } => P::Read { cmd, name },
             ParsedCommand::ListFiles { cmd, path } => P::ListFiles { cmd, path },
             ParsedCommand::Search { cmd, query, path } => P::Search { cmd, query, path },
+            ParsedCommand::Format { cmd, tool, targets } => P::Format { cmd, tool, targets },
+            ParsedCommand::Test { cmd } => P::Test { cmd },
+            ParsedCommand::Lint { cmd, tool, targets } => P::Lint { cmd, tool, targets },
+            ParsedCommand::Noop { cmd } => P::Noop { cmd },
             ParsedCommand::Unknown { cmd } => P::Unknown { cmd },
         }
     }
@@ -102,7 +122,7 @@ mod tests {
         assert_parsed(
             &vec_str(&["bash", "-lc", inner]),
             vec![ParsedCommand::Unknown {
-                cmd: "git status".to_string(),
+                cmd: "git status | wc -l".to_string(),
             }],
         );
     }
@@ -224,39 +244,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn cd_then_cat_is_single_read() {
-        assert_parsed(
-            &shlex_split_safe("cd foo && cat foo.txt"),
-            vec![ParsedCommand::Read {
-                cmd: "cat foo.txt".to_string(),
-                name: "foo.txt".to_string(),
-            }],
-        );
-    }
-
-    #[test]
-    fn bash_cd_then_bar_is_same_as_bar() {
-        // Ensure a leading `cd` inside bash -lc is dropped when followed by another command.
-        assert_parsed(
-            &shlex_split_safe("bash -lc 'cd foo && bar'"),
-            vec![ParsedCommand::Unknown {
-                cmd: "bar".to_string(),
-            }],
-        );
-    }
-
-    #[test]
-    fn bash_cd_then_cat_is_read() {
-        assert_parsed(
-            &shlex_split_safe("bash -lc 'cd foo && cat foo.txt'"),
-            vec![ParsedCommand::Read {
-                cmd: "cat foo.txt".to_string(),
-                name: "foo.txt".to_string(),
-            }],
-        );
-    }
-
     #[test]
     fn supports_ls_with_pipe() {
         let inner = "ls -la | sed -n '1,120p'";
@@ -328,6 +315,27 @@ mod tests {
         );
     }
 
+    #[test]
+    fn supports_npm_run_with_forwarded_args() {
+        assert_parsed(
+            &vec_str(&[
+                "npm",
+                "run",
+                "lint",
+                "--",
+                "--max-warnings",
+                "0",
+                "--format",
+                "json",
+            ]),
+            vec![ParsedCommand::Lint {
+                cmd: "npm run lint -- --max-warnings 0 --format json".to_string(),
+                tool: Some("npm-script:lint".to_string()),
+                targets: None,
+            }],
+        );
+    }
+
     #[test]
     fn supports_grep_recursive_current_dir() {
         assert_parsed(
@@ -388,10 +396,173 @@ mod tests {
     fn supports_cd_and_rg_files() {
         assert_parsed(
             &shlex_split_safe("cd codex-rs && rg --files"),
-            vec![ParsedCommand::Search {
-                cmd: "rg --files".to_string(),
-                query: None,
-                path: None,
+            vec![
+                ParsedCommand::Unknown {
+                    cmd: "cd codex-rs".to_string(),
+                },
+                ParsedCommand::Search {
+                    cmd: "rg --files".to_string(),
+                    query: None,
+                    path: None,
+                },
+            ],
+        );
+    }
+
+    #[test]
+    fn echo_then_cargo_test_sequence() {
+        assert_parsed(
+            &shlex_split_safe("echo Running tests... && cargo test --all-features --quiet"),
+            vec![ParsedCommand::Test {
+                cmd: "cargo test --all-features --quiet".to_string(),
+            }],
+        );
+    }
+
+    #[test]
+    fn supports_cargo_fmt_and_test_with_config() {
+        assert_parsed(
+            &shlex_split_safe(
+                "cargo fmt -- --config imports_granularity=Item && cargo test -p core --all-features",
+            ),
+            vec![
+                ParsedCommand::Format {
+                    cmd: "cargo fmt -- --config 'imports_granularity=Item'".to_string(),
+                    tool: Some("cargo fmt".to_string()),
+                    targets: None,
+                },
+                ParsedCommand::Test {
+                    cmd: "cargo test -p core --all-features".to_string(),
+                },
+            ],
+        );
+    }
+
+    #[test]
+    fn recognizes_rustfmt_and_clippy() {
+        assert_parsed(
+            &shlex_split_safe("rustfmt src/main.rs"),
+            vec![ParsedCommand::Format {
+                cmd: "rustfmt src/main.rs".to_string(),
+                tool: Some("rustfmt".to_string()),
+                targets: Some(vec!["src/main.rs".to_string()]),
+            }],
+        );
+
+        assert_parsed(
+            &shlex_split_safe("cargo clippy -p core --all-features -- -D warnings"),
+            vec![ParsedCommand::Lint {
+                cmd: "cargo clippy -p core --all-features -- -D warnings".to_string(),
+                tool: Some("cargo clippy".to_string()),
+                targets: None,
+            }],
+        );
+    }
+
+    #[test]
+    fn recognizes_pytest_go_and_tools() {
+        assert_parsed(
+            &shlex_split_safe(
+                "pytest -k 'Login and not slow' tests/test_login.py::TestLogin::test_ok",
+            ),
+            vec![ParsedCommand::Test {
+                cmd: "pytest -k 'Login and not slow' tests/test_login.py::TestLogin::test_ok"
+                    .to_string(),
+            }],
+        );
+
+        assert_parsed(
+            &shlex_split_safe("go fmt ./..."),
+            vec![ParsedCommand::Format {
+                cmd: "go fmt ./...".to_string(),
+                tool: Some("go fmt".to_string()),
+                targets: Some(vec!["./...".to_string()]),
+            }],
+        );
+
+        assert_parsed(
+            &shlex_split_safe("go test ./pkg -run TestThing"),
+            vec![ParsedCommand::Test {
+                cmd: "go test ./pkg -run TestThing".to_string(),
+            }],
+        );
+
+        assert_parsed(
+            &shlex_split_safe("eslint . --max-warnings 0"),
+            vec![ParsedCommand::Lint {
+                cmd: "eslint . --max-warnings 0".to_string(),
+                tool: Some("eslint".to_string()),
+                targets: Some(vec![".".to_string()]),
+            }],
+        );
+
+        assert_parsed(
+            &shlex_split_safe("prettier -w ."),
+            vec![ParsedCommand::Format {
+                cmd: "prettier -w .".to_string(),
+                tool: Some("prettier".to_string()),
+                targets: Some(vec![".".to_string()]),
+            }],
+        );
+    }
+
+    #[test]
+    fn recognizes_jest_and_vitest_filters() {
+        assert_parsed(
+            &shlex_split_safe("jest -t 'should work' src/foo.test.ts"),
+            vec![ParsedCommand::Test {
+                cmd: "jest -t 'should work' src/foo.test.ts".to_string(),
+            }],
+        );
+
+        assert_parsed(
+            &shlex_split_safe("vitest -t 'runs' src/foo.test.tsx"),
+            vec![ParsedCommand::Test {
+                cmd: "vitest -t runs src/foo.test.tsx".to_string(),
+            }],
+        );
+    }
+
+    #[test]
+    fn recognizes_npx_and_scripts() {
+        assert_parsed(
+            &shlex_split_safe("npx eslint src"),
+            vec![ParsedCommand::Lint {
+                cmd: "npx eslint src".to_string(),
+                tool: Some("eslint".to_string()),
+                targets: Some(vec!["src".to_string()]),
+            }],
+        );
+
+        assert_parsed(
+            &shlex_split_safe("npx prettier -c ."),
+            vec![ParsedCommand::Format {
+                cmd: "npx prettier -c .".to_string(),
+                tool: Some("prettier".to_string()),
+                targets: Some(vec![".".to_string()]),
+            }],
+        );
+
+        assert_parsed(
+            &shlex_split_safe("pnpm run lint -- --max-warnings 0"),
+            vec![ParsedCommand::Lint {
+                cmd: "pnpm run lint -- --max-warnings 0".to_string(),
+                tool: Some("pnpm-script:lint".to_string()),
+                targets: None,
+            }],
+        );
+
+        assert_parsed(
+            &shlex_split_safe("npm test"),
+            vec![ParsedCommand::Test {
+                cmd: "npm test".to_string(),
+            }],
+        );
+
+        assert_parsed(
+            &shlex_split_safe("yarn test"),
+            vec![ParsedCommand::Test {
+                cmd: "yarn test".to_string(),
             }],
         );
     }
@@ -599,51 +770,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn parses_mixed_sequence_with_pipes_semicolons_and_or() {
-        // Provided long command sequence combining sequencing, pipelines, and ORs.
-        let inner = "pwd; ls -la; rg --files -g '!target' | wc -l; rg -n '^\\[workspace\\]' -n Cargo.toml || true; rg -n '^\\[package\\]' -n */Cargo.toml || true; cargo --version; rustc --version; cargo clippy --workspace --all-targets --all-features -q";
-        let args = vec_str(&["bash", "-lc", inner]);
-
-        let expected = vec![
-            ParsedCommand::Unknown {
-                cmd: "pwd".to_string(),
-            },
-            ParsedCommand::ListFiles {
-                cmd: shlex_join(&shlex_split_safe("ls -la")),
-                path: None,
-            },
-            ParsedCommand::Search {
-                cmd: shlex_join(&shlex_split_safe("rg --files -g '!target'")),
-                query: None,
-                path: Some("!target".to_string()),
-            },
-            ParsedCommand::Search {
-                cmd: shlex_join(&shlex_split_safe("rg -n '^\\[workspace\\]' -n Cargo.toml")),
-                query: Some("^\\[workspace\\]".to_string()),
-                path: Some("Cargo.toml".to_string()),
-            },
-            ParsedCommand::Search {
-                cmd: shlex_join(&shlex_split_safe("rg -n '^\\[package\\]' -n */Cargo.toml")),
-                query: Some("^\\[package\\]".to_string()),
-                path: Some("Cargo.toml".to_string()),
-            },
-            ParsedCommand::Unknown {
-                cmd: shlex_join(&shlex_split_safe("cargo --version")),
-            },
-            ParsedCommand::Unknown {
-                cmd: shlex_join(&shlex_split_safe("rustc --version")),
-            },
-            ParsedCommand::Unknown {
-                cmd: shlex_join(&shlex_split_safe(
-                    "cargo clippy --workspace --all-targets --all-features -q",
-                )),
-            },
-        ];
-
-        assert_parsed(&args, expected);
-    }
-
     #[test]
     fn strips_true_in_sequence() {
         // `true` should be dropped from parsed sequences
@@ -741,6 +867,159 @@ mod tests {
         );
     }
 
+    #[test]
+    fn pnpm_test_is_parsed_as_test() {
+        assert_parsed(
+            &shlex_split_safe("pnpm test"),
+            vec![ParsedCommand::Test {
+                cmd: "pnpm test".to_string(),
+            }],
+        );
+    }
+
+    #[test]
+    fn pnpm_exec_vitest_is_unknown() {
+        // From commands_combined: cd codex-cli && pnpm exec vitest run tests/... --threads=false --passWithNoTests
+        let inner = "cd codex-cli && pnpm exec vitest run tests/file-tag-utils.test.ts --threads=false --passWithNoTests";
+        assert_parsed(
+            &shlex_split_safe(inner),
+            vec![
+                ParsedCommand::Unknown {
+                    cmd: "cd codex-cli".to_string(),
+                },
+                ParsedCommand::Unknown {
+                    cmd: "pnpm exec vitest run tests/file-tag-utils.test.ts '--threads=false' --passWithNoTests".to_string(),
+                },
+            ],
+        );
+    }
+
+    #[test]
+    fn cargo_test_with_crate() {
+        assert_parsed(
+            &shlex_split_safe("cargo test -p codex-core parse_command::"),
+            vec![ParsedCommand::Test {
+                cmd: "cargo test -p codex-core parse_command::".to_string(),
+            }],
+        );
+    }
+
+    #[test]
+    fn cargo_test_with_crate_2() {
+        assert_parsed(
+            &shlex_split_safe(
+                "cd core && cargo test -q parse_command::tests::bash_dash_c_pipeline_parsing parse_command::tests::fd_file_finder_variants",
+            ),
+            vec![ParsedCommand::Test {
+                cmd: "cargo test -q parse_command::tests::bash_dash_c_pipeline_parsing parse_command::tests::fd_file_finder_variants".to_string(),
+            }],
+        );
+    }
+
+    #[test]
+    fn cargo_test_with_crate_3() {
+        assert_parsed(
+            &shlex_split_safe("cd core && cargo test -q parse_command::tests"),
+            vec![ParsedCommand::Test {
+                cmd: "cargo test -q parse_command::tests".to_string(),
+            }],
+        );
+    }
+
+    #[test]
+    fn cargo_test_with_crate_4() {
+        assert_parsed(
+            &shlex_split_safe("cd core && cargo test --all-features parse_command -- --nocapture"),
+            vec![ParsedCommand::Test {
+                cmd: "cargo test --all-features parse_command -- --nocapture".to_string(),
+            }],
+        );
+    }
+
+    // Additional coverage for other common tools/frameworks
+    #[test]
+    fn recognizes_black_and_ruff() {
+        // black formats Python code
+        assert_parsed(
+            &shlex_split_safe("black src"),
+            vec![ParsedCommand::Format {
+                cmd: "black src".to_string(),
+                tool: Some("black".to_string()),
+                targets: Some(vec!["src".to_string()]),
+            }],
+        );
+
+        // ruff check is a linter; ensure we collect targets
+        assert_parsed(
+            &shlex_split_safe("ruff check ."),
+            vec![ParsedCommand::Lint {
+                cmd: "ruff check .".to_string(),
+                tool: Some("ruff".to_string()),
+                targets: Some(vec![".".to_string()]),
+            }],
+        );
+
+        // ruff format is a formatter
+        assert_parsed(
+            &shlex_split_safe("ruff format pkg/"),
+            vec![ParsedCommand::Format {
+                cmd: "ruff format pkg/".to_string(),
+                tool: Some("ruff".to_string()),
+                targets: Some(vec!["pkg/".to_string()]),
+            }],
+        );
+    }
+
+    #[test]
+    fn recognizes_pnpm_monorepo_test_and_npm_format_script() {
+        // pnpm -r test in a monorepo should still parse as a test action
+        assert_parsed(
+            &shlex_split_safe("pnpm -r test"),
+            vec![ParsedCommand::Test {
+                cmd: "pnpm -r test".to_string(),
+            }],
+        );
+
+        // npm run format should be recognized as a format action
+        assert_parsed(
+            &shlex_split_safe("npm run format -- -w ."),
+            vec![ParsedCommand::Format {
+                cmd: "npm run format -- -w .".to_string(),
+                tool: Some("npm-script:format".to_string()),
+                targets: None,
+            }],
+        );
+    }
+
+    #[test]
+    fn yarn_test_is_parsed_as_test() {
+        assert_parsed(
+            &shlex_split_safe("yarn test"),
+            vec![ParsedCommand::Test {
+                cmd: "yarn test".to_string(),
+            }],
+        );
+    }
+
+    #[test]
+    fn pytest_file_only_and_go_run_regex() {
+        // pytest invoked with a file path should be captured as a filter
+        assert_parsed(
+            &shlex_split_safe("pytest tests/test_example.py"),
+            vec![ParsedCommand::Test {
+                cmd: "pytest tests/test_example.py".to_string(),
+            }],
+        );
+
+        // go test with -run regex should capture the filter
+        assert_parsed(
+            &shlex_split_safe("go test ./... -run '^TestFoo$'"),
+            vec![ParsedCommand::Test {
+                cmd: "go test ./... -run '^TestFoo$'".to_string(),
+            }],
+        );
+    }
+
     #[test]
     fn grep_with_query_and_path() {
         assert_parsed(
@@ -811,6 +1090,30 @@ mod tests {
         );
     }
 
+    #[test]
+    fn eslint_with_config_path_and_target() {
+        assert_parsed(
+            &shlex_split_safe("eslint -c .eslintrc.json src"),
+            vec![ParsedCommand::Lint {
+                cmd: "eslint -c .eslintrc.json src".to_string(),
+                tool: Some("eslint".to_string()),
+                targets: Some(vec!["src".to_string()]),
+            }],
+        );
+    }
+
+    #[test]
+    fn npx_eslint_with_config_path_and_target() {
+        assert_parsed(
+            &shlex_split_safe("npx eslint -c .eslintrc src"),
+            vec![ParsedCommand::Lint {
+                cmd: "npx eslint -c .eslintrc src".to_string(),
+                tool: Some("eslint".to_string()),
+                targets: Some(vec!["src".to_string()]),
+            }],
+        );
+    }
+
     #[test]
     fn fd_file_finder_variants() {
         assert_parsed(
@@ -899,13 +1202,16 @@ fn simplify_once(commands: &[ParsedCommand]) -> Option<Vec<ParsedCommand>> {
         return Some(commands[1..].to_vec());
     }
 
-    // cd foo && [any command] => [any command] (keep non-cd when a cd is followed by something)
+    // cd foo && [any Test command] => [any Test command]
     if let Some(idx) = commands.iter().position(|pc| match pc {
         ParsedCommand::Unknown { cmd } => {
             shlex_split(cmd).is_some_and(|t| t.first().map(|s| s.as_str()) == Some("cd"))
         }
         _ => false,
-    }) && commands.len() > idx + 1
+    }) && commands
+        .iter()
+        .skip(idx + 1)
+        .any(|pc| matches!(pc, ParsedCommand::Test { .. }))
     {
         let mut out = Vec::with_capacity(commands.len() - 1);
         out.extend_from_slice(&commands[..idx]);
@@ -914,10 +1220,10 @@ fn simplify_once(commands: &[ParsedCommand]) -> Option<Vec<ParsedCommand>> {
     }
 
     // cmd || true => cmd
-    if let Some(idx) = commands
-        .iter()
-        .position(|pc| matches!(pc, ParsedCommand::Unknown { cmd } if cmd == "true"))
-    {
+    if let Some(idx) = commands.iter().position(|pc| match pc {
+        ParsedCommand::Noop { cmd } => cmd == "true",
+        _ => false,
+    }) {
         let mut out = Vec::with_capacity(commands.len() - 1);
         out.extend_from_slice(&commands[..idx]);
         out.extend_from_slice(&commands[idx + 1..]);
@@ -1071,6 +1377,75 @@ fn skip_flag_values<'a>(args: &'a [String], flags_with_vals: &[&str]) -> Vec<&'a
     out
 }
 
+/// Common flags for ESLint that take a following value and should not be
+/// considered positional targets.
+const ESLINT_FLAGS_WITH_VALUES: &[&str] = &[
+    "-c",
+    "--config",
+    "--parser",
+    "--parser-options",
+    "--rulesdir",
+    "--plugin",
+    "--max-warnings",
+    "--format",
+];
+
+fn collect_non_flag_targets(args: &[String]) -> Option<Vec<String>> {
+    let mut targets = Vec::new();
+    let mut skip_next = false;
+    for (i, a) in args.iter().enumerate() {
+        if a == "--" {
+            break;
+        }
+        if skip_next {
+            skip_next = false;
+            continue;
+        }
+        if a == "-p"
+            || a == "--package"
+            || a == "--features"
+            || a == "-C"
+            || a == "--config"
+            || a == "--config-path"
+            || a == "--out-dir"
+            || a == "-o"
+            || a == "--run"
+            || a == "--max-warnings"
+            || a == "--format"
+        {
+            if i + 1 < args.len() {
+                skip_next = true;
+            }
+            continue;
+        }
+        if a.starts_with('-') {
+            continue;
+        }
+        targets.push(a.clone());
+    }
+    if targets.is_empty() {
+        None
+    } else {
+        Some(targets)
+    }
+}
+
+fn collect_non_flag_targets_with_flags(
+    args: &[String],
+    flags_with_vals: &[&str],
+) -> Option<Vec<String>> {
+    let targets: Vec<String> = skip_flag_values(args, flags_with_vals)
+        .into_iter()
+        .filter(|a| !a.starts_with('-'))
+        .cloned()
+        .collect();
+    if targets.is_empty() {
+        None
+    } else {
+        Some(targets)
+    }
+}
+
 fn is_pathish(s: &str) -> bool {
     s == "."
         || s == ".."
@@ -1139,6 +1514,47 @@ fn parse_find_query_and_path(tail: &[String]) -> (Option<String>, Option<String>
     (query, path)
 }
 
+fn classify_npm_like(tool: &str, tail: &[String], full_cmd: &[String]) -> Option<ParsedCommand> {
+    let mut r = tail;
+    if tool == "pnpm" && r.first().map(|s| s.as_str()) == Some("-r") {
+        r = &r[1..];
+    }
+    let mut script_name: Option<String> = None;
+    if r.first().map(|s| s.as_str()) == Some("run") {
+        script_name = r.get(1).cloned();
+    } else {
+        let is_test_cmd = (tool == "npm" && r.first().map(|s| s.as_str()) == Some("t"))
+            || ((tool == "npm" || tool == "pnpm" || tool == "yarn")
+                && r.first().map(|s| s.as_str()) == Some("test"));
+        if is_test_cmd {
+            script_name = Some("test".to_string());
+        }
+    }
+    if let Some(name) = script_name {
+        let lname = name.to_lowercase();
+        if lname == "test" || lname == "unit" || lname == "jest" || lname == "vitest" {
+            return Some(ParsedCommand::Test {
+                cmd: shlex_join(full_cmd),
+            });
+        }
+        if lname == "lint" || lname == "eslint" {
+            return Some(ParsedCommand::Lint {
+                cmd: shlex_join(full_cmd),
+                tool: Some(format!("{tool}-script:{name}")),
+                targets: None,
+            });
+        }
+        if lname == "format" || lname == "fmt" || lname == "prettier" {
+            return Some(ParsedCommand::Format {
+                cmd: shlex_join(full_cmd),
+                tool: Some(format!("{tool}-script:{name}")),
+                targets: None,
+            });
+        }
+    }
+    None
+}
+
 fn parse_bash_lc_commands(original: &[String]) -> Option<Vec<ParsedCommand>> {
     let [bash, flag, script] = original else {
         return None;
@@ -1170,11 +1586,7 @@ fn parse_bash_lc_commands(original: &[String]) -> Option<Vec<ParsedCommand>> {
             .map(|tokens| summarize_main_tokens(&tokens))
             .collect();
         if commands.len() > 1 {
-            commands.retain(|pc| !matches!(pc, ParsedCommand::Unknown { cmd } if cmd == "true"));
-            // Apply the same simplifications used for non-bash parsing, e.g., drop leading `cd`.
-            while let Some(next) = simplify_once(&commands) {
-                commands = next;
-            }
+            commands.retain(|pc| !matches!(pc, ParsedCommand::Noop { .. }));
         }
         if commands.len() == 1 {
             // If we reduced to a single command, attribute the full original script
@@ -1243,7 +1655,27 @@ fn parse_bash_lc_commands(original: &[String]) -> Option<Vec<ParsedCommand>> {
                             }
                         }
                     }
-                    other => other,
+                    ParsedCommand::Format {
+                        tool, targets, cmd, ..
+                    } => ParsedCommand::Format {
+                        cmd: cmd.clone(),
+                        tool,
+                        targets,
+                    },
+                    ParsedCommand::Test { cmd, .. } => ParsedCommand::Test { cmd: cmd.clone() },
+                    ParsedCommand::Lint {
+                        tool, targets, cmd, ..
+                    } => ParsedCommand::Lint {
+                        cmd: cmd.clone(),
+                        tool,
+                        targets,
+                    },
+                    ParsedCommand::Unknown { .. } => ParsedCommand::Unknown {
+                        cmd: script.clone(),
+                    },
+                    ParsedCommand::Noop { .. } => ParsedCommand::Noop {
+                        cmd: script.clone(),
+                    },
                 })
                 .collect();
         }
@@ -1296,6 +1728,124 @@ fn drop_small_formatting_commands(mut commands: Vec<Vec<String>>) -> Vec<Vec<Str
 
 fn summarize_main_tokens(main_cmd: &[String]) -> ParsedCommand {
     match main_cmd.split_first() {
+        Some((head, tail)) if head == "true" && tail.is_empty() => ParsedCommand::Noop {
+            cmd: shlex_join(main_cmd),
+        },
+        // (sed-specific logic handled below in dedicated arm returning Read)
+        Some((head, tail))
+            if head == "cargo" && tail.first().map(|s| s.as_str()) == Some("fmt") =>
+        {
+            ParsedCommand::Format {
+                cmd: shlex_join(main_cmd),
+                tool: Some("cargo fmt".to_string()),
+                targets: collect_non_flag_targets(&tail[1..]),
+            }
+        }
+        Some((head, tail))
+            if head == "cargo" && tail.first().map(|s| s.as_str()) == Some("clippy") =>
+        {
+            ParsedCommand::Lint {
+                cmd: shlex_join(main_cmd),
+                tool: Some("cargo clippy".to_string()),
+                targets: collect_non_flag_targets(&tail[1..]),
+            }
+        }
+        Some((head, tail))
+            if head == "cargo" && tail.first().map(|s| s.as_str()) == Some("test") =>
+        {
+            ParsedCommand::Test {
+                cmd: shlex_join(main_cmd),
+            }
+        }
+        Some((head, tail)) if head == "rustfmt" => ParsedCommand::Format {
+            cmd: shlex_join(main_cmd),
+            tool: Some("rustfmt".to_string()),
+            targets: collect_non_flag_targets(tail),
+        },
+        Some((head, tail)) if head == "go" && tail.first().map(|s| s.as_str()) == Some("fmt") => {
+            ParsedCommand::Format {
+                cmd: shlex_join(main_cmd),
+                tool: Some("go fmt".to_string()),
+                targets: collect_non_flag_targets(&tail[1..]),
+            }
+        }
+        Some((head, tail)) if head == "go" && tail.first().map(|s| s.as_str()) == Some("test") => {
+            ParsedCommand::Test {
+                cmd: shlex_join(main_cmd),
+            }
+        }
+        Some((head, _)) if head == "pytest" => ParsedCommand::Test {
+            cmd: shlex_join(main_cmd),
+        },
+        Some((head, tail)) if head == "eslint" => {
+            // Treat configuration flags with values (e.g. `-c .eslintrc`) as non-targets.
+            let targets = collect_non_flag_targets_with_flags(tail, ESLINT_FLAGS_WITH_VALUES);
+            ParsedCommand::Lint {
+                cmd: shlex_join(main_cmd),
+                tool: Some("eslint".to_string()),
+                targets,
+            }
+        }
+        Some((head, tail)) if head == "prettier" => ParsedCommand::Format {
+            cmd: shlex_join(main_cmd),
+            tool: Some("prettier".to_string()),
+            targets: collect_non_flag_targets(tail),
+        },
+        Some((head, tail)) if head == "black" => ParsedCommand::Format {
+            cmd: shlex_join(main_cmd),
+            tool: Some("black".to_string()),
+            targets: collect_non_flag_targets(tail),
+        },
+        Some((head, tail))
+            if head == "ruff" && tail.first().map(|s| s.as_str()) == Some("check") =>
+        {
+            ParsedCommand::Lint {
+                cmd: shlex_join(main_cmd),
+                tool: Some("ruff".to_string()),
+                targets: collect_non_flag_targets(&tail[1..]),
+            }
+        }
+        Some((head, tail))
+            if head == "ruff" && tail.first().map(|s| s.as_str()) == Some("format") =>
+        {
+            ParsedCommand::Format {
+                cmd: shlex_join(main_cmd),
+                tool: Some("ruff".to_string()),
+                targets: collect_non_flag_targets(&tail[1..]),
+            }
+        }
+        Some((head, _)) if (head == "jest" || head == "vitest") => ParsedCommand::Test {
+            cmd: shlex_join(main_cmd),
+        },
+        Some((head, tail))
+            if head == "npx" && tail.first().map(|s| s.as_str()) == Some("eslint") =>
+        {
+            let targets = collect_non_flag_targets_with_flags(&tail[1..], ESLINT_FLAGS_WITH_VALUES);
+            ParsedCommand::Lint {
+                cmd: shlex_join(main_cmd),
+                tool: Some("eslint".to_string()),
+                targets,
+            }
+        }
+        Some((head, tail))
+            if head == "npx" && tail.first().map(|s| s.as_str()) == Some("prettier") =>
+        {
+            ParsedCommand::Format {
+                cmd: shlex_join(main_cmd),
+                tool: Some("prettier".to_string()),
+                targets: collect_non_flag_targets(&tail[1..]),
+            }
+        }
+        // NPM-like scripts including yarn
+        Some((tool, tail)) if (tool == "pnpm" || tool == "npm" || tool == "yarn") => {
+            if let Some(cmd) = classify_npm_like(tool, tail, main_cmd) {
+                cmd
+            } else {
+                ParsedCommand::Unknown {
+                    cmd: shlex_join(main_cmd),
+                }
+            }
+        }
         Some((head, tail)) if head == "ls" => {
             // Avoid treating option values as paths (e.g., ls -I "*.test.js").
             let candidates = skip_flag_values(

codex-rs/core/src/rollout.rs

@@ -19,16 +19,13 @@ use tracing::info;
 use tracing::warn;
 use uuid::Uuid;
 
-use super::SESSIONS_SUBDIR;
-use super::list::ConversationsPage;
-use super::list::Cursor;
-use super::list::get_conversations;
 use crate::config::Config;
-use crate::conversation_manager::InitialHistory;
 use crate::git_info::GitInfo;
 use crate::git_info::collect_git_info;
 use codex_protocol::models::ResponseItem;
 
+const SESSIONS_SUBDIR: &str = "sessions";
+
 #[derive(Serialize, Deserialize, Clone, Default)]
 pub struct SessionMeta {
     pub id: Uuid,
@@ -67,7 +64,7 @@ pub struct SavedSession {
 /// $ fx ~/.codex/sessions/rollout-2025-05-07T17-24-21-5973b6c0-94b8-487b-a530-2aeb6098ae0e.jsonl
 /// ```
 #[derive(Clone)]
-pub struct RolloutRecorder {
+pub(crate) struct RolloutRecorder {
     tx: Sender<RolloutCmd>,
 }
 
@@ -78,16 +75,6 @@ enum RolloutCmd {
 }
 
 impl RolloutRecorder {
-    #[allow(dead_code)]
-    /// List conversations (rollout files) under the provided Codex home directory.
-    pub async fn list_conversations(
-        codex_home: &Path,
-        page_size: usize,
-        cursor: Option<&Cursor>,
-    ) -> std::io::Result<ConversationsPage> {
-        get_conversations(codex_home, page_size, cursor).await
-    }
-
     /// Attempt to create a new [`RolloutRecorder`]. If the sessions directory
     /// cannot be created or the rollout file cannot be opened we return the
     /// error so the caller can decide whether to disable persistence.
@@ -148,7 +135,7 @@ impl RolloutRecorder {
                 | ResponseItem::CustomToolCall { .. }
                 | ResponseItem::CustomToolCallOutput { .. }
                 | ResponseItem::Reasoning { .. } => filtered.push(item.clone()),
-                ResponseItem::WebSearchCall { .. } | ResponseItem::Other => {
+                ResponseItem::Other => {
                     // These should never be serialized.
                     continue;
                 }
@@ -170,14 +157,20 @@ impl RolloutRecorder {
             .map_err(|e| IoError::other(format!("failed to queue rollout state: {e}")))
     }
 
-    pub async fn get_rollout_history(path: &Path) -> std::io::Result<InitialHistory> {
+    pub async fn resume(
+        path: &Path,
+        cwd: std::path::PathBuf,
+    ) -> std::io::Result<(Self, SavedSession)> {
         info!("Resuming rollout from {path:?}");
         let text = tokio::fs::read_to_string(path).await?;
         let mut lines = text.lines();
-        let _ = lines
+        let meta_line = lines
             .next()
             .ok_or_else(|| IoError::other("empty session file"))?;
+        let session: SessionMeta = serde_json::from_str(meta_line)
+            .map_err(|e| IoError::other(format!("failed to parse session meta: {e}")))?;
         let mut items = Vec::new();
+        let mut state = SessionStateSnapshot::default();
 
         for line in lines {
             if line.trim().is_empty() {
@@ -192,6 +185,9 @@ impl RolloutRecorder {
                 .map(|s| s == "state")
                 .unwrap_or(false)
             {
+                if let Ok(s) = serde_json::from_value::<SessionStateSnapshot>(v.clone()) {
+                    state = s
+                }
                 continue;
             }
             match serde_json::from_value::<ResponseItem>(v.clone()) {
@@ -203,7 +199,7 @@ impl RolloutRecorder {
                     | ResponseItem::CustomToolCall { .. }
                     | ResponseItem::CustomToolCallOutput { .. }
                     | ResponseItem::Reasoning { .. } => items.push(item),
-                    ResponseItem::WebSearchCall { .. } | ResponseItem::Other => {}
+                    ResponseItem::Other => {}
                 },
                 Err(e) => {
                     warn!("failed to parse item: {v:?}, error: {e}");
@@ -211,12 +207,27 @@ impl RolloutRecorder {
             }
         }
 
+        let saved = SavedSession {
+            session: session.clone(),
+            items: items.clone(),
+            state: state.clone(),
+            session_id: session.id,
+        };
+
+        let file = std::fs::OpenOptions::new()
+            .append(true)
+            .read(true)
+            .open(path)?;
+
+        let (tx, rx) = mpsc::channel::<RolloutCmd>(256);
+        tokio::task::spawn(rollout_writer(
+            tokio::fs::File::from_std(file),
+            rx,
+            None,
+            cwd,
+        ));
         info!("Resumed rollout successfully from {path:?}");
-        if items.is_empty() {
-            Ok(InitialHistory::New)
-        } else {
-            Ok(InitialHistory::Resumed(items))
-        }
+        Ok((Self { tx }, saved))
     }
 
     pub async fn shutdown(&self) -> std::io::Result<()> {
@@ -315,7 +326,7 @@ async fn rollout_writer(
                         | ResponseItem::Reasoning { .. } => {
                             writer.write_line(&item).await?;
                         }
-                        ResponseItem::WebSearchCall { .. } | ResponseItem::Other => {}
+                        ResponseItem::Other => {}
                     }
                 }
             }

codex-rs/core/src/rollout/list.rs

@@ -1,295 +0,0 @@
-use std::cmp::Reverse;
-use std::io::{self};
-use std::path::Path;
-use std::path::PathBuf;
-
-use time::OffsetDateTime;
-use time::PrimitiveDateTime;
-use time::format_description::FormatItem;
-use time::macros::format_description;
-use uuid::Uuid;
-
-use super::SESSIONS_SUBDIR;
-
-/// Returned page of conversation summaries.
-#[derive(Debug, Default, PartialEq)]
-pub struct ConversationsPage {
-    /// Conversation summaries ordered newest first.
-    pub items: Vec<ConversationItem>,
-    /// Opaque pagination token to resume after the last item, or `None` if end.
-    pub next_cursor: Option<Cursor>,
-    /// Total number of files touched while scanning this request.
-    pub num_scanned_files: usize,
-    /// True if a hard scan cap was hit; consider resuming with `next_cursor`.
-    pub reached_scan_cap: bool,
-}
-
-/// Summary information for a conversation rollout file.
-#[derive(Debug, PartialEq)]
-pub struct ConversationItem {
-    /// Absolute path to the rollout file.
-    pub path: PathBuf,
-    /// First up to 5 JSONL records parsed as JSON (includes meta line).
-    pub head: Vec<serde_json::Value>,
-}
-
-/// Hard cap to bound worst‑case work per request.
-const MAX_SCAN_FILES: usize = 50_000;
-
-/// Pagination cursor identifying a file by timestamp and UUID.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Cursor {
-    ts: OffsetDateTime,
-    id: Uuid,
-}
-
-impl Cursor {
-    fn new(ts: OffsetDateTime, id: Uuid) -> Self {
-        Self { ts, id }
-    }
-}
-
-impl serde::Serialize for Cursor {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let ts_str = self
-            .ts
-            .format(&format_description!(
-                "[year]-[month]-[day]T[hour]-[minute]-[second]"
-            ))
-            .map_err(|e| serde::ser::Error::custom(format!("format error: {e}")))?;
-        serializer.serialize_str(&format!("{ts_str}|{}", self.id))
-    }
-}
-
-impl<'de> serde::Deserialize<'de> for Cursor {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        parse_cursor(&s).ok_or_else(|| serde::de::Error::custom("invalid cursor"))
-    }
-}
-
-/// Retrieve recorded conversation file paths with token pagination. The returned `next_cursor`
-/// can be supplied on the next call to resume after the last returned item, resilient to
-/// concurrent new sessions being appended. Ordering is stable by timestamp desc, then UUID desc.
-pub(crate) async fn get_conversations(
-    codex_home: &Path,
-    page_size: usize,
-    cursor: Option<&Cursor>,
-) -> io::Result<ConversationsPage> {
-    let mut root = codex_home.to_path_buf();
-    root.push(SESSIONS_SUBDIR);
-
-    if !root.exists() {
-        return Ok(ConversationsPage {
-            items: Vec::new(),
-            next_cursor: None,
-            num_scanned_files: 0,
-            reached_scan_cap: false,
-        });
-    }
-
-    let anchor = cursor.cloned();
-
-    let result = traverse_directories_for_paths(root.clone(), page_size, anchor).await?;
-    Ok(result)
-}
-
-/// Load the full contents of a single conversation session file at `path`.
-/// Returns the entire file contents as a String.
-#[allow(dead_code)]
-pub(crate) async fn get_conversation(path: &Path) -> io::Result<String> {
-    tokio::fs::read_to_string(path).await
-}
-
-/// Load conversation file paths from disk using directory traversal.
-///
-/// Directory layout: `~/.codex/sessions/YYYY/MM/DD/rollout-YYYY-MM-DDThh-mm-ss-<uuid>.jsonl`
-/// Returned newest (latest) first.
-async fn traverse_directories_for_paths(
-    root: PathBuf,
-    page_size: usize,
-    anchor: Option<Cursor>,
-) -> io::Result<ConversationsPage> {
-    let mut items: Vec<ConversationItem> = Vec::with_capacity(page_size);
-    let mut scanned_files = 0usize;
-    let mut anchor_passed = anchor.is_none();
-    let (anchor_ts, anchor_id) = match anchor {
-        Some(c) => (c.ts, c.id),
-        None => (OffsetDateTime::UNIX_EPOCH, Uuid::nil()),
-    };
-
-    let year_dirs = collect_dirs_desc(&root, |s| s.parse::<u16>().ok()).await?;
-
-    'outer: for (_year, year_path) in year_dirs.iter() {
-        if scanned_files >= MAX_SCAN_FILES {
-            break;
-        }
-        let month_dirs = collect_dirs_desc(year_path, |s| s.parse::<u8>().ok()).await?;
-        for (_month, month_path) in month_dirs.iter() {
-            if scanned_files >= MAX_SCAN_FILES {
-                break 'outer;
-            }
-            let day_dirs = collect_dirs_desc(month_path, |s| s.parse::<u8>().ok()).await?;
-            for (_day, day_path) in day_dirs.iter() {
-                if scanned_files >= MAX_SCAN_FILES {
-                    break 'outer;
-                }
-                let mut day_files = collect_files(day_path, |name_str, path| {
-                    if !name_str.starts_with("rollout-") || !name_str.ends_with(".jsonl") {
-                        return None;
-                    }
-
-                    parse_timestamp_uuid_from_filename(name_str)
-                        .map(|(ts, id)| (ts, id, name_str.to_string(), path.to_path_buf()))
-                })
-                .await?;
-                // Stable ordering within the same second: (timestamp desc, uuid desc)
-                day_files.sort_by_key(|(ts, sid, _name_str, _path)| (Reverse(*ts), Reverse(*sid)));
-                for (ts, sid, _name_str, path) in day_files.into_iter() {
-                    scanned_files += 1;
-                    if scanned_files >= MAX_SCAN_FILES && items.len() >= page_size {
-                        break 'outer;
-                    }
-                    if !anchor_passed {
-                        if ts < anchor_ts || (ts == anchor_ts && sid < anchor_id) {
-                            anchor_passed = true;
-                        } else {
-                            continue;
-                        }
-                    }
-                    if items.len() == page_size {
-                        break 'outer;
-                    }
-                    let head = read_first_jsonl_records(&path, 5).await.unwrap_or_default();
-                    items.push(ConversationItem { path, head });
-                }
-            }
-        }
-    }
-
-    let next = build_next_cursor(&items);
-    Ok(ConversationsPage {
-        items,
-        next_cursor: next,
-        num_scanned_files: scanned_files,
-        reached_scan_cap: scanned_files >= MAX_SCAN_FILES,
-    })
-}
-
-/// Pagination cursor token format: "<file_ts>|<uuid>" where `file_ts` matches the
-/// filename timestamp portion (YYYY-MM-DDThh-mm-ss) used in rollout filenames.
-/// The cursor orders files by timestamp desc, then UUID desc.
-fn parse_cursor(token: &str) -> Option<Cursor> {
-    let (file_ts, uuid_str) = token.split_once('|')?;
-
-    let Ok(uuid) = Uuid::parse_str(uuid_str) else {
-        return None;
-    };
-
-    let format: &[FormatItem] =
-        format_description!("[year]-[month]-[day]T[hour]-[minute]-[second]");
-    let ts = PrimitiveDateTime::parse(file_ts, format).ok()?.assume_utc();
-
-    Some(Cursor::new(ts, uuid))
-}
-
-fn build_next_cursor(items: &[ConversationItem]) -> Option<Cursor> {
-    let last = items.last()?;
-    let file_name = last.path.file_name()?.to_string_lossy();
-    let (ts, id) = parse_timestamp_uuid_from_filename(&file_name)?;
-    Some(Cursor::new(ts, id))
-}
-
-/// Collects immediate subdirectories of `parent`, parses their (string) names with `parse`,
-/// and returns them sorted descending by the parsed key.
-async fn collect_dirs_desc<T, F>(parent: &Path, parse: F) -> io::Result<Vec<(T, PathBuf)>>
-where
-    T: Ord + Copy,
-    F: Fn(&str) -> Option<T>,
-{
-    let mut dir = tokio::fs::read_dir(parent).await?;
-    let mut vec: Vec<(T, PathBuf)> = Vec::new();
-    while let Some(entry) = dir.next_entry().await? {
-        if entry
-            .file_type()
-            .await
-            .map(|ft| ft.is_dir())
-            .unwrap_or(false)
-            && let Some(s) = entry.file_name().to_str()
-            && let Some(v) = parse(s)
-        {
-            vec.push((v, entry.path()));
-        }
-    }
-    vec.sort_by_key(|(v, _)| Reverse(*v));
-    Ok(vec)
-}
-
-/// Collects files in a directory and parses them with `parse`.
-async fn collect_files<T, F>(parent: &Path, parse: F) -> io::Result<Vec<T>>
-where
-    F: Fn(&str, &Path) -> Option<T>,
-{
-    let mut dir = tokio::fs::read_dir(parent).await?;
-    let mut collected: Vec<T> = Vec::new();
-    while let Some(entry) = dir.next_entry().await? {
-        if entry
-            .file_type()
-            .await
-            .map(|ft| ft.is_file())
-            .unwrap_or(false)
-            && let Some(s) = entry.file_name().to_str()
-            && let Some(v) = parse(s, &entry.path())
-        {
-            collected.push(v);
-        }
-    }
-    Ok(collected)
-}
-
-fn parse_timestamp_uuid_from_filename(name: &str) -> Option<(OffsetDateTime, Uuid)> {
-    // Expected: rollout-YYYY-MM-DDThh-mm-ss-<uuid>.jsonl
-    let core = name.strip_prefix("rollout-")?.strip_suffix(".jsonl")?;
-
-    // Scan from the right for a '-' such that the suffix parses as a UUID.
-    let (sep_idx, uuid) = core
-        .match_indices('-')
-        .rev()
-        .find_map(|(i, _)| Uuid::parse_str(&core[i + 1..]).ok().map(|u| (i, u)))?;
-
-    let ts_str = &core[..sep_idx];
-    let format: &[FormatItem] =
-        format_description!("[year]-[month]-[day]T[hour]-[minute]-[second]");
-    let ts = PrimitiveDateTime::parse(ts_str, format).ok()?.assume_utc();
-    Some((ts, uuid))
-}
-
-async fn read_first_jsonl_records(
-    path: &Path,
-    max_records: usize,
-) -> io::Result<Vec<serde_json::Value>> {
-    use tokio::io::AsyncBufReadExt;
-
-    let file = tokio::fs::File::open(path).await?;
-    let reader = tokio::io::BufReader::new(file);
-    let mut lines = reader.lines();
-    let mut head: Vec<serde_json::Value> = Vec::new();
-    while head.len() < max_records {
-        let line_opt = lines.next_line().await?;
-        let Some(line) = line_opt else { break };
-        let trimmed = line.trim();
-        if trimmed.is_empty() {
-            continue;
-        }
-        if let Ok(v) = serde_json::from_str::<serde_json::Value>(trimmed) {
-            head.push(v);
-        }
-    }
-    Ok(head)
-}

codex-rs/core/src/rollout/mod.rs

@@ -1,12 +0,0 @@
-//! Rollout module: persistence and discovery of session rollout files.
-
-pub(crate) const SESSIONS_SUBDIR: &str = "sessions";
-
-pub mod list;
-pub mod recorder;
-
-pub use recorder::RolloutRecorder;
-pub use recorder::SessionStateSnapshot;
-
-#[cfg(test)]
-pub mod tests;

codex-rs/core/src/rollout/tests.rs

@@ -1,384 +0,0 @@
-#![allow(clippy::unwrap_used, clippy::expect_used)]
-
-use std::fs::File;
-use std::fs::{self};
-use std::io::Write;
-use std::path::Path;
-
-use tempfile::TempDir;
-use time::OffsetDateTime;
-use time::PrimitiveDateTime;
-use time::format_description::FormatItem;
-use time::macros::format_description;
-use uuid::Uuid;
-
-use crate::rollout::list::ConversationItem;
-use crate::rollout::list::ConversationsPage;
-use crate::rollout::list::Cursor;
-use crate::rollout::list::get_conversation;
-use crate::rollout::list::get_conversations;
-
-fn write_session_file(
-    root: &Path,
-    ts_str: &str,
-    uuid: Uuid,
-    num_records: usize,
-) -> std::io::Result<(OffsetDateTime, Uuid)> {
-    let format: &[FormatItem] =
-        format_description!("[year]-[month]-[day]T[hour]-[minute]-[second]");
-    let dt = PrimitiveDateTime::parse(ts_str, format)
-        .unwrap()
-        .assume_utc();
-    let dir = root
-        .join("sessions")
-        .join(format!("{:04}", dt.year()))
-        .join(format!("{:02}", u8::from(dt.month())))
-        .join(format!("{:02}", dt.day()));
-    fs::create_dir_all(&dir)?;
-
-    let filename = format!("rollout-{ts_str}-{uuid}.jsonl");
-    let file_path = dir.join(filename);
-    let mut file = File::create(file_path)?;
-
-    let meta = serde_json::json!({
-        "timestamp": ts_str,
-        "id": uuid.to_string()
-    });
-    writeln!(file, "{meta}")?;
-
-    for i in 0..num_records {
-        let rec = serde_json::json!({
-            "record_type": "response",
-            "index": i
-        });
-        writeln!(file, "{rec}")?;
-    }
-    Ok((dt, uuid))
-}
-
-#[tokio::test]
-async fn test_list_conversations_latest_first() {
-    let temp = TempDir::new().unwrap();
-    let home = temp.path();
-
-    // Fixed UUIDs for deterministic expectations
-    let u1 = Uuid::from_u128(1);
-    let u2 = Uuid::from_u128(2);
-    let u3 = Uuid::from_u128(3);
-
-    // Create three sessions across three days
-    write_session_file(home, "2025-01-01T12-00-00", u1, 3).unwrap();
-    write_session_file(home, "2025-01-02T12-00-00", u2, 3).unwrap();
-    write_session_file(home, "2025-01-03T12-00-00", u3, 3).unwrap();
-
-    let page = get_conversations(home, 10, None).await.unwrap();
-
-    // Build expected objects
-    let p1 = home
-        .join("sessions")
-        .join("2025")
-        .join("01")
-        .join("03")
-        .join(format!("rollout-2025-01-03T12-00-00-{u3}.jsonl"));
-    let p2 = home
-        .join("sessions")
-        .join("2025")
-        .join("01")
-        .join("02")
-        .join(format!("rollout-2025-01-02T12-00-00-{u2}.jsonl"));
-    let p3 = home
-        .join("sessions")
-        .join("2025")
-        .join("01")
-        .join("01")
-        .join(format!("rollout-2025-01-01T12-00-00-{u1}.jsonl"));
-
-    let head_3 = vec![
-        serde_json::json!({"timestamp": "2025-01-03T12-00-00", "id": u3.to_string()}),
-        serde_json::json!({"record_type": "response", "index": 0}),
-        serde_json::json!({"record_type": "response", "index": 1}),
-        serde_json::json!({"record_type": "response", "index": 2}),
-    ];
-    let head_2 = vec![
-        serde_json::json!({"timestamp": "2025-01-02T12-00-00", "id": u2.to_string()}),
-        serde_json::json!({"record_type": "response", "index": 0}),
-        serde_json::json!({"record_type": "response", "index": 1}),
-        serde_json::json!({"record_type": "response", "index": 2}),
-    ];
-    let head_1 = vec![
-        serde_json::json!({"timestamp": "2025-01-01T12-00-00", "id": u1.to_string()}),
-        serde_json::json!({"record_type": "response", "index": 0}),
-        serde_json::json!({"record_type": "response", "index": 1}),
-        serde_json::json!({"record_type": "response", "index": 2}),
-    ];
-
-    let expected_cursor: Cursor =
-        serde_json::from_str(&format!("\"2025-01-01T12-00-00|{u1}\"")).unwrap();
-
-    let expected = ConversationsPage {
-        items: vec![
-            ConversationItem {
-                path: p1,
-                head: head_3,
-            },
-            ConversationItem {
-                path: p2,
-                head: head_2,
-            },
-            ConversationItem {
-                path: p3,
-                head: head_1,
-            },
-        ],
-        next_cursor: Some(expected_cursor),
-        num_scanned_files: 3,
-        reached_scan_cap: false,
-    };
-
-    assert_eq!(page, expected);
-}
-
-#[tokio::test]
-async fn test_pagination_cursor() {
-    let temp = TempDir::new().unwrap();
-    let home = temp.path();
-
-    // Fixed UUIDs for deterministic expectations
-    let u1 = Uuid::from_u128(11);
-    let u2 = Uuid::from_u128(22);
-    let u3 = Uuid::from_u128(33);
-    let u4 = Uuid::from_u128(44);
-    let u5 = Uuid::from_u128(55);
-
-    // Oldest to newest
-    write_session_file(home, "2025-03-01T09-00-00", u1, 1).unwrap();
-    write_session_file(home, "2025-03-02T09-00-00", u2, 1).unwrap();
-    write_session_file(home, "2025-03-03T09-00-00", u3, 1).unwrap();
-    write_session_file(home, "2025-03-04T09-00-00", u4, 1).unwrap();
-    write_session_file(home, "2025-03-05T09-00-00", u5, 1).unwrap();
-
-    let page1 = get_conversations(home, 2, None).await.unwrap();
-    let p5 = home
-        .join("sessions")
-        .join("2025")
-        .join("03")
-        .join("05")
-        .join(format!("rollout-2025-03-05T09-00-00-{u5}.jsonl"));
-    let p4 = home
-        .join("sessions")
-        .join("2025")
-        .join("03")
-        .join("04")
-        .join(format!("rollout-2025-03-04T09-00-00-{u4}.jsonl"));
-    let head_5 = vec![
-        serde_json::json!({"timestamp": "2025-03-05T09-00-00", "id": u5.to_string()}),
-        serde_json::json!({"record_type": "response", "index": 0}),
-    ];
-    let head_4 = vec![
-        serde_json::json!({"timestamp": "2025-03-04T09-00-00", "id": u4.to_string()}),
-        serde_json::json!({"record_type": "response", "index": 0}),
-    ];
-    let expected_cursor1: Cursor =
-        serde_json::from_str(&format!("\"2025-03-04T09-00-00|{u4}\"")).unwrap();
-    let expected_page1 = ConversationsPage {
-        items: vec![
-            ConversationItem {
-                path: p5,
-                head: head_5,
-            },
-            ConversationItem {
-                path: p4,
-                head: head_4,
-            },
-        ],
-        next_cursor: Some(expected_cursor1.clone()),
-        num_scanned_files: 3, // scanned 05, 04, and peeked at 03 before breaking
-        reached_scan_cap: false,
-    };
-    assert_eq!(page1, expected_page1);
-
-    let page2 = get_conversations(home, 2, page1.next_cursor.as_ref())
-        .await
-        .unwrap();
-    let p3 = home
-        .join("sessions")
-        .join("2025")
-        .join("03")
-        .join("03")
-        .join(format!("rollout-2025-03-03T09-00-00-{u3}.jsonl"));
-    let p2 = home
-        .join("sessions")
-        .join("2025")
-        .join("03")
-        .join("02")
-        .join(format!("rollout-2025-03-02T09-00-00-{u2}.jsonl"));
-    let head_3 = vec![
-        serde_json::json!({"timestamp": "2025-03-03T09-00-00", "id": u3.to_string()}),
-        serde_json::json!({"record_type": "response", "index": 0}),
-    ];
-    let head_2 = vec![
-        serde_json::json!({"timestamp": "2025-03-02T09-00-00", "id": u2.to_string()}),
-        serde_json::json!({"record_type": "response", "index": 0}),
-    ];
-    let expected_cursor2: Cursor =
-        serde_json::from_str(&format!("\"2025-03-02T09-00-00|{u2}\"")).unwrap();
-    let expected_page2 = ConversationsPage {
-        items: vec![
-            ConversationItem {
-                path: p3,
-                head: head_3,
-            },
-            ConversationItem {
-                path: p2,
-                head: head_2,
-            },
-        ],
-        next_cursor: Some(expected_cursor2.clone()),
-        num_scanned_files: 5, // scanned 05, 04 (anchor), 03, 02, and peeked at 01
-        reached_scan_cap: false,
-    };
-    assert_eq!(page2, expected_page2);
-
-    let page3 = get_conversations(home, 2, page2.next_cursor.as_ref())
-        .await
-        .unwrap();
-    let p1 = home
-        .join("sessions")
-        .join("2025")
-        .join("03")
-        .join("01")
-        .join(format!("rollout-2025-03-01T09-00-00-{u1}.jsonl"));
-    let head_1 = vec![
-        serde_json::json!({"timestamp": "2025-03-01T09-00-00", "id": u1.to_string()}),
-        serde_json::json!({"record_type": "response", "index": 0}),
-    ];
-    let expected_cursor3: Cursor =
-        serde_json::from_str(&format!("\"2025-03-01T09-00-00|{u1}\"")).unwrap();
-    let expected_page3 = ConversationsPage {
-        items: vec![ConversationItem {
-            path: p1,
-            head: head_1,
-        }],
-        next_cursor: Some(expected_cursor3.clone()),
-        num_scanned_files: 5, // scanned 05, 04 (anchor), 03, 02 (anchor), 01
-        reached_scan_cap: false,
-    };
-    assert_eq!(page3, expected_page3);
-}
-
-#[tokio::test]
-async fn test_get_conversation_contents() {
-    let temp = TempDir::new().unwrap();
-    let home = temp.path();
-
-    let uuid = Uuid::new_v4();
-    let ts = "2025-04-01T10-30-00";
-    write_session_file(home, ts, uuid, 2).unwrap();
-
-    let page = get_conversations(home, 1, None).await.unwrap();
-    let path = &page.items[0].path;
-
-    let content = get_conversation(path).await.unwrap();
-
-    // Page equality (single item)
-    let expected_path = home
-        .join("sessions")
-        .join("2025")
-        .join("04")
-        .join("01")
-        .join(format!("rollout-2025-04-01T10-30-00-{uuid}.jsonl"));
-    let expected_head = vec![
-        serde_json::json!({"timestamp": ts, "id": uuid.to_string()}),
-        serde_json::json!({"record_type": "response", "index": 0}),
-        serde_json::json!({"record_type": "response", "index": 1}),
-    ];
-    let expected_cursor: Cursor = serde_json::from_str(&format!("\"{ts}|{uuid}\"")).unwrap();
-    let expected_page = ConversationsPage {
-        items: vec![ConversationItem {
-            path: expected_path.clone(),
-            head: expected_head,
-        }],
-        next_cursor: Some(expected_cursor),
-        num_scanned_files: 1,
-        reached_scan_cap: false,
-    };
-    assert_eq!(page, expected_page);
-
-    // Entire file contents equality
-    let meta = serde_json::json!({"timestamp": ts, "id": uuid.to_string()});
-    let rec0 = serde_json::json!({"record_type": "response", "index": 0});
-    let rec1 = serde_json::json!({"record_type": "response", "index": 1});
-    let expected_content = format!("{meta}\n{rec0}\n{rec1}\n");
-    assert_eq!(content, expected_content);
-}
-
-#[tokio::test]
-async fn test_stable_ordering_same_second_pagination() {
-    let temp = TempDir::new().unwrap();
-    let home = temp.path();
-
-    let ts = "2025-07-01T00-00-00";
-    let u1 = Uuid::from_u128(1);
-    let u2 = Uuid::from_u128(2);
-    let u3 = Uuid::from_u128(3);
-
-    write_session_file(home, ts, u1, 0).unwrap();
-    write_session_file(home, ts, u2, 0).unwrap();
-    write_session_file(home, ts, u3, 0).unwrap();
-
-    let page1 = get_conversations(home, 2, None).await.unwrap();
-
-    let p3 = home
-        .join("sessions")
-        .join("2025")
-        .join("07")
-        .join("01")
-        .join(format!("rollout-2025-07-01T00-00-00-{u3}.jsonl"));
-    let p2 = home
-        .join("sessions")
-        .join("2025")
-        .join("07")
-        .join("01")
-        .join(format!("rollout-2025-07-01T00-00-00-{u2}.jsonl"));
-    let head = |u: Uuid| -> Vec<serde_json::Value> {
-        vec![serde_json::json!({"timestamp": ts, "id": u.to_string()})]
-    };
-    let expected_cursor1: Cursor = serde_json::from_str(&format!("\"{ts}|{u2}\"")).unwrap();
-    let expected_page1 = ConversationsPage {
-        items: vec![
-            ConversationItem {
-                path: p3,
-                head: head(u3),
-            },
-            ConversationItem {
-                path: p2,
-                head: head(u2),
-            },
-        ],
-        next_cursor: Some(expected_cursor1.clone()),
-        num_scanned_files: 3, // scanned u3, u2, peeked u1
-        reached_scan_cap: false,
-    };
-    assert_eq!(page1, expected_page1);
-
-    let page2 = get_conversations(home, 2, page1.next_cursor.as_ref())
-        .await
-        .unwrap();
-    let p1 = home
-        .join("sessions")
-        .join("2025")
-        .join("07")
-        .join("01")
-        .join(format!("rollout-2025-07-01T00-00-00-{u1}.jsonl"));
-    let expected_cursor2: Cursor = serde_json::from_str(&format!("\"{ts}|{u1}\"")).unwrap();
-    let expected_page2 = ConversationsPage {
-        items: vec![ConversationItem {
-            path: p1,
-            head: head(u1),
-        }],
-        next_cursor: Some(expected_cursor2.clone()),
-        num_scanned_files: 3, // scanned u3, u2 (anchor), u1
-        reached_scan_cap: false,
-    };
-    assert_eq!(page2, expected_page2);
-}

codex-rs/core/src/safety.rs

@@ -222,7 +222,7 @@ fn is_write_patch_constrained_to_writable_paths(
 
     for (path, change) in action.changes() {
         match change {
-            ApplyPatchFileChange::Add { .. } | ApplyPatchFileChange::Delete { .. } => {
+            ApplyPatchFileChange::Add { .. } | ApplyPatchFileChange::Delete => {
                 if !is_path_writable(path) {
                     return false;
                 }

codex-rs/core/src/tool_apply_patch.lark

@@ -1,19 +0,0 @@
-start: begin_patch hunk+ end_patch
-begin_patch: "*** Begin Patch" LF
-end_patch: "*** End Patch" LF?
-
-hunk: add_hunk | delete_hunk | update_hunk
-add_hunk: "*** Add File: " filename LF add_line+
-delete_hunk: "*** Delete File: " filename LF
-update_hunk: "*** Update File: " filename LF change_move? change?
-
-filename: /(.+)/
-add_line: "+" /(.*)/ LF -> line
-
-change_move: "*** Move to: " filename LF
-change: (change_context | change_line)+ eof_line?
-change_context: ("@@" | "@@ " /(.+)/) LF
-change_line: ("+" | "-" | " ") /(.*)/ LF
-eof_line: "*** End of File" LF
-
-%import common.LF

codex-rs/core/src/tool_apply_patch.rs

@@ -8,8 +8,6 @@ use crate::openai_tools::JsonSchema;
 use crate::openai_tools::OpenAiTool;
 use crate::openai_tools::ResponsesApiTool;
 
-const APPLY_PATCH_LARK_GRAMMAR: &str = include_str!("tool_apply_patch.lark");
-
 #[derive(Serialize, Deserialize)]
 pub(crate) struct ApplyPatchToolArgs {
     pub(crate) input: String,
@@ -31,7 +29,27 @@ pub(crate) fn create_apply_patch_freeform_tool() -> OpenAiTool {
         format: FreeformToolFormat {
             r#type: "grammar".to_string(),
             syntax: "lark".to_string(),
-            definition: APPLY_PATCH_LARK_GRAMMAR.to_string(),
+            definition: r#"start: begin_patch hunk+ end_patch
+begin_patch: "*** Begin Patch" LF
+end_patch: "*** End Patch" LF?
+
+hunk: add_hunk | delete_hunk | update_hunk
+add_hunk: "*** Add File: " filename LF add_line+
+delete_hunk: "*** Delete File: " filename LF
+update_hunk: "*** Update File: " filename LF change_move? change?
+
+filename: /(.+)/
+add_line: "+" /(.+)/ LF -> line
+
+change_move: "*** Move to: " filename LF
+change: (change_context | change_line)+ eof_line?
+change_context: ("@@" | "@@ " /(.+)/) LF
+change_line: ("+" | "-" | " ") /(.+)/ LF
+eof_line: "*** End of File" LF
+
+%import common.LF
+"#
+            .to_string(),
         },
     })
 }

codex-rs/core/src/turn_diff_tracker.rs

@@ -578,12 +578,7 @@ index {ZERO_OID}..{right_oid}
         fs::write(&file, "x\n").unwrap();
 
         let mut acc = TurnDiffTracker::new();
-        let del_changes = HashMap::from([(
-            file.clone(),
-            FileChange::Delete {
-                content: "x\n".to_string(),
-            },
-        )]);
+        let del_changes = HashMap::from([(file.clone(), FileChange::Delete)]);
         acc.on_patch_begin(&del_changes);
 
         // Simulate apply: delete the file from disk.
@@ -746,12 +741,7 @@ index {left_oid}..{right_oid}
         assert_eq!(first, expected_first);
 
         // Next: introduce a brand-new path b.txt into baseline snapshots via a delete change.
-        let del_b = HashMap::from([(
-            b.clone(),
-            FileChange::Delete {
-                content: "z\n".to_string(),
-            },
-        )]);
+        let del_b = HashMap::from([(b.clone(), FileChange::Delete)]);
         acc.on_patch_begin(&del_b);
         // Simulate apply: delete b.txt.
         let baseline_mode = file_mode_for_path(&b).unwrap_or(FileMode::Regular);

codex-rs/core/src/util.rs

@@ -1,3 +1,4 @@
+use std::path::Path;
 use std::time::Duration;
 
 use rand::Rng;
@@ -11,3 +12,33 @@ pub(crate) fn backoff(attempt: u64) -> Duration {
     let jitter = rand::rng().random_range(0.9..1.1);
     Duration::from_millis((base as f64 * jitter) as u64)
 }
+
+/// Return `true` if the project folder specified by the `Config` is inside a
+/// Git repository.
+///
+/// The check walks up the directory hierarchy looking for a `.git` file or
+/// directory (note `.git` can be a file that contains a `gitdir` entry). This
+/// approach does **not** require the `git` binary or the `git2` crate and is
+/// therefore fairly lightweight.
+///
+/// Note that this does **not** detect *work‑trees* created with
+/// `git worktree add` where the checkout lives outside the main repository
+/// directory. If you need Codex to work from such a checkout simply pass the
+/// `--allow-no-git-exec` CLI flag that disables the repo requirement.
+pub fn is_inside_git_repo(base_dir: &Path) -> bool {
+    let mut dir = base_dir.to_path_buf();
+
+    loop {
+        if dir.join(".git").exists() {
+            return true;
+        }
+
+        // Pop one component (go up one directory).  `pop` returns false when
+        // we have reached the filesystem root.
+        if !dir.pop() {
+            break;
+        }
+    }
+
+    false
+}

codex-rs/core/tests/chat_completions_payload.rs

@@ -1,345 +0,0 @@
-use std::sync::Arc;
-
-use codex_core::ContentItem;
-use codex_core::LocalShellAction;
-use codex_core::LocalShellExecAction;
-use codex_core::LocalShellStatus;
-use codex_core::ModelClient;
-use codex_core::ModelProviderInfo;
-use codex_core::Prompt;
-use codex_core::ReasoningItemContent;
-use codex_core::ResponseItem;
-use codex_core::WireApi;
-use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
-use core_test_support::load_default_config_for_test;
-use futures::StreamExt;
-use serde_json::Value;
-use tempfile::TempDir;
-use uuid::Uuid;
-use wiremock::Mock;
-use wiremock::MockServer;
-use wiremock::ResponseTemplate;
-use wiremock::matchers::method;
-use wiremock::matchers::path;
-
-fn network_disabled() -> bool {
-    std::env::var(CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok()
-}
-
-async fn run_request(input: Vec<ResponseItem>) -> Value {
-    let server = MockServer::start().await;
-
-    let template = ResponseTemplate::new(200)
-        .insert_header("content-type", "text/event-stream")
-        .set_body_raw(
-            "data: {\"choices\":[{\"delta\":{}}]}\n\ndata: [DONE]\n\n",
-            "text/event-stream",
-        );
-
-    Mock::given(method("POST"))
-        .and(path("/v1/chat/completions"))
-        .respond_with(template)
-        .expect(1)
-        .mount(&server)
-        .await;
-
-    let provider = ModelProviderInfo {
-        name: "mock".into(),
-        base_url: Some(format!("{}/v1", server.uri())),
-        env_key: None,
-        env_key_instructions: None,
-        wire_api: WireApi::Chat,
-        query_params: None,
-        http_headers: None,
-        env_http_headers: None,
-        request_max_retries: Some(0),
-        stream_max_retries: Some(0),
-        stream_idle_timeout_ms: Some(5_000),
-        requires_openai_auth: false,
-    };
-
-    let codex_home = match TempDir::new() {
-        Ok(dir) => dir,
-        Err(e) => panic!("failed to create TempDir: {e}"),
-    };
-    let mut config = load_default_config_for_test(&codex_home);
-    config.model_provider_id = provider.name.clone();
-    config.model_provider = provider.clone();
-    config.show_raw_agent_reasoning = true;
-    let effort = config.model_reasoning_effort;
-    let summary = config.model_reasoning_summary;
-    let config = Arc::new(config);
-
-    let client = ModelClient::new(
-        Arc::clone(&config),
-        None,
-        provider,
-        effort,
-        summary,
-        Uuid::new_v4(),
-    );
-
-    let mut prompt = Prompt::default();
-    prompt.input = input;
-
-    let mut stream = match client.stream(&prompt).await {
-        Ok(s) => s,
-        Err(e) => panic!("stream chat failed: {e}"),
-    };
-    while let Some(event) = stream.next().await {
-        if let Err(e) = event {
-            panic!("stream event error: {e}");
-        }
-    }
-
-    let requests = match server.received_requests().await {
-        Some(reqs) => reqs,
-        None => panic!("request not made"),
-    };
-    match requests[0].body_json() {
-        Ok(v) => v,
-        Err(e) => panic!("invalid json body: {e}"),
-    }
-}
-
-fn user_message(text: &str) -> ResponseItem {
-    ResponseItem::Message {
-        id: None,
-        role: "user".to_string(),
-        content: vec![ContentItem::InputText {
-            text: text.to_string(),
-        }],
-    }
-}
-
-fn assistant_message(text: &str) -> ResponseItem {
-    ResponseItem::Message {
-        id: None,
-        role: "assistant".to_string(),
-        content: vec![ContentItem::OutputText {
-            text: text.to_string(),
-        }],
-    }
-}
-
-fn reasoning_item(text: &str) -> ResponseItem {
-    ResponseItem::Reasoning {
-        id: String::new(),
-        summary: Vec::new(),
-        content: Some(vec![ReasoningItemContent::ReasoningText {
-            text: text.to_string(),
-        }]),
-        encrypted_content: None,
-    }
-}
-
-fn function_call() -> ResponseItem {
-    ResponseItem::FunctionCall {
-        id: None,
-        name: "f".to_string(),
-        arguments: "{}".to_string(),
-        call_id: "c1".to_string(),
-    }
-}
-
-fn local_shell_call() -> ResponseItem {
-    ResponseItem::LocalShellCall {
-        id: Some("id1".to_string()),
-        call_id: None,
-        status: LocalShellStatus::InProgress,
-        action: LocalShellAction::Exec(LocalShellExecAction {
-            command: vec!["echo".to_string()],
-            timeout_ms: Some(1_000),
-            working_directory: None,
-            env: None,
-            user: None,
-        }),
-    }
-}
-
-fn messages_from(body: &Value) -> Vec<Value> {
-    match body["messages"].as_array() {
-        Some(arr) => arr.clone(),
-        None => panic!("messages array missing"),
-    }
-}
-
-fn first_assistant(messages: &[Value]) -> &Value {
-    match messages.iter().find(|msg| msg["role"] == "assistant") {
-        Some(v) => v,
-        None => panic!("assistant message not present"),
-    }
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn omits_reasoning_when_none_present() {
-    if network_disabled() {
-        println!(
-            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
-        );
-        return;
-    }
-
-    let body = run_request(vec![user_message("u1"), assistant_message("a1")]).await;
-    let messages = messages_from(&body);
-    let assistant = first_assistant(&messages);
-
-    assert_eq!(assistant["content"], Value::String("a1".into()));
-    assert!(assistant.get("reasoning").is_none());
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn attaches_reasoning_to_previous_assistant() {
-    if network_disabled() {
-        println!(
-            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
-        );
-        return;
-    }
-
-    let body = run_request(vec![
-        user_message("u1"),
-        assistant_message("a1"),
-        reasoning_item("rA"),
-    ])
-    .await;
-    let messages = messages_from(&body);
-    let assistant = first_assistant(&messages);
-
-    assert_eq!(assistant["content"], Value::String("a1".into()));
-    assert_eq!(assistant["reasoning"], Value::String("rA".into()));
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn attaches_reasoning_to_function_call_anchor() {
-    if network_disabled() {
-        println!(
-            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
-        );
-        return;
-    }
-
-    let body = run_request(vec![
-        user_message("u1"),
-        reasoning_item("rFunc"),
-        function_call(),
-    ])
-    .await;
-    let messages = messages_from(&body);
-    let assistant = first_assistant(&messages);
-
-    assert_eq!(assistant["reasoning"], Value::String("rFunc".into()));
-    let tool_calls = match assistant["tool_calls"].as_array() {
-        Some(arr) => arr,
-        None => panic!("tool call list missing"),
-    };
-    assert_eq!(tool_calls.len(), 1);
-    assert_eq!(tool_calls[0]["type"], Value::String("function".into()));
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn attaches_reasoning_to_local_shell_call() {
-    if network_disabled() {
-        println!(
-            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
-        );
-        return;
-    }
-
-    let body = run_request(vec![
-        user_message("u1"),
-        reasoning_item("rShell"),
-        local_shell_call(),
-    ])
-    .await;
-    let messages = messages_from(&body);
-    let assistant = first_assistant(&messages);
-
-    assert_eq!(assistant["reasoning"], Value::String("rShell".into()));
-    assert_eq!(
-        assistant["tool_calls"][0]["type"],
-        Value::String("local_shell_call".into())
-    );
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn drops_reasoning_when_last_role_is_user() {
-    if network_disabled() {
-        println!(
-            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
-        );
-        return;
-    }
-
-    let body = run_request(vec![
-        assistant_message("aPrev"),
-        reasoning_item("rHist"),
-        user_message("uNew"),
-    ])
-    .await;
-    let messages = messages_from(&body);
-    assert!(messages.iter().all(|msg| msg.get("reasoning").is_none()));
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn ignores_reasoning_before_last_user() {
-    if network_disabled() {
-        println!(
-            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
-        );
-        return;
-    }
-
-    let body = run_request(vec![
-        user_message("u1"),
-        assistant_message("a1"),
-        user_message("u2"),
-        reasoning_item("rAfterU1"),
-    ])
-    .await;
-    let messages = messages_from(&body);
-    assert!(messages.iter().all(|msg| msg.get("reasoning").is_none()));
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn skips_empty_reasoning_segments() {
-    if network_disabled() {
-        println!(
-            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
-        );
-        return;
-    }
-
-    let body = run_request(vec![
-        user_message("u1"),
-        assistant_message("a1"),
-        reasoning_item(""),
-        reasoning_item("   "),
-    ])
-    .await;
-    let messages = messages_from(&body);
-    let assistant = first_assistant(&messages);
-    assert!(assistant.get("reasoning").is_none());
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn suppresses_duplicate_assistant_messages() {
-    if network_disabled() {
-        println!(
-            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
-        );
-        return;
-    }
-
-    let body = run_request(vec![assistant_message("dup"), assistant_message("dup")]).await;
-    let messages = messages_from(&body);
-    let assistant_messages: Vec<_> = messages
-        .iter()
-        .filter(|msg| msg["role"] == "assistant")
-        .collect();
-    assert_eq!(assistant_messages.len(), 1);
-    assert_eq!(
-        assistant_messages[0]["content"],
-        Value::String("dup".into())
-    );
-}

codex-rs/core/tests/chat_completions_sse.rs

@@ -1,320 +0,0 @@
-use std::sync::Arc;
-
-use codex_core::ContentItem;
-use codex_core::ModelClient;
-use codex_core::ModelProviderInfo;
-use codex_core::Prompt;
-use codex_core::ResponseEvent;
-use codex_core::ResponseItem;
-use codex_core::WireApi;
-use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
-use core_test_support::load_default_config_for_test;
-use futures::StreamExt;
-use tempfile::TempDir;
-use uuid::Uuid;
-use wiremock::Mock;
-use wiremock::MockServer;
-use wiremock::ResponseTemplate;
-use wiremock::matchers::method;
-use wiremock::matchers::path;
-
-fn network_disabled() -> bool {
-    std::env::var(CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok()
-}
-
-async fn run_stream(sse_body: &str) -> Vec<ResponseEvent> {
-    let server = MockServer::start().await;
-
-    let template = ResponseTemplate::new(200)
-        .insert_header("content-type", "text/event-stream")
-        .set_body_raw(sse_body.to_string(), "text/event-stream");
-
-    Mock::given(method("POST"))
-        .and(path("/v1/chat/completions"))
-        .respond_with(template)
-        .expect(1)
-        .mount(&server)
-        .await;
-
-    let provider = ModelProviderInfo {
-        name: "mock".into(),
-        base_url: Some(format!("{}/v1", server.uri())),
-        env_key: None,
-        env_key_instructions: None,
-        wire_api: WireApi::Chat,
-        query_params: None,
-        http_headers: None,
-        env_http_headers: None,
-        request_max_retries: Some(0),
-        stream_max_retries: Some(0),
-        stream_idle_timeout_ms: Some(5_000),
-        requires_openai_auth: false,
-    };
-
-    let codex_home = match TempDir::new() {
-        Ok(dir) => dir,
-        Err(e) => panic!("failed to create TempDir: {e}"),
-    };
-    let mut config = load_default_config_for_test(&codex_home);
-    config.model_provider_id = provider.name.clone();
-    config.model_provider = provider.clone();
-    config.show_raw_agent_reasoning = true;
-    let effort = config.model_reasoning_effort;
-    let summary = config.model_reasoning_summary;
-    let config = Arc::new(config);
-
-    let client = ModelClient::new(
-        Arc::clone(&config),
-        None,
-        provider,
-        effort,
-        summary,
-        Uuid::new_v4(),
-    );
-
-    let mut prompt = Prompt::default();
-    prompt.input = vec![ResponseItem::Message {
-        id: None,
-        role: "user".to_string(),
-        content: vec![ContentItem::InputText {
-            text: "hello".to_string(),
-        }],
-    }];
-
-    let mut stream = match client.stream(&prompt).await {
-        Ok(s) => s,
-        Err(e) => panic!("stream chat failed: {e}"),
-    };
-    let mut events = Vec::new();
-    while let Some(event) = stream.next().await {
-        match event {
-            Ok(ev) => events.push(ev),
-            Err(e) => panic!("stream event error: {e}"),
-        }
-    }
-    events
-}
-
-fn assert_message(item: &ResponseItem, expected: &str) {
-    if let ResponseItem::Message { content, .. } = item {
-        let text = content.iter().find_map(|part| match part {
-            ContentItem::OutputText { text } | ContentItem::InputText { text } => Some(text),
-            _ => None,
-        });
-        let Some(text) = text else {
-            panic!("message missing text: {item:?}");
-        };
-        assert_eq!(text, expected);
-    } else {
-        panic!("expected message item, got: {item:?}");
-    }
-}
-
-fn assert_reasoning(item: &ResponseItem, expected: &str) {
-    if let ResponseItem::Reasoning {
-        content: Some(parts),
-        ..
-    } = item
-    {
-        let mut combined = String::new();
-        for part in parts {
-            match part {
-                codex_core::ReasoningItemContent::ReasoningText { text }
-                | codex_core::ReasoningItemContent::Text { text } => combined.push_str(text),
-            }
-        }
-        assert_eq!(combined, expected);
-    } else {
-        panic!("expected reasoning item, got: {item:?}");
-    }
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn streams_text_without_reasoning() {
-    if network_disabled() {
-        println!(
-            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
-        );
-        return;
-    }
-
-    let sse = concat!(
-        "data: {\"choices\":[{\"delta\":{\"content\":\"hi\"}}]}\n\n",
-        "data: {\"choices\":[{\"delta\":{}}]}\n\n",
-        "data: [DONE]\n\n",
-    );
-
-    let events = run_stream(sse).await;
-    assert_eq!(events.len(), 3, "unexpected events: {events:?}");
-
-    match &events[0] {
-        ResponseEvent::OutputTextDelta(text) => assert_eq!(text, "hi"),
-        other => panic!("expected text delta, got {other:?}"),
-    }
-
-    match &events[1] {
-        ResponseEvent::OutputItemDone(item) => assert_message(item, "hi"),
-        other => panic!("expected terminal message, got {other:?}"),
-    }
-
-    assert!(matches!(events[2], ResponseEvent::Completed { .. }));
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn streams_reasoning_from_string_delta() {
-    if network_disabled() {
-        println!(
-            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
-        );
-        return;
-    }
-
-    let sse = concat!(
-        "data: {\"choices\":[{\"delta\":{\"reasoning\":\"think1\"}}]}\n\n",
-        "data: {\"choices\":[{\"delta\":{\"content\":\"ok\"}}]}\n\n",
-        "data: {\"choices\":[{\"delta\":{} ,\"finish_reason\":\"stop\"}]}\n\n",
-    );
-
-    let events = run_stream(sse).await;
-    assert_eq!(events.len(), 5, "unexpected events: {events:?}");
-
-    match &events[0] {
-        ResponseEvent::ReasoningContentDelta(text) => assert_eq!(text, "think1"),
-        other => panic!("expected reasoning delta, got {other:?}"),
-    }
-
-    match &events[1] {
-        ResponseEvent::OutputTextDelta(text) => assert_eq!(text, "ok"),
-        other => panic!("expected text delta, got {other:?}"),
-    }
-
-    match &events[2] {
-        ResponseEvent::OutputItemDone(item) => assert_reasoning(item, "think1"),
-        other => panic!("expected reasoning item, got {other:?}"),
-    }
-
-    match &events[3] {
-        ResponseEvent::OutputItemDone(item) => assert_message(item, "ok"),
-        other => panic!("expected message item, got {other:?}"),
-    }
-
-    assert!(matches!(events[4], ResponseEvent::Completed { .. }));
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn streams_reasoning_from_object_delta() {
-    if network_disabled() {
-        println!(
-            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
-        );
-        return;
-    }
-
-    let sse = concat!(
-        "data: {\"choices\":[{\"delta\":{\"reasoning\":{\"text\":\"partA\"}}}]}\n\n",
-        "data: {\"choices\":[{\"delta\":{\"reasoning\":{\"content\":\"partB\"}}}]}\n\n",
-        "data: {\"choices\":[{\"delta\":{\"content\":\"answer\"}}]}\n\n",
-        "data: {\"choices\":[{\"delta\":{} ,\"finish_reason\":\"stop\"}]}\n\n",
-    );
-
-    let events = run_stream(sse).await;
-    assert_eq!(events.len(), 6, "unexpected events: {events:?}");
-
-    match &events[0] {
-        ResponseEvent::ReasoningContentDelta(text) => assert_eq!(text, "partA"),
-        other => panic!("expected reasoning delta, got {other:?}"),
-    }
-
-    match &events[1] {
-        ResponseEvent::ReasoningContentDelta(text) => assert_eq!(text, "partB"),
-        other => panic!("expected reasoning delta, got {other:?}"),
-    }
-
-    match &events[2] {
-        ResponseEvent::OutputTextDelta(text) => assert_eq!(text, "answer"),
-        other => panic!("expected text delta, got {other:?}"),
-    }
-
-    match &events[3] {
-        ResponseEvent::OutputItemDone(item) => assert_reasoning(item, "partApartB"),
-        other => panic!("expected reasoning item, got {other:?}"),
-    }
-
-    match &events[4] {
-        ResponseEvent::OutputItemDone(item) => assert_message(item, "answer"),
-        other => panic!("expected message item, got {other:?}"),
-    }
-
-    assert!(matches!(events[5], ResponseEvent::Completed { .. }));
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn streams_reasoning_from_final_message() {
-    if network_disabled() {
-        println!(
-            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
-        );
-        return;
-    }
-
-    let sse = "data: {\"choices\":[{\"message\":{\"reasoning\":\"final-cot\"},\"finish_reason\":\"stop\"}]}\n\n";
-
-    let events = run_stream(sse).await;
-    assert_eq!(events.len(), 3, "unexpected events: {events:?}");
-
-    match &events[0] {
-        ResponseEvent::ReasoningContentDelta(text) => assert_eq!(text, "final-cot"),
-        other => panic!("expected reasoning delta, got {other:?}"),
-    }
-
-    match &events[1] {
-        ResponseEvent::OutputItemDone(item) => assert_reasoning(item, "final-cot"),
-        other => panic!("expected reasoning item, got {other:?}"),
-    }
-
-    assert!(matches!(events[2], ResponseEvent::Completed { .. }));
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn streams_reasoning_before_tool_call() {
-    if network_disabled() {
-        println!(
-            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
-        );
-        return;
-    }
-
-    let sse = concat!(
-        "data: {\"choices\":[{\"delta\":{\"reasoning\":\"pre-tool\"}}]}\n\n",
-        "data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"id\":\"call_1\",\"type\":\"function\",\"function\":{\"name\":\"run\",\"arguments\":\"{}\"}}]},\"finish_reason\":\"tool_calls\"}]}\n\n",
-    );
-
-    let events = run_stream(sse).await;
-    assert_eq!(events.len(), 4, "unexpected events: {events:?}");
-
-    match &events[0] {
-        ResponseEvent::ReasoningContentDelta(text) => assert_eq!(text, "pre-tool"),
-        other => panic!("expected reasoning delta, got {other:?}"),
-    }
-
-    match &events[1] {
-        ResponseEvent::OutputItemDone(item) => assert_reasoning(item, "pre-tool"),
-        other => panic!("expected reasoning item, got {other:?}"),
-    }
-
-    match &events[2] {
-        ResponseEvent::OutputItemDone(ResponseItem::FunctionCall {
-            name,
-            arguments,
-            call_id,
-            ..
-        }) => {
-            assert_eq!(name, "run");
-            assert_eq!(arguments, "{}");
-            assert_eq!(call_id, "call_1");
-        }
-        other => panic!("expected function call, got {other:?}"),
-    }
-
-    assert!(matches!(events[3], ResponseEvent::Completed { .. }));
-}

codex-rs/core/tests/suite/cli_stream.rs

@@ -388,7 +388,7 @@ async fn integration_creates_and_checks_session_file() {
         "No message found in session file containing the marker"
     );
 
-    // Second run: resume should create a NEW session file that contains both old and new history.
+    // Second run: resume and append.
     let orig_len = content.lines().count();
     let marker2 = format!("integration-resume-{}", Uuid::new_v4());
     let prompt2 = format!("echo {marker2}");
@@ -419,58 +419,31 @@ async fn integration_creates_and_checks_session_file() {
     let output2 = cmd2.output().unwrap();
     assert!(output2.status.success(), "resume codex-cli run failed");
 
-    // Find the new session file containing the resumed marker.
-    let deadline = Instant::now() + Duration::from_secs(10);
-    let mut resumed_path: Option<std::path::PathBuf> = None;
-    while Instant::now() < deadline && resumed_path.is_none() {
-        for entry in WalkDir::new(&sessions_dir) {
-            let entry = match entry {
-                Ok(e) => e,
-                Err(_) => continue,
-            };
-            if !entry.file_type().is_file() {
-                continue;
-            }
-            if !entry.file_name().to_string_lossy().ends_with(".jsonl") {
-                continue;
-            }
-            let p = entry.path();
-            let Ok(c) = std::fs::read_to_string(p) else {
-                continue;
-            };
-            if c.contains(&marker2) {
-                resumed_path = Some(p.to_path_buf());
+    // The rollout writer runs on a background async task; give it a moment to flush.
+    let mut new_len = orig_len;
+    let deadline = Instant::now() + Duration::from_secs(5);
+    let mut content2 = String::new();
+    while Instant::now() < deadline {
+        if let Ok(c) = std::fs::read_to_string(&path) {
+            let count = c.lines().count();
+            if count > orig_len {
+                content2 = c;
+                new_len = count;
                 break;
             }
         }
-        if resumed_path.is_none() {
-            std::thread::sleep(Duration::from_millis(50));
-        }
+        std::thread::sleep(Duration::from_millis(50));
     }
-
-    let resumed_path = resumed_path.expect("No resumed session file found containing the marker2");
-    // Resume should have written to a new file, not the original one.
-    assert_ne!(
-        resumed_path, path,
-        "resume should create a new session file"
-    );
-
-    let resumed_content = std::fs::read_to_string(&resumed_path).unwrap();
+    if content2.is_empty() {
+        // last attempt
+        content2 = std::fs::read_to_string(&path).unwrap();
+        new_len = content2.lines().count();
+    }
+    assert!(new_len > orig_len, "rollout file did not grow after resume");
+    assert!(content2.contains(&marker), "rollout lost original marker");
     assert!(
-        resumed_content.contains(&marker),
-        "resumed file missing original marker"
-    );
-    assert!(
-        resumed_content.contains(&marker2),
-        "resumed file missing resumed marker"
-    );
-
-    // Original file should remain unchanged.
-    let content_after = std::fs::read_to_string(&path).unwrap();
-    assert_eq!(
-        content_after.lines().count(),
-        orig_len,
-        "original rollout file should not change on resume"
+        content2.contains(&marker2),
+        "rollout missing resumed marker"
     );
 }
 

codex-rs/core/tests/suite/client.rs

@@ -1,4 +1,3 @@
-use codex_core::CodexAuth;
 use codex_core::ConversationManager;
 use codex_core::ModelProviderInfo;
 use codex_core::NewConversation;
@@ -8,7 +7,8 @@ use codex_core::protocol::EventMsg;
 use codex_core::protocol::InputItem;
 use codex_core::protocol::Op;
 use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
-use codex_protocol::mcp_protocol::AuthMode;
+use codex_login::AuthMode;
+use codex_login::CodexAuth;
 use core_test_support::load_default_config_for_test;
 use core_test_support::load_sse_fixture_with_id;
 use core_test_support::wait_for_event;
@@ -416,9 +416,9 @@ async fn prefers_chatgpt_token_when_config_prefers_chatgpt() {
 
     let auth_manager =
         match CodexAuth::from_codex_home(codex_home.path(), config.preferred_auth_method) {
-            Ok(Some(auth)) => codex_core::AuthManager::from_auth_for_testing(auth),
+            Ok(Some(auth)) => codex_login::AuthManager::from_auth_for_testing(auth),
             Ok(None) => panic!("No CodexAuth found in codex_home"),
-            Err(e) => panic!("Failed to load CodexAuth: {e}"),
+            Err(e) => panic!("Failed to load CodexAuth: {}", e),
         };
     let conversation_manager = ConversationManager::new(auth_manager);
     let NewConversation {
@@ -497,9 +497,9 @@ async fn prefers_apikey_when_config_prefers_apikey_even_with_chatgpt_tokens() {
 
     let auth_manager =
         match CodexAuth::from_codex_home(codex_home.path(), config.preferred_auth_method) {
-            Ok(Some(auth)) => codex_core::AuthManager::from_auth_for_testing(auth),
+            Ok(Some(auth)) => codex_login::AuthManager::from_auth_for_testing(auth),
             Ok(None) => panic!("No CodexAuth found in codex_home"),
-            Err(e) => panic!("Failed to load CodexAuth: {e}"),
+            Err(e) => panic!("Failed to load CodexAuth: {}", e),
         };
     let conversation_manager = ConversationManager::new(auth_manager);
     let NewConversation {

codex-rs/core/tests/suite/compact.rs

@@ -1,6 +1,5 @@
 #![expect(clippy::unwrap_used)]
 
-use codex_core::CodexAuth;
 use codex_core::ConversationManager;
 use codex_core::ModelProviderInfo;
 use codex_core::built_in_model_providers;
@@ -8,6 +7,7 @@ use codex_core::protocol::EventMsg;
 use codex_core::protocol::InputItem;
 use codex_core::protocol::Op;
 use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
+use codex_login::CodexAuth;
 use core_test_support::load_default_config_for_test;
 use core_test_support::wait_for_event;
 use serde_json::Value;

codex-rs/core/tests/suite/fork_conversation.rs

@@ -1,154 +0,0 @@
-use codex_core::CodexAuth;
-use codex_core::ConversationManager;
-use codex_core::ModelProviderInfo;
-use codex_core::NewConversation;
-use codex_core::built_in_model_providers;
-use codex_core::protocol::ConversationHistoryResponseEvent;
-use codex_core::protocol::EventMsg;
-use codex_core::protocol::InputItem;
-use codex_core::protocol::Op;
-use core_test_support::load_default_config_for_test;
-use core_test_support::wait_for_event;
-use tempfile::TempDir;
-use wiremock::Mock;
-use wiremock::MockServer;
-use wiremock::ResponseTemplate;
-use wiremock::matchers::method;
-use wiremock::matchers::path;
-
-/// Build minimal SSE stream with completed marker using the JSON fixture.
-fn sse_completed(id: &str) -> String {
-    core_test_support::load_sse_fixture_with_id("tests/fixtures/completed_template.json", id)
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn fork_conversation_twice_drops_to_first_message() {
-    // Start a mock server that completes three turns.
-    let server = MockServer::start().await;
-    let sse = sse_completed("resp");
-    let first = ResponseTemplate::new(200)
-        .insert_header("content-type", "text/event-stream")
-        .set_body_raw(sse.clone(), "text/event-stream");
-
-    // Expect three calls to /v1/responses – one per user input.
-    Mock::given(method("POST"))
-        .and(path("/v1/responses"))
-        .respond_with(first)
-        .expect(3)
-        .mount(&server)
-        .await;
-
-    // Configure Codex to use the mock server.
-    let model_provider = ModelProviderInfo {
-        base_url: Some(format!("{}/v1", server.uri())),
-        ..built_in_model_providers()["openai"].clone()
-    };
-
-    let home = TempDir::new().unwrap();
-    let mut config = load_default_config_for_test(&home);
-    config.model_provider = model_provider.clone();
-    let config_for_fork = config.clone();
-
-    let conversation_manager = ConversationManager::with_auth(CodexAuth::from_api_key("dummy"));
-    let NewConversation {
-        conversation: codex,
-        ..
-    } = conversation_manager
-        .new_conversation(config)
-        .await
-        .expect("create conversation");
-
-    // Send three user messages; wait for three completed turns.
-    for text in ["first", "second", "third"] {
-        codex
-            .submit(Op::UserInput {
-                items: vec![InputItem::Text {
-                    text: text.to_string(),
-                }],
-            })
-            .await
-            .unwrap();
-        let _ = wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
-    }
-
-    // Request history from the base conversation.
-    codex.submit(Op::GetHistory).await.unwrap();
-    let base_history =
-        wait_for_event(&codex, |ev| matches!(ev, EventMsg::ConversationHistory(_))).await;
-
-    // Capture entries from the base history and compute expected prefixes after each fork.
-    let entries_after_three = match &base_history {
-        EventMsg::ConversationHistory(ConversationHistoryResponseEvent { entries, .. }) => {
-            entries.clone()
-        }
-        _ => panic!("expected ConversationHistory event"),
-    };
-    // History layout for this test:
-    // [0] user instructions,
-    // [1] environment context,
-    // [2] "first" user message,
-    // [3] "second" user message,
-    // [4] "third" user message.
-
-    // Fork 1: drops the last user message and everything after.
-    let expected_after_first = vec![
-        entries_after_three[0].clone(),
-        entries_after_three[1].clone(),
-        entries_after_three[2].clone(),
-        entries_after_three[3].clone(),
-    ];
-
-    // Fork 2: drops the last user message and everything after.
-    // [0] user instructions,
-    // [1] environment context,
-    // [2] "first" user message,
-    let expected_after_second = vec![
-        entries_after_three[0].clone(),
-        entries_after_three[1].clone(),
-        entries_after_three[2].clone(),
-    ];
-
-    // Fork once with n=1 → drops the last user message and everything after.
-    let NewConversation {
-        conversation: codex_fork1,
-        ..
-    } = conversation_manager
-        .fork_conversation(entries_after_three.clone(), 1, config_for_fork.clone())
-        .await
-        .expect("fork 1");
-
-    codex_fork1.submit(Op::GetHistory).await.unwrap();
-    let fork1_history = wait_for_event(&codex_fork1, |ev| {
-        matches!(ev, EventMsg::ConversationHistory(_))
-    })
-    .await;
-    let entries_after_first_fork = match &fork1_history {
-        EventMsg::ConversationHistory(ConversationHistoryResponseEvent { entries, .. }) => {
-            assert!(matches!(
-                fork1_history,
-                EventMsg::ConversationHistory(ConversationHistoryResponseEvent { ref entries, .. }) if *entries == expected_after_first
-            ));
-            entries.clone()
-        }
-        _ => panic!("expected ConversationHistory event after first fork"),
-    };
-
-    // Fork again with n=1 → drops the (new) last user message, leaving only the first.
-    let NewConversation {
-        conversation: codex_fork2,
-        ..
-    } = conversation_manager
-        .fork_conversation(entries_after_first_fork.clone(), 1, config_for_fork.clone())
-        .await
-        .expect("fork 2");
-
-    codex_fork2.submit(Op::GetHistory).await.unwrap();
-    let fork2_history = wait_for_event(&codex_fork2, |ev| {
-        matches!(ev, EventMsg::ConversationHistory(_))
-    })
-    .await;
-    assert!(matches!(
-        fork2_history,
-        EventMsg::ConversationHistory(ConversationHistoryResponseEvent { ref entries, .. }) if *entries == expected_after_second
-    ));
-}

codex-rs/core/tests/suite/mcp_overlays.rs

@@ -0,0 +1,57 @@
+use std::fs;
+use std::path::PathBuf;
+
+use codex_core::config::Config;
+use codex_core::config::ConfigOverrides;
+
+fn write(path: impl Into<PathBuf>, contents: &str) {
+    let p: PathBuf = path.into();
+    fs::write(&p, contents).unwrap_or_else(|e| panic!("failed writing {}: {e}", p.display()));
+}
+
+#[test]
+fn test_overlay_precedence_local_over_project_over_user() -> std::io::Result<()> {
+    // Set up a fake CODEX_HOME with a user-level MCP server.
+    let codex_home = tempfile::tempdir()?;
+    std::env::set_var("CODEX_HOME", codex_home.path());
+    // Ensure directory exists before canonicalization in find_codex_home().
+    let config_toml_path = codex_home.path().join("config.toml");
+    write(&config_toml_path, r#"[mcp_servers.svc]
+command = "user"
+"#);
+
+    // Set up a project directory with overlays.
+    let project_dir = tempfile::tempdir()?;
+    // Mark as git repo root (enough for resolve_root_git_project_for_trust()).
+    write(project_dir.path().join(".git"), "gitdir: nowhere");
+
+    // Project overlay defines the same server name.
+    write(
+        project_dir.path().join(".mcp.toml"),
+        r#"[mcp_servers.svc]
+command = "project"
+"#,
+    );
+    // Local overlay should take precedence.
+    write(
+        project_dir.path().join(".mcp.local.toml"),
+        r#"[mcp_servers.svc]
+command = "local"
+"#,
+    );
+
+    let overrides = ConfigOverrides {
+        cwd: Some(project_dir.path().to_path_buf()),
+        ..Default::default()
+    };
+
+    let cfg = Config::load_with_cli_overrides(vec![], overrides)?;
+    let svc = cfg
+        .mcp_servers
+        .get("svc")
+        .expect("svc should be present after merge");
+    assert_eq!(svc.command, "local");
+
+    Ok(())
+}
+

codex-rs/core/tests/suite/mod.rs

@@ -5,7 +5,6 @@ mod client;
 mod compact;
 mod exec;
 mod exec_stream_events;
-mod fork_conversation;
 mod live_cli;
 mod prompt_caching;
 mod seatbelt;

codex-rs/core/tests/suite/prompt_caching.rs

@@ -1,6 +1,5 @@
 #![allow(clippy::unwrap_used)]
 
-use codex_core::CodexAuth;
 use codex_core::ConversationManager;
 use codex_core::ModelProviderInfo;
 use codex_core::built_in_model_providers;
@@ -13,6 +12,7 @@ use codex_core::protocol::SandboxPolicy;
 use codex_core::protocol_config_types::ReasoningEffort;
 use codex_core::protocol_config_types::ReasoningSummary;
 use codex_core::shell::default_user_shell;
+use codex_login::CodexAuth;
 use core_test_support::load_default_config_for_test;
 use core_test_support::load_sse_fixture_with_id;
 use core_test_support::wait_for_event;
@@ -191,7 +191,7 @@ async fn prompt_tools_are_consistent_across_requests() {
     let expected_instructions: &str = include_str!("../../prompt.md");
     // our internal implementation is responsible for keeping tools in sync
     // with the OpenAI schema, so we just verify the tool presence here
-    let expected_tools_names: &[&str] = &["shell", "update_plan", "apply_patch", "view_image"];
+    let expected_tools_names: &[&str] = &["shell", "update_plan", "apply_patch"];
     let body0 = requests[0].body_json::<serde_json::Value>().unwrap();
     assert_eq!(
         body0["instructions"],
@@ -280,7 +280,7 @@ async fn prefixes_context_and_instructions_once_and_consistently_across_requests
 {}</environment_context>"#,
         cwd.path().to_string_lossy(),
         match shell.name() {
-            Some(name) => format!("  <shell>{name}</shell>\n"),
+            Some(name) => format!("  <shell>{}</shell>\n", name),
             None => String::new(),
         }
     );

codex-rs/core/tests/suite/stream_error_allows_next_turn.rs

@@ -1,6 +1,5 @@
 use std::time::Duration;
 
-use codex_core::CodexAuth;
 use codex_core::ConversationManager;
 use codex_core::ModelProviderInfo;
 use codex_core::WireApi;
@@ -8,6 +7,7 @@ use codex_core::protocol::EventMsg;
 use codex_core::protocol::InputItem;
 use codex_core::protocol::Op;
 use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
+use codex_login::CodexAuth;
 use core_test_support::load_default_config_for_test;
 use core_test_support::load_sse_fixture_with_id;
 use core_test_support::wait_for_event_with_timeout;

codex-rs/core/tests/suite/stream_no_completed.rs

@@ -3,13 +3,13 @@
 
 use std::time::Duration;
 
-use codex_core::CodexAuth;
 use codex_core::ConversationManager;
 use codex_core::ModelProviderInfo;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::InputItem;
 use codex_core::protocol::Op;
 use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
+use codex_login::CodexAuth;
 use core_test_support::load_default_config_for_test;
 use core_test_support::load_sse_fixture;
 use core_test_support::load_sse_fixture_with_id;

codex-rs/exec/src/event_processor_with_human_output.rs

@@ -25,7 +25,6 @@ use codex_core::protocol::TaskCompleteEvent;
 use codex_core::protocol::TurnAbortReason;
 use codex_core::protocol::TurnDiffEvent;
 use codex_core::protocol::WebSearchBeginEvent;
-use codex_core::protocol::WebSearchEndEvent;
 use owo_colors::OwoColorize;
 use owo_colors::Style;
 use shlex::try_join;
@@ -363,9 +362,8 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                     }
                 }
             }
-            EventMsg::WebSearchBegin(WebSearchBeginEvent { call_id: _ }) => {}
-            EventMsg::WebSearchEnd(WebSearchEndEvent { call_id: _, query }) => {
-                ts_println!(self, "🌐 Searched: {query}");
+            EventMsg::WebSearchBegin(WebSearchBeginEvent { call_id: _, query }) => {
+                ts_println!(self, "🌐 {query}");
             }
             EventMsg::PatchApplyBegin(PatchApplyBeginEvent {
                 call_id,
@@ -404,16 +402,13 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                                 println!("{}", line.style(self.green));
                             }
                         }
-                        FileChange::Delete { content } => {
+                        FileChange::Delete => {
                             let header = format!(
                                 "{} {}",
                                 format_file_change(change),
                                 path.to_string_lossy()
                             );
                             println!("{}", header.style(self.magenta));
-                            for line in content.lines() {
-                                println!("{}", line.style(self.red));
-                            }
                         }
                         FileChange::Update {
                             unified_diff,
@@ -538,9 +533,6 @@ impl EventProcessor for EventProcessorWithHumanOutput {
             EventMsg::McpListToolsResponse(_) => {
                 // Currently ignored in exec output.
             }
-            EventMsg::ListCustomPromptsResponse(_) => {
-                // Currently ignored in exec output.
-            }
             EventMsg::TurnAborted(abort_reason) => match abort_reason.reason {
                 TurnAbortReason::Interrupted => {
                     ts_println!(self, "task interrupted");
@@ -563,7 +555,7 @@ fn escape_command(command: &[String]) -> String {
 fn format_file_change(change: &FileChange) -> &'static str {
     match change {
         FileChange::Add { .. } => "A",
-        FileChange::Delete { .. } => "D",
+        FileChange::Delete => "D",
         FileChange::Update {
             move_path: Some(_), ..
         } => "R",

codex-rs/exec/src/lib.rs

@@ -8,19 +8,19 @@ use std::io::Read;
 use std::path::PathBuf;
 
 pub use cli::Cli;
-use codex_core::AuthManager;
 use codex_core::BUILT_IN_OSS_MODEL_PROVIDER_ID;
 use codex_core::ConversationManager;
 use codex_core::NewConversation;
 use codex_core::config::Config;
 use codex_core::config::ConfigOverrides;
-use codex_core::git_info::get_git_repo_root;
 use codex_core::protocol::AskForApproval;
 use codex_core::protocol::Event;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::InputItem;
 use codex_core::protocol::Op;
 use codex_core::protocol::TaskCompleteEvent;
+use codex_core::util::is_inside_git_repo;
+use codex_login::AuthManager;
 use codex_ollama::DEFAULT_OSS_MODEL;
 use codex_protocol::config_types::SandboxMode;
 use event_processor_with_human_output::EventProcessorWithHumanOutput;
@@ -148,7 +148,6 @@ pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> any
         base_instructions: None,
         include_plan_tool: None,
         include_apply_patch_tool: None,
-        include_view_image_tool: None,
         disable_response_storage: oss.then_some(true),
         show_raw_agent_reasoning: oss.then_some(true),
         tools_web_search_request: None,
@@ -183,7 +182,7 @@ pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> any
     // is using.
     event_processor.print_config_summary(&config, &prompt);
 
-    if !skip_git_repo_check && get_git_repo_root(&config.cwd.to_path_buf()).is_none() {
+    if !skip_git_repo_check && !is_inside_git_repo(&config.cwd.to_path_buf()) {
         eprintln!("Not inside a trusted directory and --skip-git-repo-check was not specified.");
         std::process::exit(1);
     }

codex-rs/exec/tests/suite/common.rs

@@ -28,7 +28,7 @@ impl Respond for SeqResponder {
             Some(body) => wiremock::ResponseTemplate::new(200)
                 .insert_header("content-type", "text/event-stream")
                 .set_body_raw(
-                    load_sse_fixture_with_id_from_str(body, &format!("request_{call_num}")),
+                    load_sse_fixture_with_id_from_str(body, &format!("request_{}", call_num)),
                     "text/event-stream",
                 ),
             None => panic!("no response for {call_num}"),
@@ -63,7 +63,7 @@ pub(crate) async fn run_e2e_exec_test(cwd: &Path, response_streams: Vec<String>)
         .current_dir(cwd.clone())
         .env("CODEX_HOME", cwd.clone())
         .env("OPENAI_API_KEY", "dummy")
-        .env("OPENAI_BASE_URL", format!("{uri}/v1"))
+        .env("OPENAI_BASE_URL", format!("{}/v1", uri))
         .arg("--skip-git-repo-check")
         .arg("-s")
         .arg("danger-full-access")

codex-rs/login/Cargo.toml

@@ -9,7 +9,6 @@ workspace = true
 [dependencies]
 base64 = "0.22"
 chrono = { version = "0.4", features = ["serde"] }
-codex-core = { path = "../core" }
 codex-protocol = { path = "../protocol" }
 rand = "0.8"
 reqwest = { version = "0.12", features = ["json", "blocking"] }
@@ -17,7 +16,7 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 sha2 = "0.10"
 tempfile = "3"
-thiserror = "2.0.16"
+thiserror = "2.0.12"
 tiny_http = "0.12"
 tokio = { version = "1", features = [
     "io-std",

codex-rs/login/src/assets/success.html

@@ -2,7 +2,7 @@
 <html lang="en">
   <head>
     <meta charset="utf-8" />
-    <title>Sign into Codex</title>
+    <title>Sign into Codex CLI</title>
     <link rel="icon" href='data:image/svg+xml,%3Csvg xmlns="http://www.w3.org/2000/svg" width="32" height="32" fill="none" viewBox="0 0 32 32"%3E%3Cpath stroke="%23000" stroke-linecap="round" stroke-width="2.484" d="M22.356 19.797H17.17M9.662 12.29l1.979 3.576a.511.511 0 0 1-.005.504l-1.974 3.409M30.758 16c0 8.15-6.607 14.758-14.758 14.758-8.15 0-14.758-6.607-14.758-14.758C1.242 7.85 7.85 1.242 16 1.242c8.15 0 14.758 6.608 14.758 14.758Z"/%3E%3C/svg%3E' type="image/svg+xml">
     <style>
       .container {
@@ -135,7 +135,7 @@
           <div class="logo">
             <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" fill="none" viewBox="0 0 32 32"><path stroke="#000" stroke-linecap="round" stroke-width="2.484" d="M22.356 19.797H17.17M9.662 12.29l1.979 3.576a.511.511 0 0 1-.005.504l-1.974 3.409M30.758 16c0 8.15-6.607 14.758-14.758 14.758-8.15 0-14.758-6.607-14.758-14.758C1.242 7.85 7.85 1.242 16 1.242c8.15 0 14.758 6.608 14.758 14.758Z"></path></svg>
           </div>
-          <div class="title">Signed in to Codex</div>
+          <div class="title">Signed in to Codex CLI</div>
         </div>
         <div class="close-box" style="display: none;">
           <div class="setup-description">You may now close this page</div>

codex-rs/login/src/auth_manager.rs

@@ -0,0 +1,129 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::sync::RwLock;
+
+use crate::AuthMode;
+use crate::CodexAuth;
+
+/// Internal cached auth state.
+#[derive(Clone, Debug)]
+struct CachedAuth {
+    preferred_auth_mode: AuthMode,
+    auth: Option<CodexAuth>,
+}
+
+/// Central manager providing a single source of truth for auth.json derived
+/// authentication data. It loads once (or on preference change) and then
+/// hands out cloned `CodexAuth` values so the rest of the program has a
+/// consistent snapshot.
+///
+/// External modifications to `auth.json` will NOT be observed until
+/// `reload()` is called explicitly. This matches the design goal of avoiding
+/// different parts of the program seeing inconsistent auth data mid‑run.
+#[derive(Debug)]
+pub struct AuthManager {
+    codex_home: PathBuf,
+    inner: RwLock<CachedAuth>,
+}
+
+impl AuthManager {
+    /// Create a new manager loading the initial auth using the provided
+    /// preferred auth method. Errors loading auth are swallowed; `auth()` will
+    /// simply return `None` in that case so callers can treat it as an
+    /// unauthenticated state.
+    pub fn new(codex_home: PathBuf, preferred_auth_mode: AuthMode) -> Self {
+        let auth = crate::CodexAuth::from_codex_home(&codex_home, preferred_auth_mode)
+            .ok()
+            .flatten();
+        Self {
+            codex_home,
+            inner: RwLock::new(CachedAuth {
+                preferred_auth_mode,
+                auth,
+            }),
+        }
+    }
+
+    /// Create an AuthManager with a specific CodexAuth, for testing only.
+    pub fn from_auth_for_testing(auth: CodexAuth) -> Arc<Self> {
+        let preferred_auth_mode = auth.mode;
+        let cached = CachedAuth {
+            preferred_auth_mode,
+            auth: Some(auth),
+        };
+        Arc::new(Self {
+            codex_home: PathBuf::new(),
+            inner: RwLock::new(cached),
+        })
+    }
+
+    /// Current cached auth (clone). May be `None` if not logged in or load failed.
+    pub fn auth(&self) -> Option<CodexAuth> {
+        self.inner.read().ok().and_then(|c| c.auth.clone())
+    }
+
+    /// Preferred auth method used when (re)loading.
+    pub fn preferred_auth_method(&self) -> AuthMode {
+        self.inner
+            .read()
+            .map(|c| c.preferred_auth_mode)
+            .unwrap_or(AuthMode::ApiKey)
+    }
+
+    /// Force a reload using the existing preferred auth method. Returns
+    /// whether the auth value changed.
+    pub fn reload(&self) -> bool {
+        let preferred = self.preferred_auth_method();
+        let new_auth = crate::CodexAuth::from_codex_home(&self.codex_home, preferred)
+            .ok()
+            .flatten();
+        if let Ok(mut guard) = self.inner.write() {
+            let changed = !AuthManager::auths_equal(&guard.auth, &new_auth);
+            guard.auth = new_auth;
+            changed
+        } else {
+            false
+        }
+    }
+
+    fn auths_equal(a: &Option<CodexAuth>, b: &Option<CodexAuth>) -> bool {
+        match (a, b) {
+            (None, None) => true,
+            (Some(a), Some(b)) => a == b,
+            _ => false,
+        }
+    }
+
+    /// Convenience constructor returning an `Arc` wrapper.
+    pub fn shared(codex_home: PathBuf, preferred_auth_mode: AuthMode) -> Arc<Self> {
+        Arc::new(Self::new(codex_home, preferred_auth_mode))
+    }
+
+    /// Attempt to refresh the current auth token (if any). On success, reload
+    /// the auth state from disk so other components observe refreshed token.
+    pub async fn refresh_token(&self) -> std::io::Result<Option<String>> {
+        let auth = match self.auth() {
+            Some(a) => a,
+            None => return Ok(None),
+        };
+        match auth.refresh_token().await {
+            Ok(token) => {
+                // Reload to pick up persisted changes.
+                self.reload();
+                Ok(Some(token))
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    /// Log out by deleting the on‑disk auth.json (if present). Returns Ok(true)
+    /// if a file was removed, Ok(false) if no auth file existed. On success,
+    /// reloads the in‑memory auth cache so callers immediately observe the
+    /// unauthenticated state.
+    pub fn logout(&self) -> std::io::Result<bool> {
+        let removed = crate::logout(&self.codex_home)?;
+        // Always reload to clear any cached auth (even if file absent).
+        self.reload();
+        Ok(removed)
+    }
+}

codex-rs/login/src/lib.rs

@@ -1,21 +1,693 @@
+use chrono::DateTime;
+use chrono::Utc;
+use serde::Deserialize;
+use serde::Serialize;
+use std::env;
+use std::fs::File;
+use std::fs::OpenOptions;
+use std::fs::remove_file;
+use std::io::Read;
+use std::io::Write;
+#[cfg(unix)]
+use std::os::unix::fs::OpenOptionsExt;
+use std::path::Path;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::time::Duration;
+
+pub use crate::server::LoginServer;
+pub use crate::server::ServerOptions;
+pub use crate::server::ShutdownHandle;
+pub use crate::server::run_login_server;
+pub use crate::token_data::TokenData;
+use crate::token_data::parse_id_token;
+
+mod auth_manager;
 mod pkce;
 mod server;
+mod token_data;
 
-pub use server::LoginServer;
-pub use server::ServerOptions;
-pub use server::ShutdownHandle;
-pub use server::run_login_server;
-
-// Re-export commonly used auth types and helpers from codex-core for compatibility
-pub use codex_core::AuthManager;
-pub use codex_core::CodexAuth;
-pub use codex_core::auth::AuthDotJson;
-pub use codex_core::auth::CLIENT_ID;
-pub use codex_core::auth::OPENAI_API_KEY_ENV_VAR;
-pub use codex_core::auth::get_auth_file;
-pub use codex_core::auth::login_with_api_key;
-pub use codex_core::auth::logout;
-pub use codex_core::auth::try_read_auth_json;
-pub use codex_core::auth::write_auth_json;
-pub use codex_core::token_data::TokenData;
+pub const CLIENT_ID: &str = "app_EMoamEEZ73f0CkXaXp7hrann";
+pub const OPENAI_API_KEY_ENV_VAR: &str = "OPENAI_API_KEY";
+pub use auth_manager::AuthManager;
 pub use codex_protocol::mcp_protocol::AuthMode;
+
+#[derive(Debug, Clone)]
+pub struct CodexAuth {
+    pub mode: AuthMode,
+
+    api_key: Option<String>,
+    auth_dot_json: Arc<Mutex<Option<AuthDotJson>>>,
+    auth_file: PathBuf,
+}
+
+impl PartialEq for CodexAuth {
+    fn eq(&self, other: &Self) -> bool {
+        self.mode == other.mode
+    }
+}
+
+impl CodexAuth {
+    pub fn from_api_key(api_key: &str) -> Self {
+        Self {
+            api_key: Some(api_key.to_owned()),
+            mode: AuthMode::ApiKey,
+            auth_file: PathBuf::new(),
+            auth_dot_json: Arc::new(Mutex::new(None)),
+        }
+    }
+
+    pub async fn refresh_token(&self) -> Result<String, std::io::Error> {
+        let token_data = self
+            .get_current_token_data()
+            .ok_or(std::io::Error::other("Token data is not available."))?;
+        let token = token_data.refresh_token;
+
+        let refresh_response = try_refresh_token(token)
+            .await
+            .map_err(std::io::Error::other)?;
+
+        let updated = update_tokens(
+            &self.auth_file,
+            refresh_response.id_token,
+            refresh_response.access_token,
+            refresh_response.refresh_token,
+        )
+        .await?;
+
+        if let Ok(mut auth_lock) = self.auth_dot_json.lock() {
+            *auth_lock = Some(updated.clone());
+        }
+
+        let access = match updated.tokens {
+            Some(t) => t.access_token,
+            None => {
+                return Err(std::io::Error::other(
+                    "Token data is not available after refresh.",
+                ));
+            }
+        };
+        Ok(access)
+    }
+
+    /// Loads the available auth information from the auth.json or
+    /// OPENAI_API_KEY environment variable.
+    pub fn from_codex_home(
+        codex_home: &Path,
+        preferred_auth_method: AuthMode,
+    ) -> std::io::Result<Option<CodexAuth>> {
+        load_auth(codex_home, true, preferred_auth_method)
+    }
+
+    pub async fn get_token_data(&self) -> Result<TokenData, std::io::Error> {
+        let auth_dot_json: Option<AuthDotJson> = self.get_current_auth_json();
+        match auth_dot_json {
+            Some(AuthDotJson {
+                tokens: Some(mut tokens),
+                last_refresh: Some(last_refresh),
+                ..
+            }) => {
+                if last_refresh < Utc::now() - chrono::Duration::days(28) {
+                    let refresh_response = tokio::time::timeout(
+                        Duration::from_secs(60),
+                        try_refresh_token(tokens.refresh_token.clone()),
+                    )
+                    .await
+                    .map_err(|_| {
+                        std::io::Error::other("timed out while refreshing OpenAI API key")
+                    })?
+                    .map_err(std::io::Error::other)?;
+
+                    let updated_auth_dot_json = update_tokens(
+                        &self.auth_file,
+                        refresh_response.id_token,
+                        refresh_response.access_token,
+                        refresh_response.refresh_token,
+                    )
+                    .await?;
+
+                    tokens = updated_auth_dot_json
+                        .tokens
+                        .clone()
+                        .ok_or(std::io::Error::other(
+                            "Token data is not available after refresh.",
+                        ))?;
+
+                    #[expect(clippy::unwrap_used)]
+                    let mut auth_lock = self.auth_dot_json.lock().unwrap();
+                    *auth_lock = Some(updated_auth_dot_json);
+                }
+
+                Ok(tokens)
+            }
+            _ => Err(std::io::Error::other("Token data is not available.")),
+        }
+    }
+
+    pub async fn get_token(&self) -> Result<String, std::io::Error> {
+        match self.mode {
+            AuthMode::ApiKey => Ok(self.api_key.clone().unwrap_or_default()),
+            AuthMode::ChatGPT => {
+                let id_token = self.get_token_data().await?.access_token;
+
+                Ok(id_token)
+            }
+        }
+    }
+
+    pub fn get_account_id(&self) -> Option<String> {
+        self.get_current_token_data()
+            .and_then(|t| t.account_id.clone())
+    }
+
+    pub fn get_plan_type(&self) -> Option<String> {
+        self.get_current_token_data()
+            .and_then(|t| t.id_token.chatgpt_plan_type.as_ref().map(|p| p.as_string()))
+    }
+
+    fn get_current_auth_json(&self) -> Option<AuthDotJson> {
+        #[expect(clippy::unwrap_used)]
+        self.auth_dot_json.lock().unwrap().clone()
+    }
+
+    fn get_current_token_data(&self) -> Option<TokenData> {
+        self.get_current_auth_json().and_then(|t| t.tokens.clone())
+    }
+
+    /// Consider this private to integration tests.
+    pub fn create_dummy_chatgpt_auth_for_testing() -> Self {
+        let auth_dot_json = AuthDotJson {
+            openai_api_key: None,
+            tokens: Some(TokenData {
+                id_token: Default::default(),
+                access_token: "Access Token".to_string(),
+                refresh_token: "test".to_string(),
+                account_id: Some("account_id".to_string()),
+            }),
+            last_refresh: Some(Utc::now()),
+        };
+
+        let auth_dot_json = Arc::new(Mutex::new(Some(auth_dot_json)));
+        Self {
+            api_key: None,
+            mode: AuthMode::ChatGPT,
+            auth_file: PathBuf::new(),
+            auth_dot_json,
+        }
+    }
+}
+
+fn load_auth(
+    codex_home: &Path,
+    include_env_var: bool,
+    preferred_auth_method: AuthMode,
+) -> std::io::Result<Option<CodexAuth>> {
+    // First, check to see if there is a valid auth.json file. If not, we fall
+    // back to AuthMode::ApiKey using the OPENAI_API_KEY environment variable
+    // (if it is set).
+    let auth_file = get_auth_file(codex_home);
+    let auth_dot_json = match try_read_auth_json(&auth_file) {
+        Ok(auth) => auth,
+        // If auth.json does not exist, try to read the OPENAI_API_KEY from the
+        // environment variable.
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound && include_env_var => {
+            return match read_openai_api_key_from_env() {
+                Some(api_key) => Ok(Some(CodexAuth::from_api_key(&api_key))),
+                None => Ok(None),
+            };
+        }
+        // Though if auth.json exists but is malformed, do not fall back to the
+        // env var because the user may be expecting to use AuthMode::ChatGPT.
+        Err(e) => {
+            return Err(e);
+        }
+    };
+
+    let AuthDotJson {
+        openai_api_key: auth_json_api_key,
+        tokens,
+        last_refresh,
+    } = auth_dot_json;
+
+    // If the auth.json has an API key AND does not appear to be on a plan that
+    // should prefer AuthMode::ChatGPT, use AuthMode::ApiKey.
+    if let Some(api_key) = &auth_json_api_key {
+        // Should any of these be AuthMode::ChatGPT with the api_key set?
+        // Does AuthMode::ChatGPT indicate that there is an auth.json that is
+        // "refreshable" even if we are using the API key for auth?
+        match &tokens {
+            Some(tokens) => {
+                if tokens.should_use_api_key(preferred_auth_method, tokens.is_openai_email()) {
+                    return Ok(Some(CodexAuth::from_api_key(api_key)));
+                } else {
+                    // Ignore the API key and fall through to ChatGPT auth.
+                }
+            }
+            None => {
+                // We have an API key but no tokens in the auth.json file.
+                // Perhaps the user ran `codex login --api-key <KEY>` or updated
+                // auth.json by hand. Either way, let's assume they are trying
+                // to use their API key.
+                return Ok(Some(CodexAuth::from_api_key(api_key)));
+            }
+        }
+    }
+
+    // For the AuthMode::ChatGPT variant, perhaps neither api_key nor
+    // openai_api_key should exist?
+    Ok(Some(CodexAuth {
+        api_key: None,
+        mode: AuthMode::ChatGPT,
+        auth_file,
+        auth_dot_json: Arc::new(Mutex::new(Some(AuthDotJson {
+            openai_api_key: None,
+            tokens,
+            last_refresh,
+        }))),
+    }))
+}
+
+fn read_openai_api_key_from_env() -> Option<String> {
+    env::var(OPENAI_API_KEY_ENV_VAR)
+        .ok()
+        .filter(|s| !s.is_empty())
+}
+
+pub fn get_auth_file(codex_home: &Path) -> PathBuf {
+    codex_home.join("auth.json")
+}
+
+/// Delete the auth.json file inside `codex_home` if it exists. Returns `Ok(true)`
+/// if a file was removed, `Ok(false)` if no auth file was present.
+pub fn logout(codex_home: &Path) -> std::io::Result<bool> {
+    let auth_file = get_auth_file(codex_home);
+    match remove_file(&auth_file) {
+        Ok(_) => Ok(true),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(false),
+        Err(err) => Err(err),
+    }
+}
+
+pub fn login_with_api_key(codex_home: &Path, api_key: &str) -> std::io::Result<()> {
+    let auth_dot_json = AuthDotJson {
+        openai_api_key: Some(api_key.to_string()),
+        tokens: None,
+        last_refresh: None,
+    };
+    write_auth_json(&get_auth_file(codex_home), &auth_dot_json)
+}
+
+/// Attempt to read and refresh the `auth.json` file in the given `CODEX_HOME` directory.
+/// Returns the full AuthDotJson structure after refreshing if necessary.
+pub fn try_read_auth_json(auth_file: &Path) -> std::io::Result<AuthDotJson> {
+    let mut file = File::open(auth_file)?;
+    let mut contents = String::new();
+    file.read_to_string(&mut contents)?;
+    let auth_dot_json: AuthDotJson = serde_json::from_str(&contents)?;
+
+    Ok(auth_dot_json)
+}
+
+fn write_auth_json(auth_file: &Path, auth_dot_json: &AuthDotJson) -> std::io::Result<()> {
+    let json_data = serde_json::to_string_pretty(auth_dot_json)?;
+    let mut options = OpenOptions::new();
+    options.truncate(true).write(true).create(true);
+    #[cfg(unix)]
+    {
+        options.mode(0o600);
+    }
+    let mut file = options.open(auth_file)?;
+    file.write_all(json_data.as_bytes())?;
+    file.flush()?;
+    Ok(())
+}
+
+async fn update_tokens(
+    auth_file: &Path,
+    id_token: String,
+    access_token: Option<String>,
+    refresh_token: Option<String>,
+) -> std::io::Result<AuthDotJson> {
+    let mut auth_dot_json = try_read_auth_json(auth_file)?;
+
+    let tokens = auth_dot_json.tokens.get_or_insert_with(TokenData::default);
+    tokens.id_token = parse_id_token(&id_token).map_err(std::io::Error::other)?;
+    if let Some(access_token) = access_token {
+        tokens.access_token = access_token.to_string();
+    }
+    if let Some(refresh_token) = refresh_token {
+        tokens.refresh_token = refresh_token.to_string();
+    }
+    auth_dot_json.last_refresh = Some(Utc::now());
+    write_auth_json(auth_file, &auth_dot_json)?;
+    Ok(auth_dot_json)
+}
+
+async fn try_refresh_token(refresh_token: String) -> std::io::Result<RefreshResponse> {
+    let refresh_request = RefreshRequest {
+        client_id: CLIENT_ID,
+        grant_type: "refresh_token",
+        refresh_token,
+        scope: "openid profile email",
+    };
+
+    let client = reqwest::Client::new();
+    let response = client
+        .post("https://auth.openai.com/oauth/token")
+        .header("Content-Type", "application/json")
+        .json(&refresh_request)
+        .send()
+        .await
+        .map_err(std::io::Error::other)?;
+
+    if response.status().is_success() {
+        let refresh_response = response
+            .json::<RefreshResponse>()
+            .await
+            .map_err(std::io::Error::other)?;
+        Ok(refresh_response)
+    } else {
+        Err(std::io::Error::other(format!(
+            "Failed to refresh token: {}",
+            response.status()
+        )))
+    }
+}
+
+#[derive(Serialize)]
+struct RefreshRequest {
+    client_id: &'static str,
+    grant_type: &'static str,
+    refresh_token: String,
+    scope: &'static str,
+}
+
+#[derive(Deserialize, Clone)]
+struct RefreshResponse {
+    id_token: String,
+    access_token: Option<String>,
+    refresh_token: Option<String>,
+}
+
+/// Expected structure for $CODEX_HOME/auth.json.
+#[derive(Deserialize, Serialize, Clone, Debug, PartialEq)]
+pub struct AuthDotJson {
+    #[serde(rename = "OPENAI_API_KEY")]
+    pub openai_api_key: Option<String>,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tokens: Option<TokenData>,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub last_refresh: Option<DateTime<Utc>>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::token_data::IdTokenInfo;
+    use crate::token_data::KnownPlan;
+    use crate::token_data::PlanType;
+    use base64::Engine;
+    use pretty_assertions::assert_eq;
+    use serde_json::json;
+    use tempfile::tempdir;
+
+    const LAST_REFRESH: &str = "2025-08-06T20:41:36.232376Z";
+
+    #[test]
+    fn writes_api_key_and_loads_auth() {
+        let dir = tempdir().unwrap();
+        login_with_api_key(dir.path(), "sk-test-key").unwrap();
+        let auth = load_auth(dir.path(), false, AuthMode::ChatGPT)
+            .unwrap()
+            .unwrap();
+        assert_eq!(auth.mode, AuthMode::ApiKey);
+        assert_eq!(auth.api_key.as_deref(), Some("sk-test-key"));
+    }
+
+    #[test]
+    fn loads_from_env_var_if_env_var_exists() {
+        let dir = tempdir().unwrap();
+
+        let env_var = std::env::var(OPENAI_API_KEY_ENV_VAR);
+
+        if let Ok(env_var) = env_var {
+            let auth = load_auth(dir.path(), true, AuthMode::ChatGPT)
+                .unwrap()
+                .unwrap();
+            assert_eq!(auth.mode, AuthMode::ApiKey);
+            assert_eq!(auth.api_key, Some(env_var));
+        }
+    }
+
+    #[tokio::test]
+    async fn roundtrip_auth_dot_json() {
+        let codex_home = tempdir().unwrap();
+        write_auth_file(
+            AuthFileParams {
+                openai_api_key: None,
+                chatgpt_plan_type: "pro".to_string(),
+            },
+            codex_home.path(),
+        )
+        .expect("failed to write auth file");
+
+        let file = get_auth_file(codex_home.path());
+        let auth_dot_json = try_read_auth_json(&file).unwrap();
+        write_auth_json(&file, &auth_dot_json).unwrap();
+
+        let same_auth_dot_json = try_read_auth_json(&file).unwrap();
+        assert_eq!(auth_dot_json, same_auth_dot_json);
+    }
+
+    #[tokio::test]
+    async fn pro_account_with_no_api_key_uses_chatgpt_auth() {
+        let codex_home = tempdir().unwrap();
+        let fake_jwt = write_auth_file(
+            AuthFileParams {
+                openai_api_key: None,
+                chatgpt_plan_type: "pro".to_string(),
+            },
+            codex_home.path(),
+        )
+        .expect("failed to write auth file");
+
+        let CodexAuth {
+            api_key,
+            mode,
+            auth_dot_json,
+            auth_file: _,
+        } = load_auth(codex_home.path(), false, AuthMode::ChatGPT)
+            .unwrap()
+            .unwrap();
+        assert_eq!(None, api_key);
+        assert_eq!(AuthMode::ChatGPT, mode);
+
+        let guard = auth_dot_json.lock().unwrap();
+        let auth_dot_json = guard.as_ref().expect("AuthDotJson should exist");
+        assert_eq!(
+            &AuthDotJson {
+                openai_api_key: None,
+                tokens: Some(TokenData {
+                    id_token: IdTokenInfo {
+                        email: Some("user@example.com".to_string()),
+                        chatgpt_plan_type: Some(PlanType::Known(KnownPlan::Pro)),
+                        raw_jwt: fake_jwt,
+                    },
+                    access_token: "test-access-token".to_string(),
+                    refresh_token: "test-refresh-token".to_string(),
+                    account_id: None,
+                }),
+                last_refresh: Some(
+                    DateTime::parse_from_rfc3339(LAST_REFRESH)
+                        .unwrap()
+                        .with_timezone(&Utc)
+                ),
+            },
+            auth_dot_json
+        )
+    }
+
+    /// Even if the OPENAI_API_KEY is set in auth.json, if the plan is not in
+    /// [`TokenData::is_plan_that_should_use_api_key`], it should use
+    /// [`AuthMode::ChatGPT`].
+    #[tokio::test]
+    async fn pro_account_with_api_key_still_uses_chatgpt_auth() {
+        let codex_home = tempdir().unwrap();
+        let fake_jwt = write_auth_file(
+            AuthFileParams {
+                openai_api_key: Some("sk-test-key".to_string()),
+                chatgpt_plan_type: "pro".to_string(),
+            },
+            codex_home.path(),
+        )
+        .expect("failed to write auth file");
+
+        let CodexAuth {
+            api_key,
+            mode,
+            auth_dot_json,
+            auth_file: _,
+        } = load_auth(codex_home.path(), false, AuthMode::ChatGPT)
+            .unwrap()
+            .unwrap();
+        assert_eq!(None, api_key);
+        assert_eq!(AuthMode::ChatGPT, mode);
+
+        let guard = auth_dot_json.lock().unwrap();
+        let auth_dot_json = guard.as_ref().expect("AuthDotJson should exist");
+        assert_eq!(
+            &AuthDotJson {
+                openai_api_key: None,
+                tokens: Some(TokenData {
+                    id_token: IdTokenInfo {
+                        email: Some("user@example.com".to_string()),
+                        chatgpt_plan_type: Some(PlanType::Known(KnownPlan::Pro)),
+                        raw_jwt: fake_jwt,
+                    },
+                    access_token: "test-access-token".to_string(),
+                    refresh_token: "test-refresh-token".to_string(),
+                    account_id: None,
+                }),
+                last_refresh: Some(
+                    DateTime::parse_from_rfc3339(LAST_REFRESH)
+                        .unwrap()
+                        .with_timezone(&Utc)
+                ),
+            },
+            auth_dot_json
+        )
+    }
+
+    /// If the OPENAI_API_KEY is set in auth.json and it is an enterprise
+    /// account, then it should use [`AuthMode::ApiKey`].
+    #[tokio::test]
+    async fn enterprise_account_with_api_key_uses_chatgpt_auth() {
+        let codex_home = tempdir().unwrap();
+        write_auth_file(
+            AuthFileParams {
+                openai_api_key: Some("sk-test-key".to_string()),
+                chatgpt_plan_type: "enterprise".to_string(),
+            },
+            codex_home.path(),
+        )
+        .expect("failed to write auth file");
+
+        let CodexAuth {
+            api_key,
+            mode,
+            auth_dot_json,
+            auth_file: _,
+        } = load_auth(codex_home.path(), false, AuthMode::ChatGPT)
+            .unwrap()
+            .unwrap();
+        assert_eq!(Some("sk-test-key".to_string()), api_key);
+        assert_eq!(AuthMode::ApiKey, mode);
+
+        let guard = auth_dot_json.lock().expect("should unwrap");
+        assert!(guard.is_none(), "auth_dot_json should be None");
+    }
+
+    struct AuthFileParams {
+        openai_api_key: Option<String>,
+        chatgpt_plan_type: String,
+    }
+
+    fn write_auth_file(params: AuthFileParams, codex_home: &Path) -> std::io::Result<String> {
+        let auth_file = get_auth_file(codex_home);
+        // Create a minimal valid JWT for the id_token field.
+        #[derive(Serialize)]
+        struct Header {
+            alg: &'static str,
+            typ: &'static str,
+        }
+        let header = Header {
+            alg: "none",
+            typ: "JWT",
+        };
+        let payload = serde_json::json!({
+            "email": "user@example.com",
+            "email_verified": true,
+            "https://api.openai.com/auth": {
+                "chatgpt_account_id": "bc3618e3-489d-4d49-9362-1561dc53ba53",
+                "chatgpt_plan_type": params.chatgpt_plan_type,
+                "chatgpt_user_id": "user-12345",
+                "user_id": "user-12345",
+            }
+        });
+        let b64 = |b: &[u8]| base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(b);
+        let header_b64 = b64(&serde_json::to_vec(&header)?);
+        let payload_b64 = b64(&serde_json::to_vec(&payload)?);
+        let signature_b64 = b64(b"sig");
+        let fake_jwt = format!("{header_b64}.{payload_b64}.{signature_b64}");
+
+        let auth_json_data = json!({
+            "OPENAI_API_KEY": params.openai_api_key,
+            "tokens": {
+                "id_token": fake_jwt,
+                "access_token": "test-access-token",
+                "refresh_token": "test-refresh-token"
+            },
+            "last_refresh": LAST_REFRESH,
+        });
+        let auth_json = serde_json::to_string_pretty(&auth_json_data)?;
+        std::fs::write(auth_file, auth_json)?;
+
+        Ok(fake_jwt)
+    }
+
+    #[test]
+    fn id_token_info_handles_missing_fields() {
+        // Payload without email or plan should yield None values.
+        let header = serde_json::json!({"alg": "none", "typ": "JWT"});
+        let payload = serde_json::json!({"sub": "123"});
+        let header_b64 = base64::engine::general_purpose::URL_SAFE_NO_PAD
+            .encode(serde_json::to_vec(&header).unwrap());
+        let payload_b64 = base64::engine::general_purpose::URL_SAFE_NO_PAD
+            .encode(serde_json::to_vec(&payload).unwrap());
+        let signature_b64 = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(b"sig");
+        let jwt = format!("{header_b64}.{payload_b64}.{signature_b64}");
+
+        let info = parse_id_token(&jwt).expect("should parse");
+        assert!(info.email.is_none());
+        assert!(info.chatgpt_plan_type.is_none());
+    }
+
+    #[tokio::test]
+    async fn loads_api_key_from_auth_json() {
+        let dir = tempdir().unwrap();
+        let auth_file = dir.path().join("auth.json");
+        std::fs::write(
+            auth_file,
+            r#"
+        {
+            "OPENAI_API_KEY": "sk-test-key",
+            "tokens": null,
+            "last_refresh": null
+        }
+        "#,
+        )
+        .unwrap();
+
+        let auth = load_auth(dir.path(), false, AuthMode::ChatGPT)
+            .unwrap()
+            .unwrap();
+        assert_eq!(auth.mode, AuthMode::ApiKey);
+        assert_eq!(auth.api_key, Some("sk-test-key".to_string()));
+
+        assert!(auth.get_token_data().await.is_err());
+    }
+
+    #[test]
+    fn logout_removes_auth_file() -> Result<(), std::io::Error> {
+        let dir = tempdir()?;
+        login_with_api_key(dir.path(), "sk-test-key")?;
+        assert!(dir.path().join("auth.json").exists());
+        let removed = logout(dir.path())?;
+        assert!(removed);
+        assert!(!dir.path().join("auth.json").exists());
+        Ok(())
+    }
+}

codex-rs/login/src/server.rs

@@ -5,14 +5,12 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use std::thread;
 
+use crate::AuthDotJson;
+use crate::get_auth_file;
 use crate::pkce::PkceCodes;
 use crate::pkce::generate_pkce;
 use base64::Engine;
 use chrono::Utc;
-use codex_core::auth::AuthDotJson;
-use codex_core::auth::get_auth_file;
-use codex_core::token_data::TokenData;
-use codex_core::token_data::parse_id_token;
 use rand::RngCore;
 use tiny_http::Header;
 use tiny_http::Request;
@@ -376,8 +374,10 @@ async fn persist_tokens_async(
         if let Some(key) = api_key {
             auth.openai_api_key = Some(key);
         }
-        let tokens = auth.tokens.get_or_insert_with(TokenData::default);
-        tokens.id_token = parse_id_token(&id_token).map_err(io::Error::other)?;
+        let tokens = auth
+            .tokens
+            .get_or_insert_with(crate::token_data::TokenData::default);
+        tokens.id_token = crate::token_data::parse_id_token(&id_token).map_err(io::Error::other)?;
         // Persist chatgpt_account_id if present in claims
         if let Some(acc) = jwt_auth_claims(&id_token)
             .get("chatgpt_account_id")
@@ -392,14 +392,14 @@ async fn persist_tokens_async(
             tokens.refresh_token = rt;
         }
         auth.last_refresh = Some(Utc::now());
-        codex_core::auth::write_auth_json(&auth_file, &auth)
+        super::write_auth_json(&auth_file, &auth)
     })
     .await
     .map_err(|e| io::Error::other(format!("persist task failed: {e}")))?
 }
 
 fn read_or_default(path: &Path) -> AuthDotJson {
-    match codex_core::auth::try_read_auth_json(path) {
+    match super::try_read_auth_json(path) {
         Ok(auth) => auth,
         Err(_) => AuthDotJson {
             openai_api_key: None,

codex-rs/login/src/token_data.rs

@@ -3,7 +3,7 @@ use serde::Deserialize;
 use serde::Serialize;
 use thiserror::Error;
 
-use codex_protocol::mcp_protocol::AuthMode;
+use crate::AuthMode;
 
 #[derive(Deserialize, Serialize, Clone, Debug, PartialEq, Default)]
 pub struct TokenData {
@@ -58,7 +58,7 @@ pub struct IdTokenInfo {
     pub email: Option<String>,
     /// The ChatGPT subscription plan type
     /// (e.g., "free", "plus", "pro", "business", "enterprise", "edu").
-    /// (Note: values may vary by backend.)
+    /// (Note: ae has not verified that those are the exact values.)
     pub(crate) chatgpt_plan_type: Option<PlanType>,
     pub raw_jwt: String,
 }
@@ -137,7 +137,7 @@ pub enum IdTokenInfoError {
     Json(#[from] serde_json::Error),
 }
 
-pub fn parse_id_token(id_token: &str) -> Result<IdTokenInfo, IdTokenInfoError> {
+pub(crate) fn parse_id_token(id_token: &str) -> Result<IdTokenInfo, IdTokenInfoError> {
     // JWT format: header.payload.signature
     let mut parts = id_token.split('.');
     let (_header_b64, payload_b64, _sig_b64) = match (parts.next(), parts.next(), parts.next()) {
@@ -204,33 +204,9 @@ mod tests {
 
         let info = parse_id_token(&fake_jwt).expect("should parse");
         assert_eq!(info.email.as_deref(), Some("user@example.com"));
-        assert_eq!(info.get_chatgpt_plan_type().as_deref(), Some("Pro"));
-    }
-
-    #[test]
-    fn id_token_info_handles_missing_fields() {
-        #[derive(Serialize)]
-        struct Header {
-            alg: &'static str,
-            typ: &'static str,
-        }
-        let header = Header {
-            alg: "none",
-            typ: "JWT",
-        };
-        let payload = serde_json::json!({ "sub": "123" });
-
-        fn b64url_no_pad(bytes: &[u8]) -> String {
-            base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(bytes)
-        }
-
-        let header_b64 = b64url_no_pad(&serde_json::to_vec(&header).unwrap());
-        let payload_b64 = b64url_no_pad(&serde_json::to_vec(&payload).unwrap());
-        let signature_b64 = b64url_no_pad(b"sig");
-        let fake_jwt = format!("{header_b64}.{payload_b64}.{signature_b64}");
-
-        let info = parse_id_token(&fake_jwt).expect("should parse");
-        assert!(info.email.is_none());
-        assert!(info.get_chatgpt_plan_type().is_none());
+        assert_eq!(
+            info.chatgpt_plan_type,
+            Some(PlanType::Known(KnownPlan::Pro))
+        );
     }
 }

codex-rs/mcp-client/src/mcp_client.rs

@@ -129,7 +129,10 @@ impl McpClient {
                                 error!("failed to write newline to child stdin");
                                 break;
                             }
-                            // No explicit flush needed on a pipe; write_all is sufficient.
+                            if stdin.flush().await.is_err() {
+                                error!("failed to flush child stdin");
+                                break;
+                            }
                         }
                         Err(e) => error!("failed to serialize JSONRPCMessage: {e}"),
                     }
@@ -362,11 +365,7 @@ impl McpClient {
             }
         };
 
-        let tx_opt = {
-            let mut guard = pending.lock().await;
-            guard.remove(&id)
-        };
-        if let Some(tx) = tx_opt {
+        if let Some(tx) = pending.lock().await.remove(&id) {
             // Ignore send errors – the receiver might have been dropped.
             let _ = tx.send(JSONRPCMessage::Response(resp));
         } else {
@@ -384,11 +383,7 @@ impl McpClient {
             RequestId::String(_) => return, // see comment above
         };
 
-        let tx_opt = {
-            let mut guard = pending.lock().await;
-            guard.remove(&id)
-        };
-        if let Some(tx) = tx_opt {
+        if let Some(tx) = pending.lock().await.remove(&id) {
             let _ = tx.send(JSONRPCMessage::Error(err));
         }
     }

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

@@ -3,20 +3,18 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Duration;
 
-use codex_core::AuthManager;
 use codex_core::CodexConversation;
 use codex_core::ConversationManager;
 use codex_core::NewConversation;
 use codex_core::config::Config;
 use codex_core::config::ConfigOverrides;
-use codex_core::config::ConfigToml;
-use codex_core::config::load_config_as_toml;
 use codex_core::git_info::git_diff_to_remote;
 use codex_core::protocol::ApplyPatchApprovalRequestEvent;
 use codex_core::protocol::Event;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::ExecApprovalRequestEvent;
 use codex_core::protocol::ReviewDecision;
+use codex_login::AuthManager;
 use codex_protocol::mcp_protocol::AuthMode;
 use codex_protocol::mcp_protocol::GitDiffToRemoteResponse;
 use mcp_types::JSONRPCErrorError;
@@ -31,9 +29,9 @@ use crate::error_code::INVALID_REQUEST_ERROR_CODE;
 use crate::json_to_toml::json_to_toml;
 use crate::outgoing_message::OutgoingMessageSender;
 use crate::outgoing_message::OutgoingNotification;
-use codex_core::auth::CLIENT_ID;
 use codex_core::protocol::InputItem as CoreInputItem;
 use codex_core::protocol::Op;
+use codex_login::CLIENT_ID;
 use codex_login::ServerOptions as LoginServerOptions;
 use codex_login::ShutdownHandle;
 use codex_login::run_login_server;
@@ -48,7 +46,6 @@ use codex_protocol::mcp_protocol::ConversationId;
 use codex_protocol::mcp_protocol::EXEC_COMMAND_APPROVAL_METHOD;
 use codex_protocol::mcp_protocol::ExecCommandApprovalParams;
 use codex_protocol::mcp_protocol::ExecCommandApprovalResponse;
-use codex_protocol::mcp_protocol::GetConfigTomlResponse;
 use codex_protocol::mcp_protocol::InputItem as WireInputItem;
 use codex_protocol::mcp_protocol::InterruptConversationParams;
 use codex_protocol::mcp_protocol::InterruptConversationResponse;
@@ -149,9 +146,6 @@ impl CodexMessageProcessor {
             ClientRequest::GetAuthStatus { request_id, params } => {
                 self.get_auth_status(request_id, params).await;
             }
-            ClientRequest::GetConfigToml { request_id } => {
-                self.get_config_toml(request_id).await;
-            }
         }
     }
 
@@ -360,62 +354,6 @@ impl CodexMessageProcessor {
         self.outgoing.send_response(request_id, response).await;
     }
 
-    async fn get_config_toml(&self, request_id: RequestId) {
-        let toml_value = match load_config_as_toml(&self.config.codex_home) {
-            Ok(val) => val,
-            Err(err) => {
-                let error = JSONRPCErrorError {
-                    code: INTERNAL_ERROR_CODE,
-                    message: format!("failed to load config.toml: {err}"),
-                    data: None,
-                };
-                self.outgoing.send_error(request_id, error).await;
-                return;
-            }
-        };
-
-        let cfg: ConfigToml = match toml_value.try_into() {
-            Ok(cfg) => cfg,
-            Err(err) => {
-                let error = JSONRPCErrorError {
-                    code: INTERNAL_ERROR_CODE,
-                    message: format!("failed to parse config.toml: {err}"),
-                    data: None,
-                };
-                self.outgoing.send_error(request_id, error).await;
-                return;
-            }
-        };
-
-        let profiles: HashMap<String, codex_protocol::config_types::ConfigProfile> = cfg
-            .profiles
-            .into_iter()
-            .map(|(k, v)| {
-                (
-                    k,
-                    // Define this explicitly here to avoid the need to
-                    // implement `From<codex_core::config_profile::ConfigProfile>`
-                    // for the `ConfigProfile` type and introduce a dependency on codex_core
-                    codex_protocol::config_types::ConfigProfile {
-                        model: v.model,
-                        approval_policy: v.approval_policy,
-                        model_reasoning_effort: v.model_reasoning_effort,
-                    },
-                )
-            })
-            .collect();
-
-        let response = GetConfigTomlResponse {
-            approval_policy: cfg.approval_policy,
-            sandbox_mode: cfg.sandbox_mode,
-            model_reasoning_effort: cfg.model_reasoning_effort,
-            profile: cfg.profile,
-            profiles: Some(profiles),
-        };
-
-        self.outgoing.send_response(request_id, response).await;
-    }
-
     async fn process_new_conversation(&self, request_id: RequestId, params: NewConversationParams) {
         let config = match derive_config_from_params(params, self.codex_linux_sandbox_exe.clone()) {
             Ok(config) => config,
@@ -798,7 +736,6 @@ fn derive_config_from_params(
         base_instructions,
         include_plan_tool,
         include_apply_patch_tool,
-        include_view_image_tool: None,
         disable_response_storage: None,
         show_raw_agent_reasoning: None,
         tools_web_search_request: None,

codex-rs/mcp-server/src/codex_tool_config.rs

@@ -161,7 +161,6 @@ impl CodexToolCallParam {
             base_instructions,
             include_plan_tool,
             include_apply_patch_tool: None,
-            include_view_image_tool: None,
             disable_response_storage: None,
             show_raw_agent_reasoning: None,
             tools_web_search_request: None,

codex-rs/mcp-server/src/codex_tool_runner.rs

@@ -264,7 +264,6 @@ async fn run_codex_tool_session_inner(
                     | EventMsg::McpToolCallBegin(_)
                     | EventMsg::McpToolCallEnd(_)
                     | EventMsg::McpListToolsResponse(_)
-                    | EventMsg::ListCustomPromptsResponse(_)
                     | EventMsg::ExecCommandBegin(_)
                     | EventMsg::ExecCommandOutputDelta(_)
                     | EventMsg::ExecCommandEnd(_)
@@ -274,7 +273,6 @@ async fn run_codex_tool_session_inner(
                     | EventMsg::PatchApplyEnd(_)
                     | EventMsg::TurnDiff(_)
                     | EventMsg::WebSearchBegin(_)
-                    | EventMsg::WebSearchEnd(_)
                     | EventMsg::GetHistoryEntryResponse(_)
                     | EventMsg::PlanUpdate(_)
                     | EventMsg::TurnAborted(_)

codex-rs/mcp-server/src/lib.rs

@@ -59,10 +59,11 @@ pub async fn run_main(
 
     // Set up channels.
     let (incoming_tx, mut incoming_rx) = mpsc::channel::<JSONRPCMessage>(CHANNEL_CAPACITY);
-    let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded_channel::<OutgoingMessage>();
+    let (outgoing_tx, mut outgoing_rx) = mpsc::channel::<OutgoingMessage>(CHANNEL_CAPACITY);
 
     // Task: read from stdin, push to `incoming_tx`.
     let stdin_reader_handle = tokio::spawn({
+        let incoming_tx = incoming_tx.clone();
         async move {
             let stdin = io::stdin();
             let reader = BufReader::new(stdin);
@@ -134,6 +135,10 @@ pub async fn run_main(
                         error!("Failed to write newline to stdout: {e}");
                         break;
                     }
+                    if let Err(e) = stdout.flush().await {
+                        error!("Failed to flush stdout: {e}");
+                        break;
+                    }
                 }
                 Err(e) => error!("Failed to serialize JSONRPCMessage: {e}"),
             }

codex-rs/mcp-server/src/message_processor.rs

@@ -10,10 +10,10 @@ use crate::error_code::INVALID_REQUEST_ERROR_CODE;
 use crate::outgoing_message::OutgoingMessageSender;
 use codex_protocol::mcp_protocol::ClientRequest;
 
-use codex_core::AuthManager;
 use codex_core::ConversationManager;
 use codex_core::config::Config;
 use codex_core::protocol::Submission;
+use codex_login::AuthManager;
 use mcp_types::CallToolRequestParams;
 use mcp_types::CallToolResult;
 use mcp_types::ClientRequest as McpClientRequest;

codex-rs/mcp-server/src/outgoing_message.rs

@@ -24,12 +24,12 @@ use crate::error_code::INTERNAL_ERROR_CODE;
 /// Sends messages to the client and manages request callbacks.
 pub(crate) struct OutgoingMessageSender {
     next_request_id: AtomicI64,
-    sender: mpsc::UnboundedSender<OutgoingMessage>,
+    sender: mpsc::Sender<OutgoingMessage>,
     request_id_to_callback: Mutex<HashMap<RequestId, oneshot::Sender<Result>>>,
 }
 
 impl OutgoingMessageSender {
-    pub(crate) fn new(sender: mpsc::UnboundedSender<OutgoingMessage>) -> Self {
+    pub(crate) fn new(sender: mpsc::Sender<OutgoingMessage>) -> Self {
         Self {
             next_request_id: AtomicI64::new(0),
             sender,
@@ -55,7 +55,7 @@ impl OutgoingMessageSender {
             method: method.to_string(),
             params,
         });
-        let _ = self.sender.send(outgoing_message);
+        let _ = self.sender.send(outgoing_message).await;
         rx_approve
     }
 
@@ -81,7 +81,7 @@ impl OutgoingMessageSender {
         match serde_json::to_value(response) {
             Ok(result) => {
                 let outgoing_message = OutgoingMessage::Response(OutgoingResponse { id, result });
-                let _ = self.sender.send(outgoing_message);
+                let _ = self.sender.send(outgoing_message).await;
             }
             Err(err) => {
                 self.send_error(
@@ -123,24 +123,24 @@ impl OutgoingMessageSender {
     }
 
     pub(crate) async fn send_server_notification(&self, notification: ServerNotification) {
-        let method = format!("codex/event/{notification}");
+        let method = format!("codex/event/{}", notification);
         let params = match serde_json::to_value(&notification) {
             Ok(serde_json::Value::Object(mut map)) => map.remove("data"),
             _ => None,
         };
         let outgoing_message =
             OutgoingMessage::Notification(OutgoingNotification { method, params });
-        let _ = self.sender.send(outgoing_message);
+        let _ = self.sender.send(outgoing_message).await;
     }
 
     pub(crate) async fn send_notification(&self, notification: OutgoingNotification) {
         let outgoing_message = OutgoingMessage::Notification(notification);
-        let _ = self.sender.send(outgoing_message);
+        let _ = self.sender.send(outgoing_message).await;
     }
 
     pub(crate) async fn send_error(&self, id: RequestId, error: JSONRPCErrorError) {
         let outgoing_message = OutgoingMessage::Error(OutgoingError { id, error });
-        let _ = self.sender.send(outgoing_message);
+        let _ = self.sender.send(outgoing_message).await;
     }
 }
 
@@ -250,7 +250,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_send_event_as_notification() {
-        let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded_channel::<OutgoingMessage>();
+        let (outgoing_tx, mut outgoing_rx) = mpsc::channel::<OutgoingMessage>(2);
         let outgoing_message_sender = OutgoingMessageSender::new(outgoing_tx);
 
         let event = Event {
@@ -281,7 +281,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_send_event_as_notification_with_meta() {
-        let (outgoing_tx, mut outgoing_rx) = mpsc::unbounded_channel::<OutgoingMessage>();
+        let (outgoing_tx, mut outgoing_rx) = mpsc::channel::<OutgoingMessage>(2);
         let outgoing_message_sender = OutgoingMessageSender::new(outgoing_tx);
 
         let session_configured_event = SessionConfiguredEvent {

codex-rs/mcp-server/tests/common/mcp_process.rs

@@ -61,7 +61,6 @@ impl McpProcess {
 
         cmd.stdin(Stdio::piped());
         cmd.stdout(Stdio::piped());
-        cmd.stderr(Stdio::piped());
         cmd.env("CODEX_HOME", codex_home);
         cmd.env("RUST_LOG", "debug");
 
@@ -78,17 +77,6 @@ impl McpProcess {
             .take()
             .ok_or_else(|| anyhow::format_err!("mcp should have stdout fd"))?;
         let stdout = BufReader::new(stdout);
-
-        // Forward child's stderr to our stderr so failures are visible even
-        // when stdout/stderr are captured by the test harness.
-        if let Some(stderr) = process.stderr.take() {
-            let mut stderr_reader = BufReader::new(stderr).lines();
-            tokio::spawn(async move {
-                while let Ok(Some(line)) = stderr_reader.next_line().await {
-                    eprintln!("[mcp stderr] {line}");
-                }
-            });
-        }
         Ok(Self {
             next_request_id: AtomicI64::new(0),
             process,
@@ -240,11 +228,6 @@ impl McpProcess {
         self.send_request("getAuthStatus", params).await
     }
 
-    /// Send a `getConfigToml` JSON-RPC request.
-    pub async fn send_get_config_toml_request(&mut self) -> anyhow::Result<i64> {
-        self.send_request("getConfigToml", None).await
-    }
-
     /// Send a `loginChatGpt` JSON-RPC request.
     pub async fn send_login_chat_gpt_request(&mut self) -> anyhow::Result<i64> {
         self.send_request("loginChatGpt", None).await
@@ -295,7 +278,6 @@ impl McpProcess {
     }
 
     async fn send_jsonrpc_message(&mut self, message: JSONRPCMessage) -> anyhow::Result<()> {
-        eprintln!("writing message to stdin: {message:?}");
         let payload = serde_json::to_string(&message)?;
         self.stdin.write_all(payload.as_bytes()).await?;
         self.stdin.write_all(b"\n").await?;
@@ -307,15 +289,13 @@ impl McpProcess {
         let mut line = String::new();
         self.stdout.read_line(&mut line).await?;
         let message = serde_json::from_str::<JSONRPCMessage>(&line)?;
-        eprintln!("read message from stdout: {message:?}");
         Ok(message)
     }
 
     pub async fn read_stream_until_request_message(&mut self) -> anyhow::Result<JSONRPCRequest> {
-        eprintln!("in read_stream_until_request_message()");
-
         loop {
             let message = self.read_jsonrpc_message().await?;
+            eprint!("message: {message:?}");
 
             match message {
                 JSONRPCMessage::Notification(_) => {
@@ -338,10 +318,10 @@ impl McpProcess {
         &mut self,
         request_id: RequestId,
     ) -> anyhow::Result<JSONRPCResponse> {
-        eprintln!("in read_stream_until_response_message({request_id:?})");
-
         loop {
             let message = self.read_jsonrpc_message().await?;
+            eprint!("message: {message:?}");
+
             match message {
                 JSONRPCMessage::Notification(_) => {
                     eprintln!("notification: {message:?}");
@@ -367,6 +347,8 @@ impl McpProcess {
     ) -> anyhow::Result<mcp_types::JSONRPCError> {
         loop {
             let message = self.read_jsonrpc_message().await?;
+            eprint!("message: {message:?}");
+
             match message {
                 JSONRPCMessage::Notification(_) => {
                     eprintln!("notification: {message:?}");
@@ -390,10 +372,10 @@ impl McpProcess {
         &mut self,
         method: &str,
     ) -> anyhow::Result<JSONRPCNotification> {
-        eprintln!("in read_stream_until_notification_message({method})");
-
         loop {
             let message = self.read_jsonrpc_message().await?;
+            eprint!("message: {message:?}");
+
             match message {
                 JSONRPCMessage::Notification(notification) => {
                     if notification.method == method {
@@ -418,10 +400,10 @@ impl McpProcess {
     pub async fn read_stream_until_legacy_task_complete_notification(
         &mut self,
     ) -> anyhow::Result<JSONRPCNotification> {
-        eprintln!("in read_stream_until_legacy_task_complete_notification()");
-
         loop {
             let message = self.read_jsonrpc_message().await?;
+            eprint!("message: {message:?}");
+
             match message {
                 JSONRPCMessage::Notification(notification) => {
                     let is_match = if notification.method == "codex/event" {
@@ -440,8 +422,6 @@ impl McpProcess {
 
                     if is_match {
                         return Ok(notification);
-                    } else {
-                        eprintln!("ignoring notification: {notification:?}");
                     }
                 }
                 JSONRPCMessage::Request(_) => {

codex-rs/mcp-server/tests/suite/auth.rs

@@ -1,6 +1,6 @@
 use std::path::Path;
 
-use codex_core::auth::login_with_api_key;
+use codex_login::login_with_api_key;
 use codex_protocol::mcp_protocol::AuthMode;
 use codex_protocol::mcp_protocol::GetAuthStatusParams;
 use codex_protocol::mcp_protocol::GetAuthStatusResponse;

codex-rs/mcp-server/tests/suite/codex_tool.rs

@@ -30,8 +30,7 @@ use mcp_test_support::create_final_assistant_message_sse_response;
 use mcp_test_support::create_mock_chat_completions_server;
 use mcp_test_support::create_shell_sse_response;
 
-// Allow ample time on slower CI or under load to avoid flakes.
-const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(20);
+const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
 
 /// Test that a shell command that is not on the "trusted" list triggers an
 /// elicitation request to the MCP and that sending the approval runs the
@@ -53,22 +52,9 @@ async fn test_shell_command_approval_triggers_elicitation() {
 }
 
 async fn shell_command_approval_triggers_elicitation() -> anyhow::Result<()> {
-    // Use a simple, untrusted command that creates a file so we can
-    // observe a side-effect.
-    //
-    // Cross‑platform approach: run a tiny Python snippet to touch the file
-    // using `python3 -c ...` on all platforms.
+    // We use `git init` because it will not be on the "trusted" list.
+    let shell_command = vec!["git".to_string(), "init".to_string()];
     let workdir_for_shell_function_call = TempDir::new()?;
-    let created_filename = "created_by_shell_tool.txt";
-    let created_file = workdir_for_shell_function_call
-        .path()
-        .join(created_filename);
-
-    let shell_command = vec![
-        "python3".to_string(),
-        "-c".to_string(),
-        format!("import pathlib; pathlib.Path('{created_filename}').touch()"),
-    ];
 
     let McpHandle {
         process: mut mcp_process,
@@ -81,7 +67,7 @@ async fn shell_command_approval_triggers_elicitation() -> anyhow::Result<()> {
             Some(5_000),
             "call1234",
         )?,
-        create_final_assistant_message_sse_response("File created!")?,
+        create_final_assistant_message_sse_response("Enjoy your new git repo!")?,
     ])
     .await?;
 
@@ -136,7 +122,8 @@ async fn shell_command_approval_triggers_elicitation() -> anyhow::Result<()> {
     .expect("task_complete_notification timeout")
     .expect("task_complete_notification resp");
 
-    // Verify the original `codex` tool call completes and that the file was created.
+    // Verify the original `codex` tool call completes and that `git init` ran
+    // successfully.
     let codex_response = timeout(
         DEFAULT_READ_TIMEOUT,
         mcp_process.read_stream_until_response_message(RequestId::Integer(codex_request_id)),
@@ -149,7 +136,7 @@ async fn shell_command_approval_triggers_elicitation() -> anyhow::Result<()> {
             result: json!({
                 "content": [
                     {
-                        "text": "File created!",
+                        "text": "Enjoy your new git repo!",
                         "type": "text"
                     }
                 ]
@@ -158,7 +145,10 @@ async fn shell_command_approval_triggers_elicitation() -> anyhow::Result<()> {
         codex_response
     );
 
-    assert!(created_file.is_file(), "created file should exist");
+    assert!(
+        workdir_for_shell_function_call.path().join(".git").is_dir(),
+        ".git folder should have been created"
+    );
 
     Ok(())
 }

codex-rs/mcp-server/tests/suite/config.rs

@@ -1,80 +0,0 @@
-use std::collections::HashMap;
-use std::path::Path;
-
-use codex_core::protocol::AskForApproval;
-use codex_protocol::config_types::ConfigProfile;
-use codex_protocol::config_types::ReasoningEffort;
-use codex_protocol::config_types::SandboxMode;
-use codex_protocol::mcp_protocol::GetConfigTomlResponse;
-use mcp_test_support::McpProcess;
-use mcp_test_support::to_response;
-use mcp_types::JSONRPCResponse;
-use mcp_types::RequestId;
-use pretty_assertions::assert_eq;
-use tempfile::TempDir;
-use tokio::time::timeout;
-
-const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
-
-fn create_config_toml(codex_home: &Path) -> std::io::Result<()> {
-    let config_toml = codex_home.join("config.toml");
-    std::fs::write(
-        config_toml,
-        r#"
-approval_policy = "on-request"
-sandbox_mode = "workspace-write"
-model_reasoning_effort = "high"
-profile = "test"
-
-[profiles.test]
-model = "gpt-4o"
-approval_policy = "on-request"
-model_reasoning_effort = "high"
-model_reasoning_summary = "detailed"
-"#,
-    )
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn get_config_toml_returns_subset() {
-    let codex_home = TempDir::new().unwrap_or_else(|e| panic!("create tempdir: {e}"));
-    create_config_toml(codex_home.path()).expect("write config.toml");
-
-    let mut mcp = McpProcess::new(codex_home.path())
-        .await
-        .expect("spawn mcp process");
-    timeout(DEFAULT_READ_TIMEOUT, mcp.initialize())
-        .await
-        .expect("init timeout")
-        .expect("init failed");
-
-    let request_id = mcp
-        .send_get_config_toml_request()
-        .await
-        .expect("send getConfigToml");
-    let resp: JSONRPCResponse = timeout(
-        DEFAULT_READ_TIMEOUT,
-        mcp.read_stream_until_response_message(RequestId::Integer(request_id)),
-    )
-    .await
-    .expect("getConfigToml timeout")
-    .expect("getConfigToml response");
-
-    let config: GetConfigTomlResponse = to_response(resp).expect("deserialize config");
-    let expected = GetConfigTomlResponse {
-        approval_policy: Some(AskForApproval::OnRequest),
-        sandbox_mode: Some(SandboxMode::WorkspaceWrite),
-        model_reasoning_effort: Some(ReasoningEffort::High),
-        profile: Some("test".to_string()),
-        profiles: Some(HashMap::from([(
-            "test".into(),
-            ConfigProfile {
-                model: Some("gpt-4o".into()),
-                approval_policy: Some(AskForApproval::OnRequest),
-                model_reasoning_effort: Some(ReasoningEffort::High),
-            },
-        )])),
-    };
-
-    assert_eq!(expected, config);
-}

codex-rs/mcp-server/tests/suite/login.rs

@@ -1,7 +1,7 @@
 use std::path::Path;
 use std::time::Duration;
 
-use codex_core::auth::login_with_api_key;
+use codex_login::login_with_api_key;
 use codex_protocol::mcp_protocol::CancelLoginChatGptParams;
 use codex_protocol::mcp_protocol::CancelLoginChatGptResponse;
 use codex_protocol::mcp_protocol::GetAuthStatusParams;

codex-rs/mcp-server/tests/suite/mod.rs

@@ -2,7 +2,6 @@
 mod auth;
 mod codex_message_processor_flow;
 mod codex_tool;
-mod config;
 mod create_conversation;
 mod interrupt;
 mod login;

codex-rs/protocol/src/config_types.rs

@@ -4,8 +4,6 @@ use strum_macros::Display;
 use strum_macros::EnumIter;
 use ts_rs::TS;
 
-use crate::protocol::AskForApproval;
-
 /// See https://platform.openai.com/docs/guides/reasoning?api-mode=responses#get-started-with-reasoning
 #[derive(
     Debug, Serialize, Deserialize, Default, Clone, Copy, PartialEq, Eq, Display, TS, EnumIter,
@@ -49,13 +47,3 @@ pub enum SandboxMode {
     #[serde(rename = "danger-full-access")]
     DangerFullAccess,
 }
-
-/// Collection of common configuration options that a user can define as a unit
-/// in `config.toml`. Currently only a subset of the fields are supported.
-#[derive(Deserialize, Debug, Clone, PartialEq, Serialize, TS)]
-#[serde(rename_all = "camelCase")]
-pub struct ConfigProfile {
-    pub model: Option<String>,
-    pub approval_policy: Option<AskForApproval>,
-    pub model_reasoning_effort: Option<ReasoningEffort>,
-}

codex-rs/protocol/src/custom_prompts.rs

@@ -1,10 +0,0 @@
-use serde::Deserialize;
-use serde::Serialize;
-use std::path::PathBuf;
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct CustomPrompt {
-    pub name: String,
-    pub path: PathBuf,
-    pub content: String,
-}

codex-rs/protocol/src/lib.rs

@@ -1,5 +1,4 @@
 pub mod config_types;
-pub mod custom_prompts;
 pub mod mcp_protocol;
 pub mod message_history;
 pub mod models;