feat(tui): Display ACP tool calls in TUI chat history (#60)

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

- Display ACP (Agent Client Protocol) tool calls in the TUI chat history
with gear emoji
- Add AcpToolCallEvent types in translator.rs to bridge ACP and codex
types
- Add ResponseEvent::Acp variant for streaming ACP events from model
client
- Add AcpEventMsg in protocol for TUI event communication
- Handle tool calls on Pending status when title is available

## Test Plan
- [x] Added E2E PTY test `test_acp_tool_call_displayed` that verifies
gear emoji appears
- [x] Mock ACP agent sends tool call sequence (pending → in_progress →
completed)
- [x] All existing tests pass

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

Author: CSRessel

codex-rs/acp/src/connection.rs

@@ -530,10 +530,10 @@ mod tests {
         // Should have received responses
         let mut messages = Vec::new();
         while let Ok(update) = rx.try_recv() {
-            if let acp::SessionUpdate::AgentMessageChunk(chunk) = update {
-                if let acp::ContentBlock::Text(text) = chunk.content {
-                    messages.push(text.text);
-                }
+            if let acp::SessionUpdate::AgentMessageChunk(chunk) = update
+                && let acp::ContentBlock::Text(text) = chunk.content
+            {
+                messages.push(text.text);
             }
         }
 

codex-rs/acp/src/lib.rs

@@ -13,6 +13,14 @@ pub use registry::AcpAgentConfig;
 pub use registry::AcpProviderInfo;
 pub use registry::get_agent_config;
 pub use tracing_setup::init_file_tracing;
+pub use translator::AcpToolCallContent;
+pub use translator::AcpToolCallEvent;
+pub use translator::AcpToolCallLocation;
+pub use translator::AcpToolCallUpdateEvent;
+pub use translator::AcpToolKind;
+pub use translator::AcpToolStatus;
+pub use translator::TranslatedEvent;
+pub use translator::translate_session_update;
 
 // Re-export commonly used types from agent-client-protocol
 pub use agent_client_protocol::Agent;

codex-rs/acp/src/translator.rs

@@ -6,6 +6,200 @@
 use agent_client_protocol as acp;
 use codex_protocol::models::ContentItem;
 use codex_protocol::models::ResponseItem;
+use std::path::PathBuf;
+
+/// Tool kind categories for ACP tool calls.
+/// Maps to agent_client_protocol::ToolKind but owned by codex.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum AcpToolKind {
+    Read,
+    Edit,
+    Delete,
+    Move,
+    Search,
+    Execute,
+    Think,
+    Fetch,
+    SwitchMode,
+    Other,
+}
+
+impl From<&acp::ToolKind> for AcpToolKind {
+    fn from(kind: &acp::ToolKind) -> Self {
+        match kind {
+            acp::ToolKind::Read => AcpToolKind::Read,
+            acp::ToolKind::Edit => AcpToolKind::Edit,
+            acp::ToolKind::Delete => AcpToolKind::Delete,
+            acp::ToolKind::Move => AcpToolKind::Move,
+            acp::ToolKind::Search => AcpToolKind::Search,
+            acp::ToolKind::Execute => AcpToolKind::Execute,
+            acp::ToolKind::Think => AcpToolKind::Think,
+            acp::ToolKind::Fetch => AcpToolKind::Fetch,
+            acp::ToolKind::SwitchMode => AcpToolKind::SwitchMode,
+            acp::ToolKind::Other => AcpToolKind::Other,
+        }
+    }
+}
+
+impl std::fmt::Display for AcpToolKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            AcpToolKind::Read => write!(f, "read"),
+            AcpToolKind::Edit => write!(f, "edit"),
+            AcpToolKind::Delete => write!(f, "delete"),
+            AcpToolKind::Move => write!(f, "move"),
+            AcpToolKind::Search => write!(f, "search"),
+            AcpToolKind::Execute => write!(f, "execute"),
+            AcpToolKind::Think => write!(f, "think"),
+            AcpToolKind::Fetch => write!(f, "fetch"),
+            AcpToolKind::SwitchMode => write!(f, "switch_mode"),
+            AcpToolKind::Other => write!(f, "other"),
+        }
+    }
+}
+
+/// Tool call execution status.
+/// Maps to agent_client_protocol::ToolCallStatus but owned by codex.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum AcpToolStatus {
+    Pending,
+    InProgress,
+    Completed,
+    Failed,
+}
+
+impl From<&acp::ToolCallStatus> for AcpToolStatus {
+    fn from(status: &acp::ToolCallStatus) -> Self {
+        match status {
+            acp::ToolCallStatus::Pending => AcpToolStatus::Pending,
+            acp::ToolCallStatus::InProgress => AcpToolStatus::InProgress,
+            acp::ToolCallStatus::Completed => AcpToolStatus::Completed,
+            acp::ToolCallStatus::Failed => AcpToolStatus::Failed,
+        }
+    }
+}
+
+impl std::fmt::Display for AcpToolStatus {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            AcpToolStatus::Pending => write!(f, "pending"),
+            AcpToolStatus::InProgress => write!(f, "in_progress"),
+            AcpToolStatus::Completed => write!(f, "completed"),
+            AcpToolStatus::Failed => write!(f, "failed"),
+        }
+    }
+}
+
+/// Content produced by a tool call.
+#[derive(Debug, Clone)]
+pub enum AcpToolCallContent {
+    /// Text content
+    Text(String),
+    /// File diff
+    Diff {
+        path: PathBuf,
+        old_text: Option<String>,
+        new_text: String,
+    },
+    /// Terminal reference
+    Terminal { terminal_id: String },
+}
+
+/// A file location affected by a tool call.
+#[derive(Debug, Clone)]
+pub struct AcpToolCallLocation {
+    pub path: PathBuf,
+    pub line: Option<u32>,
+}
+
+/// An ACP tool call event with all relevant information.
+#[derive(Debug, Clone)]
+pub struct AcpToolCallEvent {
+    pub call_id: String,
+    pub title: String,
+    pub kind: AcpToolKind,
+    pub status: AcpToolStatus,
+    pub content: Vec<AcpToolCallContent>,
+    pub locations: Vec<AcpToolCallLocation>,
+    pub raw_input: Option<serde_json::Value>,
+    pub raw_output: Option<serde_json::Value>,
+}
+
+impl From<&acp::ToolCall> for AcpToolCallEvent {
+    fn from(tc: &acp::ToolCall) -> Self {
+        AcpToolCallEvent {
+            call_id: tc.id.0.to_string(),
+            title: tc.title.clone(),
+            kind: AcpToolKind::from(&tc.kind),
+            status: AcpToolStatus::from(&tc.status),
+            content: tc.content.iter().filter_map(convert_tool_content).collect(),
+            locations: tc.locations.iter().map(convert_tool_location).collect(),
+            raw_input: tc.raw_input.clone(),
+            raw_output: tc.raw_output.clone(),
+        }
+    }
+}
+
+/// An update to an existing ACP tool call.
+#[derive(Debug, Clone)]
+pub struct AcpToolCallUpdateEvent {
+    pub call_id: String,
+    pub title: Option<String>,
+    pub kind: Option<AcpToolKind>,
+    pub status: Option<AcpToolStatus>,
+    pub content: Option<Vec<AcpToolCallContent>>,
+    pub locations: Option<Vec<AcpToolCallLocation>>,
+    pub raw_input: Option<serde_json::Value>,
+    pub raw_output: Option<serde_json::Value>,
+}
+
+impl From<&acp::ToolCallUpdate> for AcpToolCallUpdateEvent {
+    fn from(update: &acp::ToolCallUpdate) -> Self {
+        let fields = &update.fields;
+        AcpToolCallUpdateEvent {
+            call_id: update.id.0.to_string(),
+            title: fields.title.clone(),
+            kind: fields.kind.as_ref().map(AcpToolKind::from),
+            status: fields.status.as_ref().map(AcpToolStatus::from),
+            content: fields
+                .content
+                .as_ref()
+                .map(|c| c.iter().filter_map(convert_tool_content).collect()),
+            locations: fields
+                .locations
+                .as_ref()
+                .map(|l| l.iter().map(convert_tool_location).collect()),
+            raw_input: fields.raw_input.clone(),
+            raw_output: fields.raw_output.clone(),
+        }
+    }
+}
+
+/// Convert ACP ToolCallContent to our internal representation.
+fn convert_tool_content(content: &acp::ToolCallContent) -> Option<AcpToolCallContent> {
+    match content {
+        acp::ToolCallContent::Content { content } => match content {
+            acp::ContentBlock::Text(text) => Some(AcpToolCallContent::Text(text.text.clone())),
+            _ => None, // Non-text content not yet supported
+        },
+        acp::ToolCallContent::Diff { diff } => Some(AcpToolCallContent::Diff {
+            path: diff.path.clone(),
+            old_text: diff.old_text.clone(),
+            new_text: diff.new_text.clone(),
+        }),
+        acp::ToolCallContent::Terminal { terminal_id } => Some(AcpToolCallContent::Terminal {
+            terminal_id: terminal_id.0.to_string(),
+        }),
+    }
+}
+
+/// Convert ACP ToolCallLocation to our internal representation.
+fn convert_tool_location(loc: &acp::ToolCallLocation) -> AcpToolCallLocation {
+    AcpToolCallLocation {
+        path: loc.path.clone(),
+        line: loc.line,
+    }
+}
 
 /// Convert codex ResponseItems to ACP ContentBlocks for prompting.
 ///
@@ -58,12 +252,16 @@ pub fn text_to_content_block(text: &str) -> acp::ContentBlock {
 }
 
 /// Represents an event translated from an ACP SessionUpdate.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum TranslatedEvent {
     /// Text content from the agent
     TextDelta(String),
     /// Agent completed the message with a stop reason
     Completed(acp::StopReason),
+    /// A new tool call has been initiated by the ACP agent
+    ToolCall(AcpToolCallEvent),
+    /// An existing tool call has been updated
+    ToolCallUpdate(AcpToolCallUpdateEvent),
 }
 
 /// Translate an ACP SessionUpdate to a list of TranslatedEvents.
@@ -103,14 +301,17 @@ pub fn translate_session_update(update: acp::SessionUpdate) -> Vec<TranslatedEve
                 }
             }
         }
-        acp::SessionUpdate::ToolCall(_tool_call) => {
-            // Tool calls are complex - for now, we just note them
-            // The agent will send updates about tool execution via ToolCallUpdate
-            vec![]
+        acp::SessionUpdate::ToolCall(tool_call) => {
+            // Convert ACP ToolCall to our internal representation
+            vec![TranslatedEvent::ToolCall(AcpToolCallEvent::from(
+                &tool_call,
+            ))]
         }
-        acp::SessionUpdate::ToolCallUpdate(_update) => {
-            // Tool call results - could be mapped to function call outputs
-            vec![]
+        acp::SessionUpdate::ToolCallUpdate(update) => {
+            // Convert ACP ToolCallUpdate to our internal representation
+            vec![TranslatedEvent::ToolCallUpdate(
+                AcpToolCallUpdateEvent::from(&update),
+            )]
         }
         acp::SessionUpdate::Plan(_plan) => {
             // Plans are agent-internal state

codex-rs/core/src/chat_completions.rs

@@ -931,6 +931,11 @@ where
                 Poll::Ready(Some(Ok(ResponseEvent::OutputItemAdded(item)))) => {
                     return Poll::Ready(Some(Ok(ResponseEvent::OutputItemAdded(item))));
                 }
+                Poll::Ready(Some(Ok(ResponseEvent::Acp(acp_event)))) => {
+                    // ACP events should not appear in chat completions streams,
+                    // but forward them if they somehow do.
+                    return Poll::Ready(Some(Ok(ResponseEvent::Acp(acp_event))));
+                }
             }
         }
     }

codex-rs/core/src/client.rs

@@ -35,6 +35,7 @@ use crate::auth::CodexAuth;
 use crate::auth::RefreshTokenError;
 use crate::chat_completions::AggregateStreamExt;
 use crate::chat_completions::stream_chat_completions;
+use crate::client_common::AcpResponseEvent;
 use crate::client_common::Prompt;
 use crate::client_common::Reasoning;
 use crate::client_common::ResponseEvent;
@@ -1175,6 +1176,30 @@ async fn stream_acp_internal(
                     TranslatedEvent::Completed(_) => {
                         // Completion is handled when the prompt returns
                     }
+                    TranslatedEvent::ToolCall(tool_call) => {
+                        // Forward tool call event to the client
+                        if tx_clone
+                            .send(Ok(ResponseEvent::Acp(AcpResponseEvent::ToolCall(
+                                tool_call,
+                            ))))
+                            .await
+                            .is_err()
+                        {
+                            return;
+                        }
+                    }
+                    TranslatedEvent::ToolCallUpdate(update) => {
+                        // Forward tool call update event to the client
+                        if tx_clone
+                            .send(Ok(ResponseEvent::Acp(AcpResponseEvent::ToolCallUpdate(
+                                update,
+                            ))))
+                            .await
+                            .is_err()
+                        {
+                            return;
+                        }
+                    }
                 }
             }
         }

codex-rs/core/src/client_common.rs

@@ -3,6 +3,8 @@ use crate::error::Result;
 use crate::model_family::ModelFamily;
 use crate::protocol::RateLimitSnapshot;
 use crate::protocol::TokenUsage;
+use codex_acp::AcpToolCallEvent;
+use codex_acp::AcpToolCallUpdateEvent;
 use codex_apply_patch::APPLY_PATCH_TOOL_INSTRUCTIONS;
 use codex_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
 use codex_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig;
@@ -193,6 +195,18 @@ fn strip_total_output_header(output: &str) -> Option<&str> {
     Some(remainder)
 }
 
+/// ACP-specific response events.
+///
+/// This enum encapsulates all ACP-related events to minimize changes
+/// to the parent `ResponseEvent` enum.
+#[derive(Debug)]
+pub enum AcpResponseEvent {
+    /// A new tool call has been initiated by the ACP agent
+    ToolCall(AcpToolCallEvent),
+    /// An existing tool call has been updated
+    ToolCallUpdate(AcpToolCallUpdateEvent),
+}
+
 #[derive(Debug)]
 pub enum ResponseEvent {
     Created,
@@ -215,6 +229,8 @@ pub enum ResponseEvent {
         summary_index: i64,
     },
     RateLimits(RateLimitSnapshot),
+    /// ACP-specific events (tool calls, updates, etc.)
+    Acp(AcpResponseEvent),
 }
 
 #[derive(Debug, Serialize)]