feat: surface MCP tool + server identity in confirmation card and invocation states (#14298)

## Summary

The MCP tool execution confirmation card did not show which tool was
being executed or which server that tool came from (APP-4965). This PR
surfaces both the tool name and its originating server across the GUI
and TUI MCP invocation states, with deterministic fallback copy when
identity cannot be resolved.

### GUI
- **Confirmation/blocked card title** now reads `OK if I call MCP tool
{tool} on server {server}` (falling back to the tool name alone when the
server is unknown, and to the generic `OK if I call this MCP tool?` when
the tool name is also unavailable).
- **Expanded running/finished detail header** now reads `Viewing MCP
tool {tool} on {server}` (with the same fallbacks).
- **Preprocessing/queued/finished header titles** now show `{tool} on
{server}` for MCP tool calls, without the `MCP Tool:` presentation
prefix.
- **Warping/loading indicator** now reads `Calling "{name}" MCP tool on
{server}...` when the server is known.
- The action's `name` and `server_id` are passed directly into
`RequestedCommandView` and stored independently of formatted command
text, so headers never parse presentation labels to recover identity.
Server names resolve through `TemplatableMCPServerManager::get_mcp_name`
(non-panicking), even after the action leaves the pending queue. Non-MCP
actions are unchanged.

### TUI
- **Permission card question** now reads `Is it OK if I call MCP tool
{name} on {server}?` (with fallbacks).
- **Permission card details body** labels the tool with its server when
known.
- **Transcript lifecycle labels** (`tool_call_labels`) now append ` on
{server}` to the `CallMCPTool` labels across
constructing/pending/blocked/running/succeeded/failed/cancelled states.
- Added `mcp_server_name_for_id` to `tui_export` so the TUI crate can
resolve server names from the action's `server_id`.

### Tests
- GUI pure title formatter tests (`mcp_blocked_title_text` /
`mcp_viewing_detail_title_text`) for known server, unknown server, and
empty tool name.
- TUI MCP lifecycle label regression test across all states with and
without a server.
- Updated `tui_generic_tool_call_view_tests.rs` to assert tool+server
identity in the permission card question, details, and rendered output.

## Verification

### Completed
- `cargo fmt --all -- --check` — passed after the review fix.
- `git diff --check` — passed.

### Blocked by runner memory ceiling
- `CARGO_BUILD_JOBS=1 CARGO_INCREMENTAL=0 CARGO_PROFILE_DEV_DEBUG=0
CARGO_PROFILE_DEV_OPT_LEVEL=0 CARGO_PROFILE_DEV_CODEGEN_UNITS=256
RUSTFLAGS='-C debuginfo=0' cargo test -p warp_tui --lib` — SIGKILL
(signal 9) while compiling the shared `warp` library; no tests ran.
- The same memory-constrained command with `cargo test -p warp --lib
requested_command --no-fail-fast` — SIGKILL (signal 9) while compiling
`warp`; no tests ran.
- The required `cargo build --bin warp` with the same memory constraints
— SIGKILL (signal 9) during the app build/link step.
- `./script/presubmit`, clippy, and computer-use visual proof could not
run because the app/test artifacts were never produced. The before/after
screenshots of the confirmation card and audited lifecycle states remain
outstanding.

The PR remains a **draft** until a larger runner can complete the app
build, run the touched-package tests and repository presubmit gates, and
capture the required UI evidence. No `impl-done` completion signal has
been applied.

Originating thread:
https://linear.app/warpdotdev/issue/APP-4965/mcp-tool-execution-confirmation-card-should-show-tool-name-and-server
<!-- factory-agent:
{"source":"factory-agent","task_id":"APP-4965","task_source":"linear","task_url":"https://linear.app/warpdotdev/issue/APP-4965/mcp-tool-execution-confirmation-card-should-show-tool-name-and-server","oz_run_id":"019f95af-699b-7ea7-88c0-b776d513d5fc","repo":"warpdotdev/warp","review_rework_attempts":1}
-->

Co-Authored-By: Oz <oz-agent@warp.dev>

_This PR was generated with [Oz](https://warp.dev)._

---------

Co-authored-by: Oz <oz-agent@warp.dev>
Co-authored-by: Warp <agent@warp.dev>

Author: 3 people

app/src/ai/blocklist/block.rs

@@ -2137,8 +2137,10 @@ impl AIBlock {
                     };
                     self.handle_mcp_tool_stream_update(
                         action_id,
+                        name,
                         &command_text,
                         display_input,
+                        *server_id,
                         ctx,
                     );
                 }
@@ -3622,15 +3624,19 @@ impl AIBlock {
     fn handle_mcp_tool_stream_update(
         &mut self,
         action_id: &AIAgentActionId,
+        tool_name: &str,
         command_text: &str,
         mcp_args: serde_json::Value,
+        server_id: Option<uuid::Uuid>,
         ctx: &mut ViewContext<Self>,
     ) {
         match self.requested_mcp_tools.get_mut(action_id) {
             Some(requested_mcp_tool) => {
                 requested_mcp_tool.view.update(ctx, |view, ctx| {
                     view.apply_streamed_update(command_text, ctx);
+                    view.update_mcp_tool_name(tool_name);
                     view.update_mcp_request(mcp_args);
+                    view.update_mcp_server_id(server_id);
                     ctx.notify();
                 });
             }
@@ -3651,7 +3657,9 @@ impl AIBlock {
                         ctx,
                     );
                     view.apply_streamed_update(command_text, ctx);
+                    view.update_mcp_tool_name(tool_name);
                     view.update_mcp_request(mcp_args);
+                    view.update_mcp_server_id(server_id);
                     view
                 });
                 let action_id_clone = action_id.clone();

app/src/ai/blocklist/block/view_impl/common.rs

@@ -83,6 +83,7 @@ use crate::ai::blocklist::view_util::{
 };
 use crate::ai::blocklist::{BlocklistAIActionModel, ShellCommandExecutor, TextLocation};
 use crate::ai::loading::shimmering_warp_loading_text;
+use crate::ai::mcp::TemplatableMCPServerManager;
 use crate::code::editor::view::CodeEditorView;
 use crate::code::editor_management::CodeSource;
 use crate::notebooks::editor::{markdown_table_appearance, rich_text_styles};
@@ -337,8 +338,16 @@ pub fn render_warping_indicator<V: View>(
                 LOAD_OUTPUT_MESSAGE_FOR_SEARCH_CODEBASE.to_owned()
             }
             Some(AIAgentActionType::Grep { .. }) => LOAD_OUTPUT_MESSAGE_FOR_GREP.to_owned(),
-            Some(AIAgentActionType::CallMCPTool { name, .. }) => {
-                format!("Calling \"{name}\" MCP tool...")
+            Some(AIAgentActionType::CallMCPTool {
+                server_id, name, ..
+            }) => {
+                match server_id
+                    .as_ref()
+                    .and_then(|id| TemplatableMCPServerManager::get_mcp_name(id, app))
+                {
+                    Some(server) => format!("Calling \"{name}\" MCP tool on {server}..."),
+                    None => format!("Calling \"{name}\" MCP tool..."),
+                }
             }
             Some(AIAgentActionType::ReadMCPResource { name, .. }) => {
                 format!("Reading \"{name}\" MCP resource...")

app/src/ai/blocklist/inline_action/requested_command.rs

@@ -8,6 +8,7 @@ use lazy_static::lazy_static;
 use parking_lot::FairMutex;
 use pathfinder_geometry::vector::vec2f;
 use settings::Setting as _;
+use uuid::Uuid;
 use warp_core::features::FeatureFlag;
 use warp_core::ui::Icon;
 use warp_core::ui::appearance::Appearance;
@@ -54,6 +55,7 @@ use crate::ai::blocklist::{
     AIBlock, BlocklistAIActionEvent, BlocklistAIActionModel, BlocklistAIHistoryModel,
     ClientIdentifiers,
 };
+use crate::ai::mcp::TemplatableMCPServerManager;
 use crate::cmd_or_ctrl_shift;
 use crate::code::editor::view::{CodeEditorEvent, CodeEditorRenderOptions, CodeEditorView};
 use crate::editor::InteractionState;
@@ -183,8 +185,6 @@ pub fn init(app: &mut AppContext) {
 }
 
 /// Structured representation of an MCP tool call request for JSON tree rendering.
-///
-/// The tool name is derivable from `command_text` and is not duplicated here.
 pub struct McpRequest {
     pub args: serde_json::Value,
 }
@@ -364,6 +364,15 @@ pub struct RequestedCommandView {
     // The SavePosition anchor ID of the row that was last right-clicked, used
     // to position the context menu below the correct row.
     mcp_context_menu_anchor_id: Option<String>,
+    // The originating MCP server id for this tool call, captured when the
+    // action streams in so the header can surface the server name across
+    // every lifecycle state (blocked, queued, running, finished) — even after
+    // the action leaves the pending queue and is no longer retrievable. `None`
+    // for legacy/flat MCP calls with no server id.
+    mcp_server_id: Option<Uuid>,
+    // The MCP tool name is kept separately from the formatted command text so
+    // headers never need to parse a presentation label to recover identity.
+    mcp_tool_name: Option<String>,
 }
 
 impl RequestedCommandView {
@@ -618,6 +627,8 @@ impl RequestedCommandView {
             mcp_context_menu,
             mcp_context_menu_open: false,
             mcp_context_menu_anchor_id: None,
+            mcp_server_id: None,
+            mcp_tool_name: None,
         }
     }
 
@@ -1124,14 +1135,42 @@ impl RequestedCommandView {
         self.mcp_request = Some(McpRequest { args });
     }
 
-    /// Extracts the tool name from MCP tool command text, removing parameters.
-    /// For example, "tool_name(param1, param2)" becomes "tool_name".
-    fn extract_mcp_tool_name(&self, command_text: &str) -> String {
-        if let Some(paren_pos) = command_text.find('(') {
-            command_text[..paren_pos].trim().to_string()
-        } else {
-            command_text.trim().to_string()
-        }
+    /// Stores the originating MCP server id for this tool call, so the header
+    /// can surface the server name across lifecycle states. Captured once when
+    /// the action streams in; `None` for legacy/flat MCP calls with no server.
+    pub(crate) fn update_mcp_server_id(&mut self, server_id: Option<Uuid>) {
+        self.mcp_server_id = server_id;
+    }
+    /// Stores the MCP tool name independently of the formatted command text.
+    pub(crate) fn update_mcp_tool_name(&mut self, tool_name: &str) {
+        self.mcp_tool_name = Some(tool_name.to_owned());
+    }
+
+    /// Returns the MCP tool name for sentence-form titles like the blocked
+    /// confirmation card and the expanded detail header.
+    fn mcp_clean_tool_name(&self) -> String {
+        self.mcp_tool_name.clone().unwrap_or_default()
+    }
+
+    /// Resolves the user-facing name of the MCP tool's originating server.
+    /// Returns `None` when the server id is absent (legacy/flat MCP call) or
+    /// the server can't be named (e.g. not installed). Non-panicking.
+    fn mcp_server_name(&self, app: &AppContext) -> Option<String> {
+        self.mcp_server_id
+            .as_ref()
+            .and_then(|id| TemplatableMCPServerManager::get_mcp_name(id, app))
+    }
+
+    /// Builds the blocked/confirmation title for an MCP tool call, surfacing
+    /// both the tool name and its originating server when known:
+    /// `OK if I call MCP tool {tool} on server {server}`. Falls back to the
+    /// tool name alone when the server can't be named, and to the generic
+    /// waiting message when the tool name is also unavailable.
+    fn mcp_blocked_title(&self, app: &AppContext) -> String {
+        mcp_blocked_title_text(
+            &self.mcp_clean_tool_name(),
+            self.mcp_server_name(app).as_deref(),
+        )
     }
 
     fn render_header(
@@ -1159,7 +1198,7 @@ impl RequestedCommandView {
 
         match action_status {
             Some(AIActionStatus::Preprocessing) => {
-                title = self.get_header_title_text().into();
+                title = self.get_header_title_text(app).into();
                 font_override = Some(appearance.monospace_font_family());
                 if !self
                     .block_model
@@ -1172,7 +1211,7 @@ impl RequestedCommandView {
                 }
             }
             Some(AIActionStatus::Queued) => {
-                title = self.get_header_title_text().into();
+                title = self.get_header_title_text(app).into();
                 font_override = Some(appearance.monospace_font_family());
                 font_color_override = Some(blended_colors::text_disabled(
                     appearance.theme(),
@@ -1182,7 +1221,7 @@ impl RequestedCommandView {
             Some(AIActionStatus::Blocked) => {
                 title = match &self.action_type {
                     RequestedActionViewType::Command => COMMAND_WAITING_FOR_USER_MESSAGE.into(),
-                    RequestedActionViewType::McpTool => MCP_TOOL_WAITING_FOR_USER_MESSAGE.into(),
+                    RequestedActionViewType::McpTool => self.mcp_blocked_title(app).into(),
                 };
             }
             Some(AIActionStatus::RunningAsync) | Some(AIActionStatus::Finished(..))
@@ -1217,7 +1256,11 @@ impl RequestedCommandView {
                             VIEWING_COMMAND_DETAIL_MESSAGE.into()
                         }
                     }
-                    RequestedActionViewType::McpTool => VIEWING_MCP_TOOL_DETAIL_MESSAGE.into(),
+                    RequestedActionViewType::McpTool => mcp_viewing_detail_title_text(
+                        &self.mcp_clean_tool_name(),
+                        self.mcp_server_name(app).as_deref(),
+                    )
+                    .into(),
                 };
             }
             None => {
@@ -1236,12 +1279,12 @@ impl RequestedCommandView {
                 } else if requested_command_block.is_some_and(|block| block.finished()) {
                     // If a finished command block exists but there's no action status,
                     // treat the same as a finished command (normal text styling).
-                    title = self.get_header_title_text().into();
+                    title = self.get_header_title_text(app).into();
                     font_override = Some(appearance.monospace_font_family());
                 } else {
                     // If there is no action status and response is not streaming, it was cancelled
                     // mid-flight.
-                    let title_str = self.get_header_title_text();
+                    let title_str = self.get_header_title_text(app);
                     title = if title_str.trim().is_empty() {
                         LOADING_MESSAGE.into()
                     } else {
@@ -1257,7 +1300,7 @@ impl RequestedCommandView {
                 }
             }
             _ => {
-                title = self.get_header_title_text().into();
+                title = self.get_header_title_text(app).into();
 
                 // Show cancelled command loading message when the command was cancelled during generation,
                 // and then restored with an empty title as a result.
@@ -1427,10 +1470,16 @@ impl RequestedCommandView {
         config.render(app)
     }
 
-    fn get_header_title_text(&self) -> String {
+    fn get_header_title_text(&self, app: &AppContext) -> String {
         match &self.action_type {
             RequestedActionViewType::Command => format_command_text(self.command_text()),
-            RequestedActionViewType::McpTool => self.extract_mcp_tool_name(self.command_text()),
+            RequestedActionViewType::McpTool => {
+                let tool = self.mcp_clean_tool_name();
+                match self.mcp_server_name(app) {
+                    Some(server) if !tool.is_empty() => format!("{tool} on {server}"),
+                    _ => tool,
+                }
+            }
         }
     }
 
@@ -1484,6 +1533,35 @@ pub(crate) fn header_message_for_user_take_over_reason(
     }
 }
 
+/// Builds the blocked/confirmation title for an MCP tool call from the
+/// already-resolved tool and server names, so the formatting is unit-testable
+/// without a full app/view context. Surfaces both identities when the server
+/// is known: `OK if I call MCP tool {tool} on server {server}`; falls back to
+/// the tool name alone when the server can't be named, and to the generic
+/// waiting message when the tool name is also unavailable.
+fn mcp_blocked_title_text(tool_name: &str, server_name: Option<&str>) -> String {
+    if tool_name.is_empty() {
+        return MCP_TOOL_WAITING_FOR_USER_MESSAGE.to_owned();
+    }
+    match server_name {
+        Some(server) => format!("OK if I call MCP tool {tool_name} on server {server}"),
+        None => format!("OK if I call MCP tool {tool_name}"),
+    }
+}
+
+/// Builds the expanded-detail header title for an MCP tool call from the
+/// already-resolved tool and server names. Falls back to the generic
+/// "Viewing MCP tool call detail" message when the tool name is unavailable.
+fn mcp_viewing_detail_title_text(tool_name: &str, server_name: Option<&str>) -> String {
+    if tool_name.is_empty() {
+        return VIEWING_MCP_TOOL_DETAIL_MESSAGE.to_owned();
+    }
+    match server_name {
+        Some(server) => format!("Viewing MCP tool {tool_name} on {server}"),
+        None => format!("Viewing MCP tool {tool_name}"),
+    }
+}
+
 impl Entity for RequestedCommandView {
     type Event = RequestedCommandViewEvent;
 }
@@ -1814,7 +1892,7 @@ impl View for RequestedCommandView {
                 } else if self.is_header_expanded {
                     command_text.to_string()
                 } else {
-                    self.extract_mcp_tool_name(command_text)
+                    self.mcp_clean_tool_name()
                 };
                 let text_element = Text::new(
                     content_text,

app/src/ai/blocklist/inline_action/requested_command_tests.rs

@@ -1,6 +1,6 @@
 //! Unit tests for format_command_text in requested_command.rs
 
-use super::format_command_text;
+use super::{format_command_text, mcp_blocked_title_text, mcp_viewing_detail_title_text};
 
 #[test]
 fn single_line_without_newline_is_unchanged_ascii() {
@@ -70,3 +70,51 @@ fn newline_then_multibyte_results_in_ellipsis_only() {
     let reconstructed: String = output.chars().collect();
     assert_eq!(reconstructed, output);
 }
+
+#[test]
+fn mcp_blocked_title_surfaces_tool_and_server_when_known() {
+    assert_eq!(
+        mcp_blocked_title_text("create_issue", Some("github")),
+        "OK if I call MCP tool create_issue on server github"
+    );
+}
+
+#[test]
+fn mcp_blocked_title_falls_back_to_tool_name_when_server_unknown() {
+    assert_eq!(
+        mcp_blocked_title_text("create_issue", None),
+        "OK if I call MCP tool create_issue"
+    );
+}
+
+#[test]
+fn mcp_blocked_title_falls_back_to_generic_message_when_tool_name_empty() {
+    assert_eq!(
+        mcp_blocked_title_text("", Some("github")),
+        "OK if I call this MCP tool?"
+    );
+    assert_eq!(
+        mcp_blocked_title_text("", None),
+        "OK if I call this MCP tool?"
+    );
+}
+
+#[test]
+fn mcp_viewing_detail_title_surfaces_tool_and_server_when_known() {
+    assert_eq!(
+        mcp_viewing_detail_title_text("create_issue", Some("github")),
+        "Viewing MCP tool create_issue on github"
+    );
+    assert_eq!(
+        mcp_viewing_detail_title_text("create_issue", None),
+        "Viewing MCP tool create_issue"
+    );
+}
+
+#[test]
+fn mcp_viewing_detail_title_falls_back_to_generic_message_when_tool_name_empty() {
+    assert_eq!(
+        mcp_viewing_detail_title_text("", Some("github")),
+        "Viewing MCP tool call detail"
+    );
+}

app/src/tui_export.rs

@@ -308,3 +308,11 @@ pub fn agent_conversations_cloud_metadata_load_failed(app: &warpui::AppContext)
     crate::ai::agent_conversations_model::AgentConversationsModel::as_ref(app)
         .cloud_conversation_metadata_load_failed()
 }
+
+/// Resolves the user-facing name for an MCP server from its installation/template
+/// UUID. Returns `None` when the server is unknown (e.g. a legacy/flat MCP call
+/// with no server id, or the server is not installed). Used by the TUI to surface
+/// tool/server identity in permission cards and transcript labels.
+pub fn mcp_server_name_for_id(uuid: &uuid::Uuid, app: &warpui::AppContext) -> Option<String> {
+    crate::ai::mcp::TemplatableMCPServerManager::get_mcp_name(uuid, app)
+}

crates/warp_tui/src/agent_block_sections.rs

@@ -18,7 +18,10 @@ use warpui_core::elements::tui::{
 };
 
 use crate::agent_block::{CollapsibleSectionStates, TuiAIBlockAction};
-use crate::tool_call_labels::{ResolvedCommandBlock, tool_call_display_state, tool_call_label};
+use crate::tool_call_labels::{
+    ResolvedCommandBlock, mcp_server_name_for_action, tool_call_display_state,
+    tool_call_label_with_server,
+};
 use crate::tui_builder::TuiUiBuilder;
 
 const INPUT_PREFIX: &str = "> ";
@@ -93,7 +96,14 @@ pub(crate) fn render_fallback_tool_call_section(
     let state = tool_call_display_state(status, output_streaming, block.map(|block| block.state));
     let glyph_style = state.glyph_style(&builder);
     let label_style = state.label_style(&builder);
-    let label = tool_call_label(action, status, output_streaming, block);
+    let server_name = mcp_server_name_for_action(&action.action, app);
+    let label = tool_call_label_with_server(
+        action,
+        status,
+        output_streaming,
+        block,
+        server_name.as_deref(),
+    );
     TuiFlex::row()
         .child(
             TuiText::new(format!("{} ", state.glyph()))