feat(acp): Add Claude ACP support via @zed-industries/claude-code-acp (#58)

## Summary
Generated with [Nori](https://www.npmjs.com/package/nori-ai)

- Add Claude as an ACP provider alongside Gemini via
`@zed-industries/claude-code-acp` package
- Add Claude ModelPreset for UI model selection in `/model` command
- Add unit tests for Claude ACP registry config and model family
- Add live E2E tests for ACP models (opt-in with `--ignored` flag,
requires ANTHROPIC_API_KEY/GEMINI_API_KEY)
- Update documentation in docs.md files
- Fix clippy warnings for uninlined format args (pre-existing)
- Update snapshot tests for UI changes (pre-existing /review command
addition)

## Test Plan
- [x] Unit tests pass: `cargo test -p codex-acp` and `cargo test -p
codex-core client_acp_tests --lib`
- [x] E2E snapshot tests pass: `cargo insta test`
- [x] Live ACP test with ANTHROPIC_API_KEY: `cargo test -p tui-pty-e2e
-- --ignored test_claude_acp_live_response`
- [x] CI passes

Share Nori with your team: https://www.npmjs.com/package/nori-ai

Author: CSRessel

codex-rs/acp/docs.md

@@ -18,16 +18,18 @@ Path: @/codex-rs/acp
 ### Model Registry
 
 The ACP registry in `@/codex-rs/acp/src/registry.rs` is **model-centric** rather than provider-centric:
-- `get_agent_config()` accepts model names (e.g., "mock-model", "gemini-2.5-flash") instead of provider names
+- `get_agent_config()` accepts model names (e.g., "mock-model", "gemini-2.5-flash", "claude-acp") instead of provider names
 - Called from `@/codex-rs/core/src/client.rs` at the start of `stream()` to check if model is an ACP agent
 - Returns `AcpAgentConfig` containing:
-  - `provider_slug`: Identifies which agent subprocess to spawn (e.g., "mock-acp", "gemini-acp")
+  - `provider_slug`: Identifies which agent subprocess to spawn (e.g., "mock-acp", "gemini-acp", "claude-acp")
   - `command`: Executable path or command name
   - `args`: Arguments to pass to the subprocess
   - `provider_info`: Embedded `AcpProviderInfo` with provider configuration (name, retry settings, timeouts)
 - Model names are normalized to lowercase for case-insensitive matching (e.g., "Gemini-2.5-Flash" → "gemini-2.5-flash")
 - Uses exact matching only (no prefix matching) - each model must be explicitly registered
 - The `provider_slug` field enables future optimization to determine when existing subprocess can be reused vs when new one must be spawned when switching models
+- Claude ACP is registered for both "claude" and "claude-acp" model names, using `npx @zed-industries/claude-code-acp` command with no arguments
+- Unit test `test_get_claude_model_config()` verifies Claude ACP registry configuration
 
 ### Embedded Provider Info
 

codex-rs/acp/src/connection.rs

@@ -15,14 +15,18 @@ use std::rc::Rc;
 use std::thread;
 
 use agent_client_protocol as acp;
-use anyhow::{Context, Result};
+use anyhow::Context;
+use anyhow::Result;
 use futures::AsyncBufReadExt;
 use futures::io::BufReader;
-use tokio::process::{Child, Command};
+use tokio::process::Child;
+use tokio::process::Command;
 use tokio::sync::mpsc;
 use tokio::sync::oneshot;
-use tokio_util::compat::{TokioAsyncReadCompatExt, TokioAsyncWriteCompatExt};
-use tracing::{debug, warn};
+use tokio_util::compat::TokioAsyncReadCompatExt;
+use tokio_util::compat::TokioAsyncWriteCompatExt;
+use tracing::debug;
+use tracing::warn;
 
 use crate::registry::AcpAgentConfig;
 
@@ -80,7 +84,10 @@ impl AcpConnection {
 
         // Spawn a dedicated thread with a single-threaded tokio runtime
         let worker_thread = thread::spawn(move || {
-            #[expect(clippy::expect_used, reason = "Runtime creation in dedicated thread is infallible in practice")]
+            #[expect(
+                clippy::expect_used,
+                reason = "Runtime creation in dedicated thread is infallible in practice"
+            )]
             let rt = tokio::runtime::Builder::new_current_thread()
                 .enable_all()
                 .build()
@@ -407,8 +414,8 @@ impl acp::Client for ClientDelegate {
         arguments: acp::ReadTextFileRequest,
     ) -> acp::Result<acp::ReadTextFileResponse> {
         // Read file content
-        let content = std::fs::read_to_string(&arguments.path)
-            .map_err(acp::Error::into_internal_error)?;
+        let content =
+            std::fs::read_to_string(&arguments.path).map_err(acp::Error::into_internal_error)?;
         Ok(acp::ReadTextFileResponse {
             content,
             meta: None,
@@ -537,8 +544,7 @@ mod tests {
         );
         assert!(
             messages.iter().any(|m| m.contains("Test message")),
-            "Should contain test message, got: {:?}",
-            messages
+            "Should contain test message, got: {messages:?}"
         );
         assert_eq!(stop_reason, acp::StopReason::EndTurn);
     }

codex-rs/acp/src/registry.rs

@@ -154,6 +154,16 @@ mod tests {
         assert_eq!(config.provider_info.name, "Gemini ACP");
     }
 
+    #[test]
+    fn test_get_claude_model_config() {
+        let config = get_agent_config("claude-acp").expect("Should return config for claude-acp");
+
+        assert_eq!(config.provider_slug, "claude-acp");
+        assert_eq!(config.command, "npx");
+        assert_eq!(config.args, vec!["@zed-industries/claude-code-acp"]);
+        assert_eq!(config.provider_info.name, "Claude ACP");
+    }
+
     #[test]
     fn test_get_unknown_model_returns_error() {
         let result = get_agent_config("unknown-model-xyz");

codex-rs/acp/src/translator.rs

@@ -4,7 +4,8 @@
 //! (Agent Client Protocol) data types and the codex internal data types.
 
 use agent_client_protocol as acp;
-use codex_protocol::models::{ContentItem, ResponseItem};
+use codex_protocol::models::ContentItem;
+use codex_protocol::models::ResponseItem;
 
 /// Convert codex ResponseItems to ACP ContentBlocks for prompting.
 ///

codex-rs/acp/tests/tracing_test.rs

@@ -32,8 +32,7 @@ fn test_file_tracing_comprehensive() {
     // Verify log file exists
     assert!(
         log_file_path.exists(),
-        "Log file should exist at {:?}",
-        log_file_path
+        "Log file should exist at {log_file_path:?}"
     );
 
     // Read and verify log file contents

codex-rs/common/docs.md

@@ -50,10 +50,11 @@ pub struct CliConfigOverrides {
 
 **Model Presets:**
 
-`model_presets` defines available models by provider with capabilities:
-- Default reasoning effort levels
+`model_presets` in `@/codex-rs/common/src/model_presets.rs` defines available models by provider with capabilities:
+- Default reasoning effort levels (set to Medium for all models)
 - Summary generation support
 - Tool capabilities
+- Claude ACP preset added with display_name "Claude" and description "Anthropic's Claude via Agent Context Protocol" to make Claude model visible in TUI model selection
 
 **Approval Presets:**
 

codex-rs/common/src/model_presets.rs

@@ -69,6 +69,16 @@ static PRESETS: Lazy<Vec<ModelPreset>> = Lazy::new(|| {
             is_default: false,
             upgrade: None,
         },
+        ModelPreset {
+            id: "claude-acp",
+            model: "claude-acp",
+            display_name: "Claude",
+            description: "Anthropic's Claude via Agent Context Protocol.",
+            default_reasoning_effort: ReasoningEffort::Medium,
+            supported_reasoning_efforts: &[],
+            is_default: false,
+            upgrade: None,
+        },
         ModelPreset {
             id: "gpt-5.1-codex",
             model: "gpt-5.1-codex",

codex-rs/core/docs.md

@@ -88,7 +88,7 @@ The `client.rs` defines `ModelClient` trait implemented by:
 
 Response streaming uses `ResponseStream` of `ResponseEvent` items.
 
-For ACP providers (`wire_api: WireApi::Acp`), the client looks up subprocess configuration via `codex_acp::get_agent_config(self.config.model)` from `@/codex-rs/acp/src/registry.rs`. The registry is **model-centric**: it maps model names (e.g., "mock-model", "gemini-2.5-flash") to `AcpAgentConfig` structs containing provider identifier, command, and args. This differs from the provider-based approach used for HTTP APIs. ACP providers should not define `env_key` or `env_key_instructions` in their `ModelProviderInfo` entries, as they communicate via subprocess rather than HTTP APIs.
+For ACP providers (`wire_api: WireApi::Acp`), the client looks up subprocess configuration via `codex_acp::get_agent_config(self.config.model)` from `@/codex-rs/acp/src/registry.rs`. The registry is **model-centric**: it maps model names (e.g., "mock-model", "gemini-2.5-flash", "claude-acp") to `AcpAgentConfig` structs containing provider identifier, command, and args. This differs from the provider-based approach used for HTTP APIs. ACP providers should not define `env_key` or `env_key_instructions` in their `ModelProviderInfo` entries, as they communicate via subprocess rather than HTTP APIs. Unit test `test_claude_acp_model_has_family()` in `@/codex-rs/core/src/client_acp_tests.rs` verifies that Claude ACP models resolve to a valid model family.
 
 **ACP Streaming Flow (`stream_acp` / `stream_acp_internal`):**
 

codex-rs/core/src/client.rs

@@ -1105,10 +1105,13 @@ async fn stream_acp_internal(
     tx: mpsc::Sender<Result<ResponseEvent>>,
 ) -> Result<()> {
     use agent_client_protocol::SessionUpdate;
-    use codex_acp::translator::{TranslatedEvent, translate_session_update};
-    use codex_protocol::models::{ContentItem, ResponseItem};
+    use codex_acp::translator::TranslatedEvent;
+    use codex_acp::translator::translate_session_update;
+    use codex_protocol::models::ContentItem;
+    use codex_protocol::models::ResponseItem;
     use std::sync::Arc;
-    use std::sync::atomic::{AtomicBool, Ordering};
+    use std::sync::atomic::AtomicBool;
+    use std::sync::atomic::Ordering;
 
     // Spawn ACP connection
     let connection = codex_acp::AcpConnection::spawn(config, cwd)

codex-rs/core/src/client_acp_tests.rs

@@ -51,4 +51,15 @@ mod tests {
             "gemini-acp model should have a model family"
         );
     }
+
+    #[test]
+    fn test_claude_acp_model_has_family() {
+        use crate::model_family::find_family_for_model;
+
+        let family = find_family_for_model("claude-acp");
+        assert!(
+            family.is_some(),
+            "claude-acp model should have a model family"
+        );
+    }
 }