1use acp_thread::ContentBlock;
   2use cloud_api_types::{SubmitAgentThreadFeedbackBody, SubmitAgentThreadFeedbackCommentsBody};
   3use editor::actions::OpenExcerpts;
   4
   5use crate::StartThreadIn;
   6use gpui::{Corner, List};
   7use language_model::{LanguageModelEffortLevel, Speed};
   8use settings::update_settings_file;
   9use ui::{ButtonLike, SplitButton, SplitButtonStyle, Tab};
  10use workspace::SERIALIZATION_THROTTLE_TIME;
  11
  12use super::*;
  13
  14#[derive(Default)]
  15struct ThreadFeedbackState {
  16    feedback: Option<ThreadFeedback>,
  17    comments_editor: Option<Entity<Editor>>,
  18}
  19
  20impl ThreadFeedbackState {
  21    pub fn submit(
  22        &mut self,
  23        thread: Entity<AcpThread>,
  24        feedback: ThreadFeedback,
  25        window: &mut Window,
  26        cx: &mut App,
  27    ) {
  28        let Some(telemetry) = thread.read(cx).connection().telemetry() else {
  29            return;
  30        };
  31
  32        let project = thread.read(cx).project().read(cx);
  33        let client = project.client();
  34        let user_store = project.user_store();
  35        let organization = user_store.read(cx).current_organization();
  36
  37        if self.feedback == Some(feedback) {
  38            return;
  39        }
  40
  41        self.feedback = Some(feedback);
  42        match feedback {
  43            ThreadFeedback::Positive => {
  44                self.comments_editor = None;
  45            }
  46            ThreadFeedback::Negative => {
  47                self.comments_editor = Some(Self::build_feedback_comments_editor(window, cx));
  48            }
  49        }
  50        let session_id = thread.read(cx).session_id().clone();
  51        let parent_session_id = thread.read(cx).parent_session_id().cloned();
  52        let agent_telemetry_id = thread.read(cx).connection().telemetry_id();
  53        let task = telemetry.thread_data(&session_id, cx);
  54        let rating = match feedback {
  55            ThreadFeedback::Positive => "positive",
  56            ThreadFeedback::Negative => "negative",
  57        };
  58        cx.background_spawn(async move {
  59            let thread = task.await?;
  60
  61            client
  62                .cloud_client()
  63                .submit_agent_feedback(SubmitAgentThreadFeedbackBody {
  64                    organization_id: organization.map(|organization| organization.id.clone()),
  65                    agent: agent_telemetry_id.to_string(),
  66                    session_id: session_id.to_string(),
  67                    parent_session_id: parent_session_id.map(|id| id.to_string()),
  68                    rating: rating.to_string(),
  69                    thread,
  70                })
  71                .await?;
  72
  73            anyhow::Ok(())
  74        })
  75        .detach_and_log_err(cx);
  76    }
  77
  78    pub fn submit_comments(&mut self, thread: Entity<AcpThread>, cx: &mut App) {
  79        let Some(telemetry) = thread.read(cx).connection().telemetry() else {
  80            return;
  81        };
  82
  83        let Some(comments) = self
  84            .comments_editor
  85            .as_ref()
  86            .map(|editor| editor.read(cx).text(cx))
  87            .filter(|text| !text.trim().is_empty())
  88        else {
  89            return;
  90        };
  91
  92        self.comments_editor.take();
  93
  94        let project = thread.read(cx).project().read(cx);
  95        let client = project.client();
  96        let user_store = project.user_store();
  97        let organization = user_store.read(cx).current_organization();
  98
  99        let session_id = thread.read(cx).session_id().clone();
 100        let agent_telemetry_id = thread.read(cx).connection().telemetry_id();
 101        let task = telemetry.thread_data(&session_id, cx);
 102        cx.background_spawn(async move {
 103            let thread = task.await?;
 104
 105            client
 106                .cloud_client()
 107                .submit_agent_feedback_comments(SubmitAgentThreadFeedbackCommentsBody {
 108                    organization_id: organization.map(|organization| organization.id.clone()),
 109                    agent: agent_telemetry_id.to_string(),
 110                    session_id: session_id.to_string(),
 111                    comments,
 112                    thread,
 113                })
 114                .await?;
 115
 116            anyhow::Ok(())
 117        })
 118        .detach_and_log_err(cx);
 119    }
 120
 121    pub fn clear(&mut self) {
 122        *self = Self::default()
 123    }
 124
 125    pub fn dismiss_comments(&mut self) {
 126        self.comments_editor.take();
 127    }
 128
 129    fn build_feedback_comments_editor(window: &mut Window, cx: &mut App) -> Entity<Editor> {
 130        let buffer = cx.new(|cx| {
 131            let empty_string = String::new();
 132            MultiBuffer::singleton(cx.new(|cx| Buffer::local(empty_string, cx)), cx)
 133        });
 134
 135        let editor = cx.new(|cx| {
 136            let mut editor = Editor::new(
 137                editor::EditorMode::AutoHeight {
 138                    min_lines: 1,
 139                    max_lines: Some(4),
 140                },
 141                buffer,
 142                None,
 143                window,
 144                cx,
 145            );
 146            editor.set_placeholder_text(
 147                "What went wrong? Share your feedback so we can improve.",
 148                window,
 149                cx,
 150            );
 151            editor
 152        });
 153
 154        editor.read(cx).focus_handle(cx).focus(window, cx);
 155        editor
 156    }
 157}
 158
 159#[derive(Default, Clone, Copy)]
 160struct DiffStats {
 161    lines_added: u32,
 162    lines_removed: u32,
 163}
 164
 165impl DiffStats {
 166    fn single_file(buffer: &Buffer, diff: &BufferDiff, cx: &App) -> Self {
 167        let mut stats = DiffStats::default();
 168        let diff_snapshot = diff.snapshot(cx);
 169        let buffer_snapshot = buffer.snapshot();
 170        let base_text = diff_snapshot.base_text();
 171
 172        for hunk in diff_snapshot.hunks(&buffer_snapshot) {
 173            let added_rows = hunk.range.end.row.saturating_sub(hunk.range.start.row);
 174            stats.lines_added += added_rows;
 175
 176            let base_start = hunk.diff_base_byte_range.start.to_point(base_text).row;
 177            let base_end = hunk.diff_base_byte_range.end.to_point(base_text).row;
 178            let removed_rows = base_end.saturating_sub(base_start);
 179            stats.lines_removed += removed_rows;
 180        }
 181
 182        stats
 183    }
 184
 185    fn all_files(changed_buffers: &BTreeMap<Entity<Buffer>, Entity<BufferDiff>>, cx: &App) -> Self {
 186        let mut total = DiffStats::default();
 187        for (buffer, diff) in changed_buffers {
 188            let stats = DiffStats::single_file(buffer.read(cx), diff.read(cx), cx);
 189            total.lines_added += stats.lines_added;
 190            total.lines_removed += stats.lines_removed;
 191        }
 192        total
 193    }
 194}
 195
 196pub enum AcpThreadViewEvent {
 197    FirstSendRequested { content: Vec<acp::ContentBlock> },
 198}
 199
 200impl EventEmitter<AcpThreadViewEvent> for ThreadView {}
 201
 202pub struct ThreadView {
 203    pub id: acp::SessionId,
 204    pub parent_id: Option<acp::SessionId>,
 205    pub thread: Entity<AcpThread>,
 206    pub(crate) conversation: Entity<super::Conversation>,
 207    pub server_view: WeakEntity<ConnectionView>,
 208    pub agent_icon: IconName,
 209    pub agent_icon_from_external_svg: Option<SharedString>,
 210    pub agent_name: SharedString,
 211    pub focus_handle: FocusHandle,
 212    pub workspace: WeakEntity<Workspace>,
 213    pub entry_view_state: Entity<EntryViewState>,
 214    pub title_editor: Entity<Editor>,
 215    pub config_options_view: Option<Entity<ConfigOptionsView>>,
 216    pub mode_selector: Option<Entity<ModeSelector>>,
 217    pub model_selector: Option<Entity<ModelSelectorPopover>>,
 218    pub profile_selector: Option<Entity<ProfileSelector>>,
 219    pub permission_dropdown_handle: PopoverMenuHandle<ContextMenu>,
 220    pub thread_retry_status: Option<RetryStatus>,
 221    pub(super) thread_error: Option<ThreadError>,
 222    pub thread_error_markdown: Option<Entity<Markdown>>,
 223    pub token_limit_callout_dismissed: bool,
 224    pub last_token_limit_telemetry: Option<acp_thread::TokenUsageRatio>,
 225    thread_feedback: ThreadFeedbackState,
 226    pub list_state: ListState,
 227    pub prompt_capabilities: Rc<RefCell<PromptCapabilities>>,
 228    pub available_commands: Rc<RefCell<Vec<agent_client_protocol::AvailableCommand>>>,
 229    /// Tracks which tool calls have their content/output expanded.
 230    /// Used for showing/hiding tool call results, terminal output, etc.
 231    pub expanded_tool_calls: HashSet<agent_client_protocol::ToolCallId>,
 232    pub expanded_tool_call_raw_inputs: HashSet<agent_client_protocol::ToolCallId>,
 233    pub expanded_thinking_blocks: HashSet<(usize, usize)>,
 234    pub subagent_scroll_handles: RefCell<HashMap<agent_client_protocol::SessionId, ScrollHandle>>,
 235    pub edits_expanded: bool,
 236    pub plan_expanded: bool,
 237    pub queue_expanded: bool,
 238    pub editor_expanded: bool,
 239    pub should_be_following: bool,
 240    pub editing_message: Option<usize>,
 241    pub local_queued_messages: Vec<QueuedMessage>,
 242    pub queued_message_editors: Vec<Entity<MessageEditor>>,
 243    pub queued_message_editor_subscriptions: Vec<Subscription>,
 244    pub last_synced_queue_length: usize,
 245    pub turn_fields: TurnFields,
 246    pub discarded_partial_edits: HashSet<agent_client_protocol::ToolCallId>,
 247    pub is_loading_contents: bool,
 248    pub new_server_version_available: Option<SharedString>,
 249    pub resumed_without_history: bool,
 250    pub _cancel_task: Option<Task<()>>,
 251    _save_task: Option<Task<()>>,
 252    _draft_resolve_task: Option<Task<()>>,
 253    pub skip_queue_processing_count: usize,
 254    pub user_interrupted_generation: bool,
 255    pub can_fast_track_queue: bool,
 256    pub hovered_edited_file_buttons: Option<usize>,
 257    pub in_flight_prompt: Option<Vec<acp::ContentBlock>>,
 258    pub _subscriptions: Vec<Subscription>,
 259    pub message_editor: Entity<MessageEditor>,
 260    pub add_context_menu_handle: PopoverMenuHandle<ContextMenu>,
 261    pub thinking_effort_menu_handle: PopoverMenuHandle<ContextMenu>,
 262    pub project: WeakEntity<Project>,
 263    pub recent_history_entries: Vec<AgentSessionInfo>,
 264    pub hovered_recent_history_item: Option<usize>,
 265    pub show_external_source_prompt_warning: bool,
 266    pub show_codex_windows_warning: bool,
 267    pub history: Entity<ThreadHistory>,
 268    pub _history_subscription: Subscription,
 269}
 270impl Focusable for ThreadView {
 271    fn focus_handle(&self, cx: &App) -> FocusHandle {
 272        if self.parent_id.is_some() {
 273            self.focus_handle.clone()
 274        } else {
 275            self.active_editor(cx).focus_handle(cx)
 276        }
 277    }
 278}
 279
 280#[derive(Default)]
 281pub struct TurnFields {
 282    pub _turn_timer_task: Option<Task<()>>,
 283    pub last_turn_duration: Option<Duration>,
 284    pub last_turn_tokens: Option<u64>,
 285    pub turn_generation: usize,
 286    pub turn_started_at: Option<Instant>,
 287    pub turn_tokens: Option<u64>,
 288}
 289
 290impl ThreadView {
 291    pub(crate) fn new(
 292        parent_id: Option<acp::SessionId>,
 293        thread: Entity<AcpThread>,
 294        conversation: Entity<super::Conversation>,
 295        server_view: WeakEntity<ConnectionView>,
 296        agent_icon: IconName,
 297        agent_icon_from_external_svg: Option<SharedString>,
 298        agent_name: SharedString,
 299        agent_display_name: SharedString,
 300        workspace: WeakEntity<Workspace>,
 301        entry_view_state: Entity<EntryViewState>,
 302        config_options_view: Option<Entity<ConfigOptionsView>>,
 303        mode_selector: Option<Entity<ModeSelector>>,
 304        model_selector: Option<Entity<ModelSelectorPopover>>,
 305        profile_selector: Option<Entity<ProfileSelector>>,
 306        list_state: ListState,
 307        prompt_capabilities: Rc<RefCell<PromptCapabilities>>,
 308        available_commands: Rc<RefCell<Vec<agent_client_protocol::AvailableCommand>>>,
 309        resumed_without_history: bool,
 310        project: WeakEntity<Project>,
 311        thread_store: Option<Entity<ThreadStore>>,
 312        history: Entity<ThreadHistory>,
 313        prompt_store: Option<Entity<PromptStore>>,
 314        initial_content: Option<AgentInitialContent>,
 315        mut subscriptions: Vec<Subscription>,
 316        window: &mut Window,
 317        cx: &mut Context<Self>,
 318    ) -> Self {
 319        let id = thread.read(cx).session_id().clone();
 320
 321        let placeholder = placeholder_text(agent_display_name.as_ref(), false);
 322
 323        let history_subscription = cx.observe(&history, |this, history, cx| {
 324            this.update_recent_history_from_cache(&history, cx);
 325        });
 326
 327        let mut should_auto_submit = false;
 328        let mut show_external_source_prompt_warning = false;
 329
 330        let message_editor = cx.new(|cx| {
 331            let mut editor = MessageEditor::new(
 332                workspace.clone(),
 333                project.clone(),
 334                thread_store,
 335                history.downgrade(),
 336                prompt_store,
 337                prompt_capabilities.clone(),
 338                available_commands.clone(),
 339                agent_name.clone(),
 340                &placeholder,
 341                editor::EditorMode::AutoHeight {
 342                    min_lines: AgentSettings::get_global(cx).message_editor_min_lines,
 343                    max_lines: Some(AgentSettings::get_global(cx).set_message_editor_max_lines()),
 344                },
 345                window,
 346                cx,
 347            );
 348            if let Some(content) = initial_content {
 349                match content {
 350                    AgentInitialContent::ThreadSummary { session_id, title } => {
 351                        editor.insert_thread_summary(session_id, title, window, cx);
 352                    }
 353                    AgentInitialContent::ContentBlock {
 354                        blocks,
 355                        auto_submit,
 356                    } => {
 357                        should_auto_submit = auto_submit;
 358                        editor.set_message(blocks, window, cx);
 359                    }
 360                    AgentInitialContent::FromExternalSource(prompt) => {
 361                        show_external_source_prompt_warning = true;
 362                        // SECURITY: Be explicit about not auto submitting prompt from external source.
 363                        should_auto_submit = false;
 364                        editor.set_message(
 365                            vec![acp::ContentBlock::Text(acp::TextContent::new(
 366                                prompt.into_string(),
 367                            ))],
 368                            window,
 369                            cx,
 370                        );
 371                    }
 372                }
 373            } else if let Some(draft) = thread.read(cx).draft_prompt() {
 374                editor.set_message(draft.to_vec(), window, cx);
 375            }
 376            editor
 377        });
 378
 379        let show_codex_windows_warning = cfg!(windows)
 380            && project.upgrade().is_some_and(|p| p.read(cx).is_local())
 381            && agent_name == "Codex";
 382
 383        let title_editor = {
 384            let can_edit = thread.update(cx, |thread, cx| thread.can_set_title(cx));
 385            let editor = cx.new(|cx| {
 386                let mut editor = Editor::single_line(window, cx);
 387                editor.set_text(thread.read(cx).title(), window, cx);
 388                editor.set_read_only(!can_edit);
 389                editor
 390            });
 391            subscriptions.push(cx.subscribe_in(&editor, window, Self::handle_title_editor_event));
 392            editor
 393        };
 394
 395        subscriptions.push(cx.subscribe_in(
 396            &entry_view_state,
 397            window,
 398            Self::handle_entry_view_event,
 399        ));
 400
 401        subscriptions.push(cx.subscribe_in(
 402            &message_editor,
 403            window,
 404            Self::handle_message_editor_event,
 405        ));
 406
 407        subscriptions.push(cx.observe(&message_editor, |this, editor, cx| {
 408            let is_empty = editor.read(cx).text(cx).is_empty();
 409            let draft_contents_task = if is_empty {
 410                None
 411            } else {
 412                Some(editor.update(cx, |editor, cx| editor.draft_contents(cx)))
 413            };
 414            this._draft_resolve_task = Some(cx.spawn(async move |this, cx| {
 415                let draft = if let Some(task) = draft_contents_task {
 416                    let blocks = task.await.ok().filter(|b| !b.is_empty());
 417                    blocks
 418                } else {
 419                    None
 420                };
 421                this.update(cx, |this, cx| {
 422                    this.thread.update(cx, |thread, _cx| {
 423                        thread.set_draft_prompt(draft);
 424                    });
 425                    this.schedule_save(cx);
 426                })
 427                .ok();
 428            }));
 429        }));
 430
 431        let recent_history_entries = history.read(cx).get_recent_sessions(3);
 432
 433        let mut this = Self {
 434            id,
 435            parent_id,
 436            focus_handle: cx.focus_handle(),
 437            thread,
 438            conversation,
 439            server_view,
 440            agent_icon,
 441            agent_icon_from_external_svg,
 442            agent_name,
 443            workspace,
 444            entry_view_state,
 445            title_editor,
 446            config_options_view,
 447            mode_selector,
 448            model_selector,
 449            profile_selector,
 450            list_state,
 451            prompt_capabilities,
 452            available_commands,
 453            resumed_without_history,
 454            _subscriptions: subscriptions,
 455            permission_dropdown_handle: PopoverMenuHandle::default(),
 456            thread_retry_status: None,
 457            thread_error: None,
 458            thread_error_markdown: None,
 459            token_limit_callout_dismissed: false,
 460            last_token_limit_telemetry: None,
 461            thread_feedback: Default::default(),
 462            expanded_tool_calls: HashSet::default(),
 463            expanded_tool_call_raw_inputs: HashSet::default(),
 464            expanded_thinking_blocks: HashSet::default(),
 465            subagent_scroll_handles: RefCell::new(HashMap::default()),
 466            edits_expanded: false,
 467            plan_expanded: false,
 468            queue_expanded: true,
 469            editor_expanded: false,
 470            should_be_following: false,
 471            editing_message: None,
 472            local_queued_messages: Vec::new(),
 473            queued_message_editors: Vec::new(),
 474            queued_message_editor_subscriptions: Vec::new(),
 475            last_synced_queue_length: 0,
 476            turn_fields: TurnFields::default(),
 477            discarded_partial_edits: HashSet::default(),
 478            is_loading_contents: false,
 479            new_server_version_available: None,
 480            _cancel_task: None,
 481            _save_task: None,
 482            _draft_resolve_task: None,
 483            skip_queue_processing_count: 0,
 484            user_interrupted_generation: false,
 485            can_fast_track_queue: false,
 486            hovered_edited_file_buttons: None,
 487            in_flight_prompt: None,
 488            message_editor,
 489            add_context_menu_handle: PopoverMenuHandle::default(),
 490            thinking_effort_menu_handle: PopoverMenuHandle::default(),
 491            project,
 492            recent_history_entries,
 493            hovered_recent_history_item: None,
 494            show_external_source_prompt_warning,
 495            history,
 496            _history_subscription: history_subscription,
 497            show_codex_windows_warning,
 498        };
 499        let list_state_for_scroll = this.list_state.clone();
 500        let thread_view = cx.entity().downgrade();
 501        this.list_state
 502            .set_scroll_handler(move |_event, _window, cx| {
 503                let list_state = list_state_for_scroll.clone();
 504                let thread_view = thread_view.clone();
 505                // N.B. We must defer because the scroll handler is called while the
 506                // ListState's RefCell is mutably borrowed. Reading logical_scroll_top()
 507                // directly would panic from a double borrow.
 508                cx.defer(move |cx| {
 509                    let scroll_top = list_state.logical_scroll_top();
 510                    let _ = thread_view.update(cx, |this, cx| {
 511                        if let Some(thread) = this.as_native_thread(cx) {
 512                            thread.update(cx, |thread, _cx| {
 513                                thread.set_ui_scroll_position(Some(scroll_top));
 514                            });
 515                        }
 516                        this.schedule_save(cx);
 517                    });
 518                });
 519            });
 520
 521        if should_auto_submit {
 522            this.send(window, cx);
 523        }
 524        this
 525    }
 526
 527    /// Schedule a throttled save of the thread state (draft prompt, scroll position, etc.).
 528    /// Multiple calls within `SERIALIZATION_THROTTLE_TIME` are coalesced into a single save.
 529    fn schedule_save(&mut self, cx: &mut Context<Self>) {
 530        self._save_task = Some(cx.spawn(async move |this, cx| {
 531            cx.background_executor()
 532                .timer(SERIALIZATION_THROTTLE_TIME)
 533                .await;
 534            this.update(cx, |this, cx| {
 535                if let Some(thread) = this.as_native_thread(cx) {
 536                    thread.update(cx, |_thread, cx| cx.notify());
 537                }
 538            })
 539            .ok();
 540        }));
 541    }
 542
 543    pub fn handle_message_editor_event(
 544        &mut self,
 545        _editor: &Entity<MessageEditor>,
 546        event: &MessageEditorEvent,
 547        window: &mut Window,
 548        cx: &mut Context<Self>,
 549    ) {
 550        match event {
 551            MessageEditorEvent::Send => self.send(window, cx),
 552            MessageEditorEvent::SendImmediately => self.interrupt_and_send(window, cx),
 553            MessageEditorEvent::Cancel => self.cancel_generation(cx),
 554            MessageEditorEvent::Focus => {
 555                self.cancel_editing(&Default::default(), window, cx);
 556            }
 557            MessageEditorEvent::LostFocus => {}
 558            MessageEditorEvent::InputAttempted(_) => {}
 559        }
 560    }
 561
 562    pub(crate) fn as_native_connection(
 563        &self,
 564        cx: &App,
 565    ) -> Option<Rc<agent::NativeAgentConnection>> {
 566        let acp_thread = self.thread.read(cx);
 567        acp_thread.connection().clone().downcast()
 568    }
 569
 570    pub(crate) fn as_native_thread(&self, cx: &App) -> Option<Entity<agent::Thread>> {
 571        let acp_thread = self.thread.read(cx);
 572        self.as_native_connection(cx)?
 573            .thread(acp_thread.session_id(), cx)
 574    }
 575
 576    /// Resolves the message editor's contents into content blocks. For profiles
 577    /// that do not enable any tools, directory mentions are expanded to inline
 578    /// file contents since the agent can't read files on its own.
 579    fn resolve_message_contents(
 580        &self,
 581        message_editor: &Entity<MessageEditor>,
 582        cx: &mut App,
 583    ) -> Task<Result<(Vec<acp::ContentBlock>, Vec<Entity<Buffer>>)>> {
 584        let expand = self.as_native_thread(cx).is_some_and(|thread| {
 585            let thread = thread.read(cx);
 586            AgentSettings::get_global(cx)
 587                .profiles
 588                .get(thread.profile())
 589                .is_some_and(|profile| profile.tools.is_empty())
 590        });
 591        message_editor.update(cx, |message_editor, cx| message_editor.contents(expand, cx))
 592    }
 593
 594    pub fn current_model_id(&self, cx: &App) -> Option<String> {
 595        let selector = self.model_selector.as_ref()?;
 596        let model = selector.read(cx).active_model(cx)?;
 597        Some(model.id.to_string())
 598    }
 599
 600    pub fn current_mode_id(&self, cx: &App) -> Option<Arc<str>> {
 601        if let Some(thread) = self.as_native_thread(cx) {
 602            Some(thread.read(cx).profile().0.clone())
 603        } else {
 604            let mode_selector = self.mode_selector.as_ref()?;
 605            Some(mode_selector.read(cx).mode().0)
 606        }
 607    }
 608
 609    fn is_subagent(&self) -> bool {
 610        self.parent_id.is_some()
 611    }
 612
 613    /// Returns the currently active editor, either for a message that is being
 614    /// edited or the editor for a new message.
 615    pub(crate) fn active_editor(&self, cx: &App) -> Entity<MessageEditor> {
 616        if let Some(index) = self.editing_message
 617            && let Some(editor) = self
 618                .entry_view_state
 619                .read(cx)
 620                .entry(index)
 621                .and_then(|entry| entry.message_editor())
 622                .cloned()
 623        {
 624            editor
 625        } else {
 626            self.message_editor.clone()
 627        }
 628    }
 629
 630    pub fn has_queued_messages(&self) -> bool {
 631        !self.local_queued_messages.is_empty()
 632    }
 633
 634    pub fn is_imported_thread(&self, cx: &App) -> bool {
 635        let Some(thread) = self.as_native_thread(cx) else {
 636            return false;
 637        };
 638        thread.read(cx).is_imported()
 639    }
 640
 641    // events
 642
 643    pub fn handle_entry_view_event(
 644        &mut self,
 645        _: &Entity<EntryViewState>,
 646        event: &EntryViewEvent,
 647        window: &mut Window,
 648        cx: &mut Context<Self>,
 649    ) {
 650        match &event.view_event {
 651            ViewEvent::NewDiff(tool_call_id) => {
 652                if AgentSettings::get_global(cx).expand_edit_card {
 653                    self.expanded_tool_calls.insert(tool_call_id.clone());
 654                }
 655            }
 656            ViewEvent::NewTerminal(tool_call_id) => {
 657                if AgentSettings::get_global(cx).expand_terminal_card {
 658                    self.expanded_tool_calls.insert(tool_call_id.clone());
 659                }
 660            }
 661            ViewEvent::TerminalMovedToBackground(tool_call_id) => {
 662                self.expanded_tool_calls.remove(tool_call_id);
 663            }
 664            ViewEvent::MessageEditorEvent(_editor, MessageEditorEvent::Focus) => {
 665                if let Some(AgentThreadEntry::UserMessage(user_message)) =
 666                    self.thread.read(cx).entries().get(event.entry_index)
 667                    && user_message.id.is_some()
 668                {
 669                    self.editing_message = Some(event.entry_index);
 670                    cx.notify();
 671                }
 672            }
 673            ViewEvent::MessageEditorEvent(editor, MessageEditorEvent::LostFocus) => {
 674                if let Some(AgentThreadEntry::UserMessage(user_message)) =
 675                    self.thread.read(cx).entries().get(event.entry_index)
 676                    && user_message.id.is_some()
 677                {
 678                    if editor.read(cx).text(cx).as_str() == user_message.content.to_markdown(cx) {
 679                        self.editing_message = None;
 680                        cx.notify();
 681                    }
 682                }
 683            }
 684            ViewEvent::MessageEditorEvent(_editor, MessageEditorEvent::SendImmediately) => {}
 685            ViewEvent::MessageEditorEvent(editor, MessageEditorEvent::Send) => {
 686                self.regenerate(event.entry_index, editor.clone(), window, cx);
 687            }
 688            ViewEvent::MessageEditorEvent(_editor, MessageEditorEvent::Cancel) => {
 689                self.cancel_editing(&Default::default(), window, cx);
 690            }
 691            ViewEvent::MessageEditorEvent(_editor, MessageEditorEvent::InputAttempted(_)) => {}
 692            ViewEvent::OpenDiffLocation {
 693                path,
 694                position,
 695                split,
 696            } => {
 697                self.open_diff_location(path, *position, *split, window, cx);
 698            }
 699        }
 700    }
 701
 702    fn open_diff_location(
 703        &self,
 704        path: &str,
 705        position: Point,
 706        split: bool,
 707        window: &mut Window,
 708        cx: &mut Context<Self>,
 709    ) {
 710        let Some(project) = self.project.upgrade() else {
 711            return;
 712        };
 713        let Some(project_path) = project.read(cx).find_project_path(path, cx) else {
 714            return;
 715        };
 716
 717        let open_task = if split {
 718            self.workspace
 719                .update(cx, |workspace, cx| {
 720                    workspace.split_path(project_path, window, cx)
 721                })
 722                .log_err()
 723        } else {
 724            self.workspace
 725                .update(cx, |workspace, cx| {
 726                    workspace.open_path(project_path, None, true, window, cx)
 727                })
 728                .log_err()
 729        };
 730
 731        let Some(open_task) = open_task else {
 732            return;
 733        };
 734
 735        window
 736            .spawn(cx, async move |cx| {
 737                let item = open_task.await?;
 738                let Some(editor) = item.downcast::<Editor>() else {
 739                    return anyhow::Ok(());
 740                };
 741                editor.update_in(cx, |editor, window, cx| {
 742                    editor.change_selections(
 743                        SelectionEffects::scroll(Autoscroll::center()),
 744                        window,
 745                        cx,
 746                        |selections| {
 747                            selections.select_ranges([position..position]);
 748                        },
 749                    );
 750                })?;
 751                anyhow::Ok(())
 752            })
 753            .detach_and_log_err(cx);
 754    }
 755
 756    // turns
 757
 758    pub fn start_turn(&mut self, cx: &mut Context<Self>) -> usize {
 759        self.turn_fields.turn_generation += 1;
 760        let generation = self.turn_fields.turn_generation;
 761        self.turn_fields.turn_started_at = Some(Instant::now());
 762        self.turn_fields.last_turn_duration = None;
 763        self.turn_fields.last_turn_tokens = None;
 764        self.turn_fields.turn_tokens = Some(0);
 765        self.turn_fields._turn_timer_task = Some(cx.spawn(async move |this, cx| {
 766            loop {
 767                cx.background_executor().timer(Duration::from_secs(1)).await;
 768                if this.update(cx, |_, cx| cx.notify()).is_err() {
 769                    break;
 770                }
 771            }
 772        }));
 773        generation
 774    }
 775
 776    pub fn stop_turn(&mut self, generation: usize) {
 777        if self.turn_fields.turn_generation != generation {
 778            return;
 779        }
 780        self.turn_fields.last_turn_duration = self
 781            .turn_fields
 782            .turn_started_at
 783            .take()
 784            .map(|started| started.elapsed());
 785        self.turn_fields.last_turn_tokens = self.turn_fields.turn_tokens.take();
 786        self.turn_fields._turn_timer_task = None;
 787    }
 788
 789    pub fn update_turn_tokens(&mut self, cx: &App) {
 790        if let Some(usage) = self.thread.read(cx).token_usage() {
 791            if let Some(tokens) = &mut self.turn_fields.turn_tokens {
 792                *tokens += usage.output_tokens;
 793            }
 794        }
 795    }
 796
 797    // sending
 798
 799    fn clear_external_source_prompt_warning(&mut self, cx: &mut Context<Self>) {
 800        if self.show_external_source_prompt_warning {
 801            self.show_external_source_prompt_warning = false;
 802            cx.notify();
 803        }
 804    }
 805
 806    pub fn send(&mut self, window: &mut Window, cx: &mut Context<Self>) {
 807        let thread = &self.thread;
 808
 809        if self.is_loading_contents {
 810            return;
 811        }
 812
 813        let message_editor = self.message_editor.clone();
 814
 815        // Intercept the first send so the agent panel can capture the full
 816        // content blocks — needed for "Start thread in New Worktree",
 817        // which must create a workspace before sending the message there.
 818        let intercept_first_send = self.thread.read(cx).entries().is_empty()
 819            && !message_editor.read(cx).is_empty(cx)
 820            && self
 821                .workspace
 822                .upgrade()
 823                .and_then(|workspace| workspace.read(cx).panel::<AgentPanel>(cx))
 824                .is_some_and(|panel| {
 825                    panel.read(cx).start_thread_in() == &StartThreadIn::NewWorktree
 826                });
 827
 828        if intercept_first_send {
 829            let content_task = self.resolve_message_contents(&message_editor, cx);
 830
 831            cx.spawn(async move |this, cx| match content_task.await {
 832                Ok((content, _tracked_buffers)) => {
 833                    if content.is_empty() {
 834                        return;
 835                    }
 836
 837                    this.update(cx, |_, cx| {
 838                        cx.emit(AcpThreadViewEvent::FirstSendRequested { content });
 839                    })
 840                    .ok();
 841                }
 842                Err(error) => {
 843                    this.update(cx, |this, cx| {
 844                        this.handle_thread_error(error, cx);
 845                    })
 846                    .ok();
 847                }
 848            })
 849            .detach();
 850
 851            return;
 852        }
 853
 854        let is_editor_empty = message_editor.read(cx).is_empty(cx);
 855        let is_generating = thread.read(cx).status() != ThreadStatus::Idle;
 856
 857        let has_queued = self.has_queued_messages();
 858        if is_editor_empty && self.can_fast_track_queue && has_queued {
 859            self.can_fast_track_queue = false;
 860            self.send_queued_message_at_index(0, true, window, cx);
 861            return;
 862        }
 863
 864        if is_editor_empty {
 865            return;
 866        }
 867
 868        if is_generating {
 869            self.queue_message(message_editor, window, cx);
 870            return;
 871        }
 872
 873        let text = message_editor.read(cx).text(cx);
 874        let text = text.trim();
 875        if text == "/login" || text == "/logout" {
 876            let connection = thread.read(cx).connection().clone();
 877            let can_login = !connection.auth_methods().is_empty();
 878            // Does the agent have a specific logout command? Prefer that in case they need to reset internal state.
 879            let logout_supported = text == "/logout"
 880                && self
 881                    .available_commands
 882                    .borrow()
 883                    .iter()
 884                    .any(|command| command.name == "logout");
 885            if can_login && !logout_supported {
 886                message_editor.update(cx, |editor, cx| editor.clear(window, cx));
 887                self.clear_external_source_prompt_warning(cx);
 888
 889                let connection = self.thread.read(cx).connection().clone();
 890                window.defer(cx, {
 891                    let agent_name = self.agent_name.clone();
 892                    let server_view = self.server_view.clone();
 893                    move |window, cx| {
 894                        ConnectionView::handle_auth_required(
 895                            server_view.clone(),
 896                            AuthRequired::new(),
 897                            agent_name,
 898                            connection,
 899                            window,
 900                            cx,
 901                        );
 902                    }
 903                });
 904                cx.notify();
 905                return;
 906            }
 907        }
 908
 909        self.send_impl(message_editor, window, cx)
 910    }
 911
 912    pub fn send_impl(
 913        &mut self,
 914        message_editor: Entity<MessageEditor>,
 915        window: &mut Window,
 916        cx: &mut Context<Self>,
 917    ) {
 918        let contents = self.resolve_message_contents(&message_editor, cx);
 919
 920        self.thread_error.take();
 921        self.thread_feedback.clear();
 922        self.editing_message.take();
 923
 924        if self.should_be_following {
 925            self.workspace
 926                .update(cx, |workspace, cx| {
 927                    workspace.follow(CollaboratorId::Agent, window, cx);
 928                })
 929                .ok();
 930        }
 931
 932        let contents_task = cx.spawn_in(window, async move |_this, cx| {
 933            let (contents, tracked_buffers) = contents.await?;
 934
 935            if contents.is_empty() {
 936                return Ok(None);
 937            }
 938
 939            let _ = cx.update(|window, cx| {
 940                message_editor.update(cx, |message_editor, cx| {
 941                    message_editor.clear(window, cx);
 942                });
 943            });
 944
 945            Ok(Some((contents, tracked_buffers)))
 946        });
 947
 948        self.send_content(contents_task, window, cx);
 949    }
 950
 951    pub fn send_content(
 952        &mut self,
 953        contents_task: Task<anyhow::Result<Option<(Vec<acp::ContentBlock>, Vec<Entity<Buffer>>)>>>,
 954        window: &mut Window,
 955        cx: &mut Context<Self>,
 956    ) {
 957        let session_id = self.thread.read(cx).session_id().clone();
 958        let parent_session_id = self.thread.read(cx).parent_session_id().cloned();
 959        let agent_telemetry_id = self.thread.read(cx).connection().telemetry_id();
 960        let is_first_message = self.thread.read(cx).entries().is_empty();
 961        let thread = self.thread.downgrade();
 962
 963        self.is_loading_contents = true;
 964
 965        let model_id = self.current_model_id(cx);
 966        let mode_id = self.current_mode_id(cx);
 967        let guard = cx.new(|_| ());
 968        cx.observe_release(&guard, |this, _guard, cx| {
 969            this.is_loading_contents = false;
 970            cx.notify();
 971        })
 972        .detach();
 973
 974        let task = cx.spawn_in(window, async move |this, cx| {
 975            let Some((contents, tracked_buffers)) = contents_task.await? else {
 976                return Ok(());
 977            };
 978
 979            let generation = this.update(cx, |this, cx| {
 980                this.clear_external_source_prompt_warning(cx);
 981                let generation = this.start_turn(cx);
 982                this.in_flight_prompt = Some(contents.clone());
 983                generation
 984            })?;
 985
 986            this.update_in(cx, |this, _window, cx| {
 987                this.set_editor_is_expanded(false, cx);
 988            })?;
 989            let _ = this.update(cx, |this, cx| this.scroll_to_bottom(cx));
 990
 991            let _stop_turn = defer({
 992                let this = this.clone();
 993                let mut cx = cx.clone();
 994                move || {
 995                    this.update(&mut cx, |this, cx| {
 996                        this.stop_turn(generation);
 997                        cx.notify();
 998                    })
 999                    .ok();
1000                }
1001            });
1002            if is_first_message {
1003                let text: String = contents
1004                    .iter()
1005                    .filter_map(|block| match block {
1006                        acp::ContentBlock::Text(text_content) => Some(text_content.text.as_str()),
1007                        _ => None,
1008                    })
1009                    .collect::<Vec<_>>()
1010                    .join(" ");
1011                let text = text.lines().next().unwrap_or("").trim();
1012                if !text.is_empty() {
1013                    let title: SharedString = util::truncate_and_trailoff(text, 20).into();
1014                    thread.update(cx, |thread, cx| {
1015                        thread.set_provisional_title(title, cx);
1016                    })?;
1017                }
1018            }
1019
1020            let turn_start_time = Instant::now();
1021            let send = thread.update(cx, |thread, cx| {
1022                thread.action_log().update(cx, |action_log, cx| {
1023                    for buffer in tracked_buffers {
1024                        action_log.buffer_read(buffer, cx)
1025                    }
1026                });
1027                drop(guard);
1028
1029                telemetry::event!(
1030                    "Agent Message Sent",
1031                    agent = agent_telemetry_id,
1032                    session = session_id,
1033                    parent_session_id = parent_session_id.as_ref().map(|id| id.to_string()),
1034                    model = model_id,
1035                    mode = mode_id
1036                );
1037
1038                thread.send(contents, cx)
1039            })?;
1040            let res = send.await;
1041            let turn_time_ms = turn_start_time.elapsed().as_millis();
1042            drop(_stop_turn);
1043            let status = if res.is_ok() {
1044                let _ = this.update(cx, |this, _| this.in_flight_prompt.take());
1045                "success"
1046            } else {
1047                "failure"
1048            };
1049            telemetry::event!(
1050                "Agent Turn Completed",
1051                agent = agent_telemetry_id,
1052                session = session_id,
1053                parent_session_id = parent_session_id.as_ref().map(|id| id.to_string()),
1054                model = model_id,
1055                mode = mode_id,
1056                status,
1057                turn_time_ms,
1058            );
1059            res.map(|_| ())
1060        });
1061
1062        cx.spawn(async move |this, cx| {
1063            if let Err(err) = task.await {
1064                this.update(cx, |this, cx| {
1065                    this.handle_thread_error(err, cx);
1066                })
1067                .ok();
1068            } else {
1069                this.update(cx, |this, cx| {
1070                    let should_be_following = this
1071                        .workspace
1072                        .update(cx, |workspace, _| {
1073                            workspace.is_being_followed(CollaboratorId::Agent)
1074                        })
1075                        .unwrap_or_default();
1076                    this.should_be_following = should_be_following;
1077                })
1078                .ok();
1079            }
1080        })
1081        .detach();
1082    }
1083
1084    pub fn interrupt_and_send(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1085        let thread = &self.thread;
1086
1087        if self.is_loading_contents {
1088            return;
1089        }
1090
1091        let message_editor = self.message_editor.clone();
1092        if thread.read(cx).status() == ThreadStatus::Idle {
1093            self.send_impl(message_editor, window, cx);
1094            return;
1095        }
1096
1097        self.stop_current_and_send_new_message(message_editor, window, cx);
1098    }
1099
1100    fn stop_current_and_send_new_message(
1101        &mut self,
1102        message_editor: Entity<MessageEditor>,
1103        window: &mut Window,
1104        cx: &mut Context<Self>,
1105    ) {
1106        let thread = self.thread.clone();
1107        self.skip_queue_processing_count = 0;
1108        self.user_interrupted_generation = true;
1109
1110        let cancelled = thread.update(cx, |thread, cx| thread.cancel(cx));
1111
1112        cx.spawn_in(window, async move |this, cx| {
1113            cancelled.await;
1114
1115            this.update_in(cx, |this, window, cx| {
1116                this.send_impl(message_editor, window, cx);
1117            })
1118            .ok();
1119        })
1120        .detach();
1121    }
1122
1123    pub(crate) fn handle_thread_error(
1124        &mut self,
1125        error: impl Into<ThreadError>,
1126        cx: &mut Context<Self>,
1127    ) {
1128        let error = error.into();
1129        self.emit_thread_error_telemetry(&error, cx);
1130        self.thread_error = Some(error);
1131        cx.notify();
1132    }
1133
1134    fn emit_thread_error_telemetry(&self, error: &ThreadError, cx: &mut Context<Self>) {
1135        let (error_kind, acp_error_code, message): (&str, Option<SharedString>, SharedString) =
1136            match error {
1137                ThreadError::PaymentRequired => (
1138                    "payment_required",
1139                    None,
1140                    "You reached your free usage limit. Upgrade to Zed Pro for more prompts."
1141                        .into(),
1142                ),
1143                ThreadError::Refusal => {
1144                    let model_or_agent_name = self.current_model_name(cx);
1145                    let message = format!(
1146                        "{} refused to respond to this prompt. This can happen when a model believes the prompt violates its content policy or safety guidelines, so rephrasing it can sometimes address the issue.",
1147                        model_or_agent_name
1148                    );
1149                    ("refusal", None, message.into())
1150                }
1151                ThreadError::AuthenticationRequired(message) => {
1152                    ("authentication_required", None, message.clone())
1153                }
1154                ThreadError::Other {
1155                    acp_error_code,
1156                    message,
1157                } => ("other", acp_error_code.clone(), message.clone()),
1158            };
1159
1160        let agent_telemetry_id = self.thread.read(cx).connection().telemetry_id();
1161        let session_id = self.thread.read(cx).session_id().clone();
1162        let parent_session_id = self
1163            .thread
1164            .read(cx)
1165            .parent_session_id()
1166            .map(|id| id.to_string());
1167
1168        telemetry::event!(
1169            "Agent Panel Error Shown",
1170            agent = agent_telemetry_id,
1171            session_id = session_id,
1172            parent_session_id = parent_session_id,
1173            kind = error_kind,
1174            acp_error_code = acp_error_code,
1175            message = message,
1176        );
1177    }
1178
1179    // generation
1180
1181    pub fn cancel_generation(&mut self, cx: &mut Context<Self>) {
1182        self.thread_retry_status.take();
1183        self.thread_error.take();
1184        self.user_interrupted_generation = true;
1185        self._cancel_task = Some(self.thread.update(cx, |thread, cx| thread.cancel(cx)));
1186    }
1187
1188    pub fn retry_generation(&mut self, cx: &mut Context<Self>) {
1189        self.thread_error.take();
1190
1191        let thread = &self.thread;
1192        if !thread.read(cx).can_retry(cx) {
1193            return;
1194        }
1195
1196        let task = thread.update(cx, |thread, cx| thread.retry(cx));
1197        cx.spawn(async move |this, cx| {
1198            let result = task.await;
1199
1200            this.update(cx, |this, cx| {
1201                if let Err(err) = result {
1202                    this.handle_thread_error(err, cx);
1203                }
1204            })
1205        })
1206        .detach();
1207    }
1208
1209    pub fn regenerate(
1210        &mut self,
1211        entry_ix: usize,
1212        message_editor: Entity<MessageEditor>,
1213        window: &mut Window,
1214        cx: &mut Context<Self>,
1215    ) {
1216        if self.is_loading_contents {
1217            return;
1218        }
1219        let thread = self.thread.clone();
1220
1221        let Some(user_message_id) = thread.update(cx, |thread, _| {
1222            thread.entries().get(entry_ix)?.user_message()?.id.clone()
1223        }) else {
1224            return;
1225        };
1226
1227        cx.spawn_in(window, async move |this, cx| {
1228            // Check if there are any edits from prompts before the one being regenerated.
1229            //
1230            // If there are, we keep/accept them since we're not regenerating the prompt that created them.
1231            //
1232            // If editing the prompt that generated the edits, they are auto-rejected
1233            // through the `rewind` function in the `acp_thread`.
1234            let has_earlier_edits = thread.read_with(cx, |thread, _| {
1235                thread
1236                    .entries()
1237                    .iter()
1238                    .take(entry_ix)
1239                    .any(|entry| entry.diffs().next().is_some())
1240            });
1241
1242            if has_earlier_edits {
1243                thread.update(cx, |thread, cx| {
1244                    thread.action_log().update(cx, |action_log, cx| {
1245                        action_log.keep_all_edits(None, cx);
1246                    });
1247                });
1248            }
1249
1250            thread
1251                .update(cx, |thread, cx| thread.rewind(user_message_id, cx))
1252                .await?;
1253            this.update_in(cx, |thread, window, cx| {
1254                thread.send_impl(message_editor, window, cx);
1255                thread.focus_handle(cx).focus(window, cx);
1256            })?;
1257            anyhow::Ok(())
1258        })
1259        .detach_and_log_err(cx);
1260    }
1261
1262    // message queueing
1263
1264    fn queue_message(
1265        &mut self,
1266        message_editor: Entity<MessageEditor>,
1267        window: &mut Window,
1268        cx: &mut Context<Self>,
1269    ) {
1270        let is_idle = self.thread.read(cx).status() == acp_thread::ThreadStatus::Idle;
1271
1272        if is_idle {
1273            self.send_impl(message_editor, window, cx);
1274            return;
1275        }
1276
1277        let contents = self.resolve_message_contents(&message_editor, cx);
1278
1279        cx.spawn_in(window, async move |this, cx| {
1280            let (content, tracked_buffers) = contents.await?;
1281
1282            if content.is_empty() {
1283                return Ok::<(), anyhow::Error>(());
1284            }
1285
1286            this.update_in(cx, |this, window, cx| {
1287                this.add_to_queue(content, tracked_buffers, cx);
1288                this.can_fast_track_queue = true;
1289                message_editor.update(cx, |message_editor, cx| {
1290                    message_editor.clear(window, cx);
1291                });
1292                cx.notify();
1293            })?;
1294            Ok(())
1295        })
1296        .detach_and_log_err(cx);
1297    }
1298
1299    pub fn add_to_queue(
1300        &mut self,
1301        content: Vec<acp::ContentBlock>,
1302        tracked_buffers: Vec<Entity<Buffer>>,
1303        cx: &mut Context<Self>,
1304    ) {
1305        self.local_queued_messages.push(QueuedMessage {
1306            content,
1307            tracked_buffers,
1308        });
1309        self.sync_queue_flag_to_native_thread(cx);
1310    }
1311
1312    pub fn remove_from_queue(
1313        &mut self,
1314        index: usize,
1315        cx: &mut Context<Self>,
1316    ) -> Option<QueuedMessage> {
1317        if index < self.local_queued_messages.len() {
1318            let removed = self.local_queued_messages.remove(index);
1319            self.sync_queue_flag_to_native_thread(cx);
1320            Some(removed)
1321        } else {
1322            None
1323        }
1324    }
1325
1326    pub fn sync_queue_flag_to_native_thread(&self, cx: &mut Context<Self>) {
1327        if let Some(native_thread) = self.as_native_thread(cx) {
1328            let has_queued = self.has_queued_messages();
1329            native_thread.update(cx, |thread, _| {
1330                thread.set_has_queued_message(has_queued);
1331            });
1332        }
1333    }
1334
1335    pub fn send_queued_message_at_index(
1336        &mut self,
1337        index: usize,
1338        is_send_now: bool,
1339        window: &mut Window,
1340        cx: &mut Context<Self>,
1341    ) {
1342        let Some(queued) = self.remove_from_queue(index, cx) else {
1343            return;
1344        };
1345        let content = queued.content;
1346        let tracked_buffers = queued.tracked_buffers;
1347
1348        // Only increment skip count for "Send Now" operations (out-of-order sends)
1349        // Normal auto-processing from the Stopped handler doesn't need to skip.
1350        // We only skip the Stopped event from the cancelled generation, NOT the
1351        // Stopped event from the newly sent message (which should trigger queue processing).
1352        if is_send_now {
1353            let is_generating =
1354                self.thread.read(cx).status() == acp_thread::ThreadStatus::Generating;
1355            self.skip_queue_processing_count += if is_generating { 1 } else { 0 };
1356        }
1357
1358        let cancelled = self.thread.update(cx, |thread, cx| thread.cancel(cx));
1359
1360        let workspace = self.workspace.clone();
1361
1362        let should_be_following = self.should_be_following;
1363        let contents_task = cx.spawn_in(window, async move |_this, cx| {
1364            cancelled.await;
1365            if should_be_following {
1366                workspace
1367                    .update_in(cx, |workspace, window, cx| {
1368                        workspace.follow(CollaboratorId::Agent, window, cx);
1369                    })
1370                    .ok();
1371            }
1372
1373            Ok(Some((content, tracked_buffers)))
1374        });
1375
1376        self.send_content(contents_task, window, cx);
1377    }
1378
1379    pub fn move_queued_message_to_main_editor(
1380        &mut self,
1381        index: usize,
1382        inserted_text: Option<&str>,
1383        window: &mut Window,
1384        cx: &mut Context<Self>,
1385    ) -> bool {
1386        let Some(queued_message) = self.remove_from_queue(index, cx) else {
1387            return false;
1388        };
1389        let queued_content = queued_message.content;
1390        let message_editor = self.message_editor.clone();
1391        let inserted_text = inserted_text.map(ToOwned::to_owned);
1392
1393        window.focus(&message_editor.focus_handle(cx), cx);
1394
1395        if message_editor.read(cx).is_empty(cx) {
1396            message_editor.update(cx, |editor, cx| {
1397                editor.set_message(queued_content, window, cx);
1398                if let Some(inserted_text) = inserted_text.as_deref() {
1399                    editor.insert_text(inserted_text, window, cx);
1400                }
1401            });
1402            cx.notify();
1403            return true;
1404        }
1405
1406        message_editor.update(cx, |editor, cx| {
1407            editor.append_message(queued_content, Some("\n\n"), window, cx);
1408            if let Some(inserted_text) = inserted_text.as_deref() {
1409                editor.insert_text(inserted_text, window, cx);
1410            }
1411        });
1412
1413        cx.notify();
1414        true
1415    }
1416
1417    // editor methods
1418
1419    pub fn expand_message_editor(
1420        &mut self,
1421        _: &ExpandMessageEditor,
1422        _window: &mut Window,
1423        cx: &mut Context<Self>,
1424    ) {
1425        self.set_editor_is_expanded(!self.editor_expanded, cx);
1426        cx.stop_propagation();
1427        cx.notify();
1428    }
1429
1430    pub fn set_editor_is_expanded(&mut self, is_expanded: bool, cx: &mut Context<Self>) {
1431        self.editor_expanded = is_expanded;
1432        self.message_editor.update(cx, |editor, cx| {
1433            if is_expanded {
1434                editor.set_mode(
1435                    EditorMode::Full {
1436                        scale_ui_elements_with_buffer_font_size: false,
1437                        show_active_line_background: false,
1438                        sizing_behavior: SizingBehavior::ExcludeOverscrollMargin,
1439                    },
1440                    cx,
1441                )
1442            } else {
1443                let agent_settings = AgentSettings::get_global(cx);
1444                editor.set_mode(
1445                    EditorMode::AutoHeight {
1446                        min_lines: agent_settings.message_editor_min_lines,
1447                        max_lines: Some(agent_settings.set_message_editor_max_lines()),
1448                    },
1449                    cx,
1450                )
1451            }
1452        });
1453        cx.notify();
1454    }
1455
1456    pub fn handle_title_editor_event(
1457        &mut self,
1458        title_editor: &Entity<Editor>,
1459        event: &EditorEvent,
1460        window: &mut Window,
1461        cx: &mut Context<Self>,
1462    ) {
1463        let thread = &self.thread;
1464
1465        match event {
1466            EditorEvent::BufferEdited => {
1467                let new_title = title_editor.read(cx).text(cx);
1468                thread.update(cx, |thread, cx| {
1469                    thread
1470                        .set_title(new_title.into(), cx)
1471                        .detach_and_log_err(cx);
1472                })
1473            }
1474            EditorEvent::Blurred => {
1475                if title_editor.read(cx).text(cx).is_empty() {
1476                    title_editor.update(cx, |editor, cx| {
1477                        editor.set_text("New Thread", window, cx);
1478                    });
1479                }
1480            }
1481            _ => {}
1482        }
1483    }
1484
1485    pub fn cancel_editing(&mut self, _: &ClickEvent, window: &mut Window, cx: &mut Context<Self>) {
1486        if let Some(index) = self.editing_message.take()
1487            && let Some(editor) = &self
1488                .entry_view_state
1489                .read(cx)
1490                .entry(index)
1491                .and_then(|e| e.message_editor())
1492                .cloned()
1493        {
1494            editor.update(cx, |editor, cx| {
1495                if let Some(user_message) = self
1496                    .thread
1497                    .read(cx)
1498                    .entries()
1499                    .get(index)
1500                    .and_then(|e| e.user_message())
1501                {
1502                    editor.set_message(user_message.chunks.clone(), window, cx);
1503                }
1504            })
1505        };
1506        cx.notify();
1507    }
1508
1509    // tool permissions
1510
1511    pub fn authorize_tool_call(
1512        &mut self,
1513        session_id: acp::SessionId,
1514        tool_call_id: acp::ToolCallId,
1515        option_id: acp::PermissionOptionId,
1516        option_kind: acp::PermissionOptionKind,
1517        window: &mut Window,
1518        cx: &mut Context<Self>,
1519    ) {
1520        self.conversation.update(cx, |conversation, cx| {
1521            conversation.authorize_tool_call(session_id, tool_call_id, option_id, option_kind, cx);
1522        });
1523        if self.should_be_following {
1524            self.workspace
1525                .update(cx, |workspace, cx| {
1526                    workspace.follow(CollaboratorId::Agent, window, cx);
1527                })
1528                .ok();
1529        }
1530        cx.notify();
1531    }
1532
1533    pub fn allow_always(&mut self, _: &AllowAlways, window: &mut Window, cx: &mut Context<Self>) {
1534        self.authorize_pending_tool_call(acp::PermissionOptionKind::AllowAlways, window, cx);
1535    }
1536
1537    pub fn allow_once(&mut self, _: &AllowOnce, window: &mut Window, cx: &mut Context<Self>) {
1538        self.authorize_pending_with_granularity(true, window, cx);
1539    }
1540
1541    pub fn reject_once(&mut self, _: &RejectOnce, window: &mut Window, cx: &mut Context<Self>) {
1542        self.authorize_pending_with_granularity(false, window, cx);
1543    }
1544
1545    pub fn authorize_pending_tool_call(
1546        &mut self,
1547        kind: acp::PermissionOptionKind,
1548        window: &mut Window,
1549        cx: &mut Context<Self>,
1550    ) -> Option<()> {
1551        self.conversation.update(cx, |conversation, cx| {
1552            conversation.authorize_pending_tool_call(&self.id, kind, cx)
1553        })?;
1554        if self.should_be_following {
1555            self.workspace
1556                .update(cx, |workspace, cx| {
1557                    workspace.follow(CollaboratorId::Agent, window, cx);
1558                })
1559                .ok();
1560        }
1561        cx.notify();
1562        Some(())
1563    }
1564
1565    fn handle_authorize_tool_call(
1566        &mut self,
1567        action: &AuthorizeToolCall,
1568        window: &mut Window,
1569        cx: &mut Context<Self>,
1570    ) {
1571        let tool_call_id = acp::ToolCallId::new(action.tool_call_id.clone());
1572        let option_id = acp::PermissionOptionId::new(action.option_id.clone());
1573        let option_kind = match action.option_kind.as_str() {
1574            "AllowOnce" => acp::PermissionOptionKind::AllowOnce,
1575            "AllowAlways" => acp::PermissionOptionKind::AllowAlways,
1576            "RejectOnce" => acp::PermissionOptionKind::RejectOnce,
1577            "RejectAlways" => acp::PermissionOptionKind::RejectAlways,
1578            _ => acp::PermissionOptionKind::AllowOnce,
1579        };
1580
1581        self.authorize_tool_call(
1582            self.id.clone(),
1583            tool_call_id,
1584            option_id,
1585            option_kind,
1586            window,
1587            cx,
1588        );
1589    }
1590
1591    fn authorize_pending_with_granularity(
1592        &mut self,
1593        is_allow: bool,
1594        window: &mut Window,
1595        cx: &mut Context<Self>,
1596    ) -> Option<()> {
1597        let (session_id, tool_call_id, options) =
1598            self.conversation.read(cx).pending_tool_call(&self.id, cx)?;
1599        let PermissionOptions::Dropdown(choices) = options else {
1600            let kind = if is_allow {
1601                acp::PermissionOptionKind::AllowOnce
1602            } else {
1603                acp::PermissionOptionKind::RejectOnce
1604            };
1605            return self.authorize_pending_tool_call(kind, window, cx);
1606        };
1607
1608        // Get selected index, defaulting to last option ("Only this time")
1609        let selected_index = self
1610            .conversation
1611            .read(cx)
1612            .selected_permission_granularity(&session_id, &tool_call_id)
1613            .unwrap_or_else(|| choices.len().saturating_sub(1));
1614
1615        let selected_choice = choices.get(selected_index).or(choices.last())?;
1616
1617        let selected_option = if is_allow {
1618            &selected_choice.allow
1619        } else {
1620            &selected_choice.deny
1621        };
1622
1623        self.authorize_tool_call(
1624            session_id,
1625            tool_call_id,
1626            selected_option.option_id.clone(),
1627            selected_option.kind,
1628            window,
1629            cx,
1630        );
1631
1632        Some(())
1633    }
1634
1635    // edits
1636
1637    pub fn keep_all(&mut self, _: &KeepAll, _window: &mut Window, cx: &mut Context<Self>) {
1638        let thread = &self.thread;
1639        let telemetry = ActionLogTelemetry::from(thread.read(cx));
1640        let action_log = thread.read(cx).action_log().clone();
1641        action_log.update(cx, |action_log, cx| {
1642            action_log.keep_all_edits(Some(telemetry), cx)
1643        });
1644    }
1645
1646    pub fn reject_all(&mut self, _: &RejectAll, _window: &mut Window, cx: &mut Context<Self>) {
1647        let thread = &self.thread;
1648        let telemetry = ActionLogTelemetry::from(thread.read(cx));
1649        let action_log = thread.read(cx).action_log().clone();
1650        let has_changes = action_log.read(cx).changed_buffers(cx).len() > 0;
1651
1652        action_log
1653            .update(cx, |action_log, cx| {
1654                action_log.reject_all_edits(Some(telemetry), cx)
1655            })
1656            .detach();
1657
1658        if has_changes {
1659            if let Some(workspace) = self.workspace.upgrade() {
1660                workspace.update(cx, |workspace, cx| {
1661                    crate::ui::show_undo_reject_toast(workspace, action_log, cx);
1662                });
1663            }
1664        }
1665    }
1666
1667    pub fn undo_last_reject(
1668        &mut self,
1669        _: &UndoLastReject,
1670        _window: &mut Window,
1671        cx: &mut Context<Self>,
1672    ) {
1673        let thread = &self.thread;
1674        let action_log = thread.read(cx).action_log().clone();
1675        action_log
1676            .update(cx, |action_log, cx| action_log.undo_last_reject(cx))
1677            .detach()
1678    }
1679
1680    pub fn open_edited_buffer(
1681        &mut self,
1682        buffer: &Entity<Buffer>,
1683        window: &mut Window,
1684        cx: &mut Context<Self>,
1685    ) {
1686        let thread = &self.thread;
1687
1688        let Some(diff) =
1689            AgentDiffPane::deploy(thread.clone(), self.workspace.clone(), window, cx).log_err()
1690        else {
1691            return;
1692        };
1693
1694        diff.update(cx, |diff, cx| {
1695            diff.move_to_path(PathKey::for_buffer(buffer, cx), window, cx)
1696        })
1697    }
1698
1699    // thread stuff
1700
1701    fn share_thread(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
1702        let Some((thread, project)) = self.as_native_thread(cx).zip(self.project.upgrade()) else {
1703            return;
1704        };
1705
1706        let client = project.read(cx).client();
1707        let workspace = self.workspace.clone();
1708        let session_id = thread.read(cx).id().to_string();
1709
1710        let load_task = thread.read(cx).to_db(cx);
1711
1712        cx.spawn(async move |_this, cx| {
1713            let db_thread = load_task.await;
1714
1715            let shared_thread = SharedThread::from_db_thread(&db_thread);
1716            let thread_data = shared_thread.to_bytes()?;
1717            let title = shared_thread.title.to_string();
1718
1719            client
1720                .request(proto::ShareAgentThread {
1721                    session_id: session_id.clone(),
1722                    title,
1723                    thread_data,
1724                })
1725                .await?;
1726
1727            let share_url = client::zed_urls::shared_agent_thread_url(&session_id);
1728
1729            cx.update(|cx| {
1730                if let Some(workspace) = workspace.upgrade() {
1731                    workspace.update(cx, |workspace, cx| {
1732                        struct ThreadSharedToast;
1733                        workspace.show_toast(
1734                            Toast::new(
1735                                NotificationId::unique::<ThreadSharedToast>(),
1736                                "Thread shared!",
1737                            )
1738                            .on_click(
1739                                "Copy URL",
1740                                move |_window, cx| {
1741                                    cx.write_to_clipboard(ClipboardItem::new_string(
1742                                        share_url.clone(),
1743                                    ));
1744                                },
1745                            ),
1746                            cx,
1747                        );
1748                    });
1749                }
1750            });
1751
1752            anyhow::Ok(())
1753        })
1754        .detach_and_log_err(cx);
1755    }
1756
1757    pub fn sync_thread(
1758        &mut self,
1759        project: Entity<Project>,
1760        server_view: Entity<ConnectionView>,
1761        window: &mut Window,
1762        cx: &mut Context<Self>,
1763    ) {
1764        if !self.is_imported_thread(cx) {
1765            return;
1766        }
1767
1768        let Some(session_list) = self
1769            .as_native_connection(cx)
1770            .and_then(|connection| connection.session_list(cx))
1771            .and_then(|list| list.downcast::<NativeAgentSessionList>())
1772        else {
1773            return;
1774        };
1775        let thread_store = session_list.thread_store().clone();
1776
1777        let client = project.read(cx).client();
1778        let session_id = self.thread.read(cx).session_id().clone();
1779        cx.spawn_in(window, async move |this, cx| {
1780            let response = client
1781                .request(proto::GetSharedAgentThread {
1782                    session_id: session_id.to_string(),
1783                })
1784                .await?;
1785
1786            let shared_thread = SharedThread::from_bytes(&response.thread_data)?;
1787
1788            let db_thread = shared_thread.to_db_thread();
1789
1790            thread_store
1791                .update(&mut cx.clone(), |store, cx| {
1792                    store.save_thread(session_id.clone(), db_thread, Default::default(), cx)
1793                })
1794                .await?;
1795
1796            server_view.update_in(cx, |server_view, window, cx| server_view.reset(window, cx))?;
1797
1798            this.update_in(cx, |this, _window, cx| {
1799                if let Some(workspace) = this.workspace.upgrade() {
1800                    workspace.update(cx, |workspace, cx| {
1801                        struct ThreadSyncedToast;
1802                        workspace.show_toast(
1803                            Toast::new(
1804                                NotificationId::unique::<ThreadSyncedToast>(),
1805                                "Thread synced with latest version",
1806                            )
1807                            .autohide(),
1808                            cx,
1809                        );
1810                    });
1811                }
1812            })?;
1813
1814            anyhow::Ok(())
1815        })
1816        .detach_and_log_err(cx);
1817    }
1818
1819    pub fn restore_checkpoint(&mut self, message_id: &UserMessageId, cx: &mut Context<Self>) {
1820        self.thread
1821            .update(cx, |thread, cx| {
1822                thread.restore_checkpoint(message_id.clone(), cx)
1823            })
1824            .detach_and_log_err(cx);
1825    }
1826
1827    pub fn clear_thread_error(&mut self, cx: &mut Context<Self>) {
1828        self.thread_error = None;
1829        self.thread_error_markdown = None;
1830        self.token_limit_callout_dismissed = true;
1831        cx.notify();
1832    }
1833
1834    fn is_following(&self, cx: &App) -> bool {
1835        match self.thread.read(cx).status() {
1836            ThreadStatus::Generating => self
1837                .workspace
1838                .read_with(cx, |workspace, _| {
1839                    workspace.is_being_followed(CollaboratorId::Agent)
1840                })
1841                .unwrap_or(false),
1842            _ => self.should_be_following,
1843        }
1844    }
1845
1846    fn toggle_following(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1847        let following = self.is_following(cx);
1848
1849        self.should_be_following = !following;
1850        if self.thread.read(cx).status() == ThreadStatus::Generating {
1851            self.workspace
1852                .update(cx, |workspace, cx| {
1853                    if following {
1854                        workspace.unfollow(CollaboratorId::Agent, window, cx);
1855                    } else {
1856                        workspace.follow(CollaboratorId::Agent, window, cx);
1857                    }
1858                })
1859                .ok();
1860        }
1861
1862        telemetry::event!("Follow Agent Selected", following = !following);
1863    }
1864
1865    // other
1866
1867    pub fn render_thread_retry_status_callout(&self) -> Option<Callout> {
1868        let state = self.thread_retry_status.as_ref()?;
1869
1870        let next_attempt_in = state
1871            .duration
1872            .saturating_sub(Instant::now().saturating_duration_since(state.started_at));
1873        if next_attempt_in.is_zero() {
1874            return None;
1875        }
1876
1877        let next_attempt_in_secs = next_attempt_in.as_secs() + 1;
1878
1879        let retry_message = if state.max_attempts == 1 {
1880            if next_attempt_in_secs == 1 {
1881                "Retrying. Next attempt in 1 second.".to_string()
1882            } else {
1883                format!("Retrying. Next attempt in {next_attempt_in_secs} seconds.")
1884            }
1885        } else if next_attempt_in_secs == 1 {
1886            format!(
1887                "Retrying. Next attempt in 1 second (Attempt {} of {}).",
1888                state.attempt, state.max_attempts,
1889            )
1890        } else {
1891            format!(
1892                "Retrying. Next attempt in {next_attempt_in_secs} seconds (Attempt {} of {}).",
1893                state.attempt, state.max_attempts,
1894            )
1895        };
1896
1897        Some(
1898            Callout::new()
1899                .icon(IconName::Warning)
1900                .severity(Severity::Warning)
1901                .title(state.last_error.clone())
1902                .description(retry_message),
1903        )
1904    }
1905
1906    pub fn handle_open_rules(
1907        &mut self,
1908        _: &ClickEvent,
1909        window: &mut Window,
1910        cx: &mut Context<Self>,
1911    ) {
1912        let Some(thread) = self.as_native_thread(cx) else {
1913            return;
1914        };
1915        let project_context = thread.read(cx).project_context().read(cx);
1916
1917        let project_entry_ids = project_context
1918            .worktrees
1919            .iter()
1920            .flat_map(|worktree| worktree.rules_file.as_ref())
1921            .map(|rules_file| ProjectEntryId::from_usize(rules_file.project_entry_id))
1922            .collect::<Vec<_>>();
1923
1924        self.workspace
1925            .update(cx, move |workspace, cx| {
1926                // TODO: Open a multibuffer instead? In some cases this doesn't make the set of rules
1927                // files clear. For example, if rules file 1 is already open but rules file 2 is not,
1928                // this would open and focus rules file 2 in a tab that is not next to rules file 1.
1929                let project = workspace.project().read(cx);
1930                let project_paths = project_entry_ids
1931                    .into_iter()
1932                    .flat_map(|entry_id| project.path_for_entry(entry_id, cx))
1933                    .collect::<Vec<_>>();
1934                for project_path in project_paths {
1935                    workspace
1936                        .open_path(project_path, None, true, window, cx)
1937                        .detach_and_log_err(cx);
1938                }
1939            })
1940            .ok();
1941    }
1942
1943    fn activity_bar_bg(&self, cx: &Context<Self>) -> Hsla {
1944        let editor_bg_color = cx.theme().colors().editor_background;
1945        let active_color = cx.theme().colors().element_selected;
1946        editor_bg_color.blend(active_color.opacity(0.3))
1947    }
1948
1949    pub fn render_activity_bar(
1950        &self,
1951        window: &mut Window,
1952        cx: &Context<Self>,
1953    ) -> Option<AnyElement> {
1954        let thread = self.thread.read(cx);
1955        let action_log = thread.action_log();
1956        let telemetry = ActionLogTelemetry::from(thread);
1957        let changed_buffers = action_log.read(cx).changed_buffers(cx);
1958        let plan = thread.plan();
1959        let queue_is_empty = !self.has_queued_messages();
1960
1961        if changed_buffers.is_empty() && plan.is_empty() && queue_is_empty {
1962            return None;
1963        }
1964
1965        // Temporarily always enable ACP edit controls. This is temporary, to lessen the
1966        // impact of a nasty bug that causes them to sometimes be disabled when they shouldn't
1967        // be, which blocks you from being able to accept or reject edits. This switches the
1968        // bug to be that sometimes it's enabled when it shouldn't be, which at least doesn't
1969        // block you from using the panel.
1970        let pending_edits = false;
1971
1972        let plan_expanded = self.plan_expanded;
1973        let edits_expanded = self.edits_expanded;
1974        let queue_expanded = self.queue_expanded;
1975
1976        v_flex()
1977            .mt_1()
1978            .mx_2()
1979            .bg(self.activity_bar_bg(cx))
1980            .border_1()
1981            .border_b_0()
1982            .border_color(cx.theme().colors().border)
1983            .rounded_t_md()
1984            .shadow(vec![gpui::BoxShadow {
1985                color: gpui::black().opacity(0.15),
1986                offset: point(px(1.), px(-1.)),
1987                blur_radius: px(3.),
1988                spread_radius: px(0.),
1989            }])
1990            .when(!plan.is_empty(), |this| {
1991                this.child(self.render_plan_summary(plan, window, cx))
1992                    .when(plan_expanded, |parent| {
1993                        parent.child(self.render_plan_entries(plan, window, cx))
1994                    })
1995            })
1996            .when(!plan.is_empty() && !changed_buffers.is_empty(), |this| {
1997                this.child(Divider::horizontal().color(DividerColor::Border))
1998            })
1999            .when(
2000                !changed_buffers.is_empty() && thread.parent_session_id().is_none(),
2001                |this| {
2002                    this.child(self.render_edits_summary(
2003                        &changed_buffers,
2004                        edits_expanded,
2005                        pending_edits,
2006                        cx,
2007                    ))
2008                    .when(edits_expanded, |parent| {
2009                        parent.child(self.render_edited_files(
2010                            action_log,
2011                            telemetry.clone(),
2012                            &changed_buffers,
2013                            pending_edits,
2014                            cx,
2015                        ))
2016                    })
2017                },
2018            )
2019            .when(!queue_is_empty, |this| {
2020                this.when(!plan.is_empty() || !changed_buffers.is_empty(), |this| {
2021                    this.child(Divider::horizontal().color(DividerColor::Border))
2022                })
2023                .child(self.render_message_queue_summary(window, cx))
2024                .when(queue_expanded, |parent| {
2025                    parent.child(self.render_message_queue_entries(window, cx))
2026                })
2027            })
2028            .into_any()
2029            .into()
2030    }
2031
2032    fn render_edited_files(
2033        &self,
2034        action_log: &Entity<ActionLog>,
2035        telemetry: ActionLogTelemetry,
2036        changed_buffers: &BTreeMap<Entity<Buffer>, Entity<BufferDiff>>,
2037        pending_edits: bool,
2038        cx: &Context<Self>,
2039    ) -> impl IntoElement {
2040        let editor_bg_color = cx.theme().colors().editor_background;
2041
2042        // Sort edited files alphabetically for consistency with Git diff view
2043        let mut sorted_buffers: Vec<_> = changed_buffers.iter().collect();
2044        sorted_buffers.sort_by(|(buffer_a, _), (buffer_b, _)| {
2045            let path_a = buffer_a.read(cx).file().map(|f| f.path().clone());
2046            let path_b = buffer_b.read(cx).file().map(|f| f.path().clone());
2047            path_a.cmp(&path_b)
2048        });
2049
2050        v_flex()
2051            .id("edited_files_list")
2052            .max_h_40()
2053            .overflow_y_scroll()
2054            .children(
2055                sorted_buffers
2056                    .into_iter()
2057                    .enumerate()
2058                    .flat_map(|(index, (buffer, diff))| {
2059                        let file = buffer.read(cx).file()?;
2060                        let path = file.path();
2061                        let path_style = file.path_style(cx);
2062                        let separator = file.path_style(cx).primary_separator();
2063
2064                        let file_path = path.parent().and_then(|parent| {
2065                            if parent.is_empty() {
2066                                None
2067                            } else {
2068                                Some(
2069                                    Label::new(format!(
2070                                        "{}{separator}",
2071                                        parent.display(path_style)
2072                                    ))
2073                                    .color(Color::Muted)
2074                                    .size(LabelSize::XSmall)
2075                                    .buffer_font(cx),
2076                                )
2077                            }
2078                        });
2079
2080                        let file_name = path.file_name().map(|name| {
2081                            Label::new(name.to_string())
2082                                .size(LabelSize::XSmall)
2083                                .buffer_font(cx)
2084                                .ml_1()
2085                        });
2086
2087                        let full_path = path.display(path_style).to_string();
2088
2089                        let file_icon = FileIcons::get_icon(path.as_std_path(), cx)
2090                            .map(Icon::from_path)
2091                            .map(|icon| icon.color(Color::Muted).size(IconSize::Small))
2092                            .unwrap_or_else(|| {
2093                                Icon::new(IconName::File)
2094                                    .color(Color::Muted)
2095                                    .size(IconSize::Small)
2096                            });
2097
2098                        let file_stats = DiffStats::single_file(buffer.read(cx), diff.read(cx), cx);
2099
2100                        let buttons = self.render_edited_files_buttons(
2101                            index,
2102                            buffer,
2103                            action_log,
2104                            &telemetry,
2105                            pending_edits,
2106                            editor_bg_color,
2107                            cx,
2108                        );
2109
2110                        let element = h_flex()
2111                            .group("edited-code")
2112                            .id(("file-container", index))
2113                            .relative()
2114                            .min_w_0()
2115                            .p_1p5()
2116                            .gap_2()
2117                            .justify_between()
2118                            .bg(editor_bg_color)
2119                            .when(index < changed_buffers.len() - 1, |parent| {
2120                                parent.border_color(cx.theme().colors().border).border_b_1()
2121                            })
2122                            .child(
2123                                h_flex()
2124                                    .id(("file-name-path", index))
2125                                    .cursor_pointer()
2126                                    .pr_0p5()
2127                                    .gap_0p5()
2128                                    .rounded_xs()
2129                                    .child(file_icon)
2130                                    .children(file_name)
2131                                    .children(file_path)
2132                                    .child(
2133                                        DiffStat::new(
2134                                            "file",
2135                                            file_stats.lines_added as usize,
2136                                            file_stats.lines_removed as usize,
2137                                        )
2138                                        .label_size(LabelSize::XSmall),
2139                                    )
2140                                    .hover(|s| s.bg(cx.theme().colors().element_hover))
2141                                    .tooltip({
2142                                        move |_, cx| {
2143                                            Tooltip::with_meta(
2144                                                "Go to File",
2145                                                None,
2146                                                full_path.clone(),
2147                                                cx,
2148                                            )
2149                                        }
2150                                    })
2151                                    .on_click({
2152                                        let buffer = buffer.clone();
2153                                        cx.listener(move |this, _, window, cx| {
2154                                            this.open_edited_buffer(&buffer, window, cx);
2155                                        })
2156                                    }),
2157                            )
2158                            .child(buttons);
2159
2160                        Some(element)
2161                    }),
2162            )
2163            .into_any_element()
2164    }
2165
2166    fn render_edited_files_buttons(
2167        &self,
2168        index: usize,
2169        buffer: &Entity<Buffer>,
2170        action_log: &Entity<ActionLog>,
2171        telemetry: &ActionLogTelemetry,
2172        pending_edits: bool,
2173        editor_bg_color: Hsla,
2174        cx: &Context<Self>,
2175    ) -> impl IntoElement {
2176        h_flex()
2177            .id("edited-buttons-container")
2178            .visible_on_hover("edited-code")
2179            .absolute()
2180            .right_0()
2181            .px_1()
2182            .gap_1()
2183            .bg(editor_bg_color)
2184            .on_hover(cx.listener(move |this, is_hovered, _window, cx| {
2185                if *is_hovered {
2186                    this.hovered_edited_file_buttons = Some(index);
2187                } else if this.hovered_edited_file_buttons == Some(index) {
2188                    this.hovered_edited_file_buttons = None;
2189                }
2190                cx.notify();
2191            }))
2192            .child(
2193                Button::new("review", "Review")
2194                    .label_size(LabelSize::Small)
2195                    .on_click({
2196                        let buffer = buffer.clone();
2197                        cx.listener(move |this, _, window, cx| {
2198                            this.open_edited_buffer(&buffer, window, cx);
2199                        })
2200                    }),
2201            )
2202            .child(
2203                Button::new(("reject-file", index), "Reject")
2204                    .label_size(LabelSize::Small)
2205                    .disabled(pending_edits)
2206                    .on_click({
2207                        let buffer = buffer.clone();
2208                        let action_log = action_log.clone();
2209                        let telemetry = telemetry.clone();
2210                        move |_, _, cx| {
2211                            action_log.update(cx, |action_log, cx| {
2212                                action_log
2213                                    .reject_edits_in_ranges(
2214                                        buffer.clone(),
2215                                        vec![Anchor::min_max_range_for_buffer(
2216                                            buffer.read(cx).remote_id(),
2217                                        )],
2218                                        Some(telemetry.clone()),
2219                                        cx,
2220                                    )
2221                                    .0
2222                                    .detach_and_log_err(cx);
2223                            })
2224                        }
2225                    }),
2226            )
2227            .child(
2228                Button::new(("keep-file", index), "Keep")
2229                    .label_size(LabelSize::Small)
2230                    .disabled(pending_edits)
2231                    .on_click({
2232                        let buffer = buffer.clone();
2233                        let action_log = action_log.clone();
2234                        let telemetry = telemetry.clone();
2235                        move |_, _, cx| {
2236                            action_log.update(cx, |action_log, cx| {
2237                                action_log.keep_edits_in_range(
2238                                    buffer.clone(),
2239                                    Anchor::min_max_range_for_buffer(buffer.read(cx).remote_id()),
2240                                    Some(telemetry.clone()),
2241                                    cx,
2242                                );
2243                            })
2244                        }
2245                    }),
2246            )
2247    }
2248
2249    fn render_message_queue_summary(
2250        &self,
2251        _window: &mut Window,
2252        cx: &Context<Self>,
2253    ) -> impl IntoElement {
2254        let queue_count = self.local_queued_messages.len();
2255        let title: SharedString = if queue_count == 1 {
2256            "1 Queued Message".into()
2257        } else {
2258            format!("{} Queued Messages", queue_count).into()
2259        };
2260
2261        h_flex()
2262            .p_1()
2263            .w_full()
2264            .gap_1()
2265            .justify_between()
2266            .when(self.queue_expanded, |this| {
2267                this.border_b_1().border_color(cx.theme().colors().border)
2268            })
2269            .child(
2270                h_flex()
2271                    .id("queue_summary")
2272                    .gap_1()
2273                    .child(Disclosure::new("queue_disclosure", self.queue_expanded))
2274                    .child(Label::new(title).size(LabelSize::Small).color(Color::Muted))
2275                    .on_click(cx.listener(|this, _, _, cx| {
2276                        this.queue_expanded = !this.queue_expanded;
2277                        cx.notify();
2278                    })),
2279            )
2280            .child(
2281                Button::new("clear_queue", "Clear All")
2282                    .label_size(LabelSize::Small)
2283                    .key_binding(KeyBinding::for_action(&ClearMessageQueue, cx))
2284                    .on_click(cx.listener(|this, _, _, cx| {
2285                        this.clear_queue(cx);
2286                        this.can_fast_track_queue = false;
2287                        cx.notify();
2288                    })),
2289            )
2290            .into_any_element()
2291    }
2292
2293    fn clear_queue(&mut self, cx: &mut Context<Self>) {
2294        self.local_queued_messages.clear();
2295        self.sync_queue_flag_to_native_thread(cx);
2296    }
2297
2298    fn render_plan_summary(
2299        &self,
2300        plan: &Plan,
2301        window: &mut Window,
2302        cx: &Context<Self>,
2303    ) -> impl IntoElement {
2304        let plan_expanded = self.plan_expanded;
2305        let stats = plan.stats();
2306
2307        let title = if let Some(entry) = stats.in_progress_entry
2308            && !plan_expanded
2309        {
2310            h_flex()
2311                .cursor_default()
2312                .relative()
2313                .w_full()
2314                .gap_1()
2315                .truncate()
2316                .child(
2317                    Label::new("Current:")
2318                        .size(LabelSize::Small)
2319                        .color(Color::Muted),
2320                )
2321                .child(
2322                    div()
2323                        .text_xs()
2324                        .text_color(cx.theme().colors().text_muted)
2325                        .line_clamp(1)
2326                        .child(MarkdownElement::new(
2327                            entry.content.clone(),
2328                            plan_label_markdown_style(&entry.status, window, cx),
2329                        )),
2330                )
2331                .when(stats.pending > 0, |this| {
2332                    this.child(
2333                        h_flex()
2334                            .absolute()
2335                            .top_0()
2336                            .right_0()
2337                            .h_full()
2338                            .child(div().min_w_8().h_full().bg(linear_gradient(
2339                                90.,
2340                                linear_color_stop(self.activity_bar_bg(cx), 1.),
2341                                linear_color_stop(self.activity_bar_bg(cx).opacity(0.2), 0.),
2342                            )))
2343                            .child(
2344                                div().pr_0p5().bg(self.activity_bar_bg(cx)).child(
2345                                    Label::new(format!("{} left", stats.pending))
2346                                        .size(LabelSize::Small)
2347                                        .color(Color::Muted),
2348                                ),
2349                            ),
2350                    )
2351                })
2352        } else {
2353            let status_label = if stats.pending == 0 {
2354                "All Done".to_string()
2355            } else if stats.completed == 0 {
2356                format!("{} Tasks", plan.entries.len())
2357            } else {
2358                format!("{}/{}", stats.completed, plan.entries.len())
2359            };
2360
2361            h_flex()
2362                .w_full()
2363                .gap_1()
2364                .justify_between()
2365                .child(
2366                    Label::new("Plan")
2367                        .size(LabelSize::Small)
2368                        .color(Color::Muted),
2369                )
2370                .child(
2371                    Label::new(status_label)
2372                        .size(LabelSize::Small)
2373                        .color(Color::Muted)
2374                        .mr_1(),
2375                )
2376        };
2377
2378        h_flex()
2379            .id("plan_summary")
2380            .p_1()
2381            .w_full()
2382            .gap_1()
2383            .when(plan_expanded, |this| {
2384                this.border_b_1().border_color(cx.theme().colors().border)
2385            })
2386            .child(Disclosure::new("plan_disclosure", plan_expanded))
2387            .child(title)
2388            .on_click(cx.listener(|this, _, _, cx| {
2389                this.plan_expanded = !this.plan_expanded;
2390                cx.notify();
2391            }))
2392            .into_any_element()
2393    }
2394
2395    fn render_plan_entries(
2396        &self,
2397        plan: &Plan,
2398        window: &mut Window,
2399        cx: &Context<Self>,
2400    ) -> impl IntoElement {
2401        v_flex()
2402            .id("plan_items_list")
2403            .max_h_40()
2404            .overflow_y_scroll()
2405            .children(plan.entries.iter().enumerate().flat_map(|(index, entry)| {
2406                let element = h_flex()
2407                    .py_1()
2408                    .px_2()
2409                    .gap_2()
2410                    .justify_between()
2411                    .bg(cx.theme().colors().editor_background)
2412                    .when(index < plan.entries.len() - 1, |parent| {
2413                        parent.border_color(cx.theme().colors().border).border_b_1()
2414                    })
2415                    .child(
2416                        h_flex()
2417                            .id(("plan_entry", index))
2418                            .gap_1p5()
2419                            .max_w_full()
2420                            .overflow_x_scroll()
2421                            .text_xs()
2422                            .text_color(cx.theme().colors().text_muted)
2423                            .child(match entry.status {
2424                                acp::PlanEntryStatus::InProgress => {
2425                                    Icon::new(IconName::TodoProgress)
2426                                        .size(IconSize::Small)
2427                                        .color(Color::Accent)
2428                                        .with_rotate_animation(2)
2429                                        .into_any_element()
2430                                }
2431                                acp::PlanEntryStatus::Completed => {
2432                                    Icon::new(IconName::TodoComplete)
2433                                        .size(IconSize::Small)
2434                                        .color(Color::Success)
2435                                        .into_any_element()
2436                                }
2437                                acp::PlanEntryStatus::Pending | _ => {
2438                                    Icon::new(IconName::TodoPending)
2439                                        .size(IconSize::Small)
2440                                        .color(Color::Muted)
2441                                        .into_any_element()
2442                                }
2443                            })
2444                            .child(MarkdownElement::new(
2445                                entry.content.clone(),
2446                                plan_label_markdown_style(&entry.status, window, cx),
2447                            )),
2448                    );
2449
2450                Some(element)
2451            }))
2452            .into_any_element()
2453    }
2454
2455    fn render_edits_summary(
2456        &self,
2457        changed_buffers: &BTreeMap<Entity<Buffer>, Entity<BufferDiff>>,
2458        expanded: bool,
2459        pending_edits: bool,
2460        cx: &Context<Self>,
2461    ) -> Div {
2462        const EDIT_NOT_READY_TOOLTIP_LABEL: &str = "Wait until file edits are complete.";
2463
2464        let focus_handle = self.focus_handle(cx);
2465
2466        h_flex()
2467            .p_1()
2468            .justify_between()
2469            .flex_wrap()
2470            .when(expanded, |this| {
2471                this.border_b_1().border_color(cx.theme().colors().border)
2472            })
2473            .child(
2474                h_flex()
2475                    .id("edits-container")
2476                    .cursor_pointer()
2477                    .gap_1()
2478                    .child(Disclosure::new("edits-disclosure", expanded))
2479                    .map(|this| {
2480                        if pending_edits {
2481                            this.child(
2482                                Label::new(format!(
2483                                    "Editing {} {}…",
2484                                    changed_buffers.len(),
2485                                    if changed_buffers.len() == 1 {
2486                                        "file"
2487                                    } else {
2488                                        "files"
2489                                    }
2490                                ))
2491                                .color(Color::Muted)
2492                                .size(LabelSize::Small)
2493                                .with_animation(
2494                                    "edit-label",
2495                                    Animation::new(Duration::from_secs(2))
2496                                        .repeat()
2497                                        .with_easing(pulsating_between(0.3, 0.7)),
2498                                    |label, delta| label.alpha(delta),
2499                                ),
2500                            )
2501                        } else {
2502                            let stats = DiffStats::all_files(changed_buffers, cx);
2503                            let dot_divider = || {
2504                                Label::new("•")
2505                                    .size(LabelSize::XSmall)
2506                                    .color(Color::Disabled)
2507                            };
2508
2509                            this.child(
2510                                Label::new("Edits")
2511                                    .size(LabelSize::Small)
2512                                    .color(Color::Muted),
2513                            )
2514                            .child(dot_divider())
2515                            .child(
2516                                Label::new(format!(
2517                                    "{} {}",
2518                                    changed_buffers.len(),
2519                                    if changed_buffers.len() == 1 {
2520                                        "file"
2521                                    } else {
2522                                        "files"
2523                                    }
2524                                ))
2525                                .size(LabelSize::Small)
2526                                .color(Color::Muted),
2527                            )
2528                            .child(dot_divider())
2529                            .child(DiffStat::new(
2530                                "total",
2531                                stats.lines_added as usize,
2532                                stats.lines_removed as usize,
2533                            ))
2534                        }
2535                    })
2536                    .on_click(cx.listener(|this, _, _, cx| {
2537                        this.edits_expanded = !this.edits_expanded;
2538                        cx.notify();
2539                    })),
2540            )
2541            .child(
2542                h_flex()
2543                    .gap_1()
2544                    .child(
2545                        IconButton::new("review-changes", IconName::ListTodo)
2546                            .icon_size(IconSize::Small)
2547                            .tooltip({
2548                                let focus_handle = focus_handle.clone();
2549                                move |_window, cx| {
2550                                    Tooltip::for_action_in(
2551                                        "Review Changes",
2552                                        &OpenAgentDiff,
2553                                        &focus_handle,
2554                                        cx,
2555                                    )
2556                                }
2557                            })
2558                            .on_click(cx.listener(|_, _, window, cx| {
2559                                window.dispatch_action(OpenAgentDiff.boxed_clone(), cx);
2560                            })),
2561                    )
2562                    .child(Divider::vertical().color(DividerColor::Border))
2563                    .child(
2564                        Button::new("reject-all-changes", "Reject All")
2565                            .label_size(LabelSize::Small)
2566                            .disabled(pending_edits)
2567                            .when(pending_edits, |this| {
2568                                this.tooltip(Tooltip::text(EDIT_NOT_READY_TOOLTIP_LABEL))
2569                            })
2570                            .key_binding(
2571                                KeyBinding::for_action_in(&RejectAll, &focus_handle.clone(), cx)
2572                                    .map(|kb| kb.size(rems_from_px(10.))),
2573                            )
2574                            .on_click(cx.listener(move |this, _, window, cx| {
2575                                this.reject_all(&RejectAll, window, cx);
2576                            })),
2577                    )
2578                    .child(
2579                        Button::new("keep-all-changes", "Keep All")
2580                            .label_size(LabelSize::Small)
2581                            .disabled(pending_edits)
2582                            .when(pending_edits, |this| {
2583                                this.tooltip(Tooltip::text(EDIT_NOT_READY_TOOLTIP_LABEL))
2584                            })
2585                            .key_binding(
2586                                KeyBinding::for_action_in(&KeepAll, &focus_handle, cx)
2587                                    .map(|kb| kb.size(rems_from_px(10.))),
2588                            )
2589                            .on_click(cx.listener(move |this, _, window, cx| {
2590                                this.keep_all(&KeepAll, window, cx);
2591                            })),
2592                    ),
2593            )
2594    }
2595
2596    fn is_subagent_canceled_or_failed(&self, cx: &App) -> bool {
2597        let Some(parent_session_id) = self.parent_id.as_ref() else {
2598            return false;
2599        };
2600
2601        let my_session_id = self.thread.read(cx).session_id().clone();
2602
2603        self.server_view
2604            .upgrade()
2605            .and_then(|sv| sv.read(cx).thread_view(parent_session_id))
2606            .is_some_and(|parent_view| {
2607                parent_view
2608                    .read(cx)
2609                    .thread
2610                    .read(cx)
2611                    .tool_call_for_subagent(&my_session_id)
2612                    .is_some_and(|tc| {
2613                        matches!(
2614                            tc.status,
2615                            ToolCallStatus::Canceled
2616                                | ToolCallStatus::Failed
2617                                | ToolCallStatus::Rejected
2618                        )
2619                    })
2620            })
2621    }
2622
2623    pub(crate) fn render_subagent_titlebar(&mut self, cx: &mut Context<Self>) -> Option<Div> {
2624        let Some(parent_session_id) = self.parent_id.clone() else {
2625            return None;
2626        };
2627
2628        let server_view = self.server_view.clone();
2629        let thread = self.thread.clone();
2630        let is_done = thread.read(cx).status() == ThreadStatus::Idle;
2631        let is_canceled_or_failed = self.is_subagent_canceled_or_failed(cx);
2632
2633        Some(
2634            h_flex()
2635                .h(Tab::container_height(cx))
2636                .pl_2()
2637                .pr_1p5()
2638                .w_full()
2639                .justify_between()
2640                .gap_1()
2641                .border_b_1()
2642                .when(is_done && is_canceled_or_failed, |this| {
2643                    this.border_dashed()
2644                })
2645                .border_color(cx.theme().colors().border)
2646                .bg(cx.theme().colors().editor_background.opacity(0.2))
2647                .child(
2648                    h_flex()
2649                        .flex_1()
2650                        .gap_2()
2651                        .child(
2652                            Icon::new(IconName::ForwardArrowUp)
2653                                .size(IconSize::Small)
2654                                .color(Color::Muted),
2655                        )
2656                        .child(self.title_editor.clone())
2657                        .when(is_done && is_canceled_or_failed, |this| {
2658                            this.child(Icon::new(IconName::Close).color(Color::Error))
2659                        })
2660                        .when(is_done && !is_canceled_or_failed, |this| {
2661                            this.child(Icon::new(IconName::Check).color(Color::Success))
2662                        }),
2663                )
2664                .child(
2665                    h_flex()
2666                        .gap_0p5()
2667                        .when(!is_done, |this| {
2668                            this.child(
2669                                IconButton::new("stop_subagent", IconName::Stop)
2670                                    .icon_size(IconSize::Small)
2671                                    .icon_color(Color::Error)
2672                                    .tooltip(Tooltip::text("Stop Subagent"))
2673                                    .on_click(move |_, _, cx| {
2674                                        thread.update(cx, |thread, cx| {
2675                                            thread.cancel(cx).detach();
2676                                        });
2677                                    }),
2678                            )
2679                        })
2680                        .child(
2681                            IconButton::new("minimize_subagent", IconName::Minimize)
2682                                .icon_size(IconSize::Small)
2683                                .tooltip(Tooltip::text("Minimize Subagent"))
2684                                .on_click(move |_, window, cx| {
2685                                    let _ = server_view.update(cx, |server_view, cx| {
2686                                        server_view.navigate_to_session(
2687                                            parent_session_id.clone(),
2688                                            window,
2689                                            cx,
2690                                        );
2691                                    });
2692                                }),
2693                        ),
2694                ),
2695        )
2696    }
2697
2698    pub(crate) fn render_message_editor(
2699        &mut self,
2700        window: &mut Window,
2701        cx: &mut Context<Self>,
2702    ) -> AnyElement {
2703        if self.is_subagent() {
2704            return div().into_any_element();
2705        }
2706
2707        let focus_handle = self.message_editor.focus_handle(cx);
2708        let editor_bg_color = cx.theme().colors().editor_background;
2709        let editor_expanded = self.editor_expanded;
2710        let has_messages = self.list_state.item_count() > 0;
2711        let v2_empty_state = cx.has_flag::<AgentV2FeatureFlag>() && !has_messages;
2712        let (expand_icon, expand_tooltip) = if editor_expanded {
2713            (IconName::Minimize, "Minimize Message Editor")
2714        } else {
2715            (IconName::Maximize, "Expand Message Editor")
2716        };
2717
2718        if v2_empty_state {
2719            self.message_editor.update(cx, |editor, cx| {
2720                editor.set_mode(
2721                    EditorMode::Full {
2722                        scale_ui_elements_with_buffer_font_size: false,
2723                        show_active_line_background: false,
2724                        sizing_behavior: SizingBehavior::Default,
2725                    },
2726                    cx,
2727                );
2728            });
2729        } else {
2730            self.message_editor.update(cx, |editor, cx| {
2731                editor.set_mode(
2732                    EditorMode::AutoHeight {
2733                        min_lines: AgentSettings::get_global(cx).message_editor_min_lines,
2734                        max_lines: Some(
2735                            AgentSettings::get_global(cx).set_message_editor_max_lines(),
2736                        ),
2737                    },
2738                    cx,
2739                );
2740            });
2741        }
2742
2743        v_flex()
2744            .on_action(cx.listener(Self::expand_message_editor))
2745            .p_2()
2746            .gap_2()
2747            .when(!v2_empty_state, |this| {
2748                this.border_t_1().border_color(cx.theme().colors().border)
2749            })
2750            .bg(editor_bg_color)
2751            .when(v2_empty_state, |this| this.flex_1().size_full())
2752            .when(editor_expanded && !v2_empty_state, |this| {
2753                this.h(vh(0.8, window)).size_full().justify_between()
2754            })
2755            .child(
2756                v_flex()
2757                    .relative()
2758                    .size_full()
2759                    .when(v2_empty_state, |this| this.flex_1())
2760                    .pt_1()
2761                    .pr_2p5()
2762                    .child(self.message_editor.clone())
2763                    .when(!v2_empty_state, |this| {
2764                        this.child(
2765                            h_flex()
2766                                .absolute()
2767                                .top_0()
2768                                .right_0()
2769                                .opacity(0.5)
2770                                .hover(|this| this.opacity(1.0))
2771                                .child(
2772                                    IconButton::new("toggle-height", expand_icon)
2773                                        .icon_size(IconSize::Small)
2774                                        .icon_color(Color::Muted)
2775                                        .tooltip({
2776                                            move |_window, cx| {
2777                                                Tooltip::for_action_in(
2778                                                    expand_tooltip,
2779                                                    &ExpandMessageEditor,
2780                                                    &focus_handle,
2781                                                    cx,
2782                                                )
2783                                            }
2784                                        })
2785                                        .on_click(cx.listener(|this, _, window, cx| {
2786                                            this.expand_message_editor(
2787                                                &ExpandMessageEditor,
2788                                                window,
2789                                                cx,
2790                                            );
2791                                        })),
2792                                ),
2793                        )
2794                    }),
2795            )
2796            .child(
2797                h_flex()
2798                    .flex_none()
2799                    .flex_wrap()
2800                    .justify_between()
2801                    .child(
2802                        h_flex()
2803                            .gap_0p5()
2804                            .child(self.render_add_context_button(cx))
2805                            .child(self.render_follow_toggle(cx))
2806                            .children(self.render_fast_mode_control(cx))
2807                            .children(self.render_thinking_control(cx)),
2808                    )
2809                    .child(
2810                        h_flex()
2811                            .gap_1()
2812                            .children(self.render_token_usage(cx))
2813                            .children(self.profile_selector.clone())
2814                            .map(|this| {
2815                                // Either config_options_view OR (mode_selector + model_selector)
2816                                match self.config_options_view.clone() {
2817                                    Some(config_view) => this.child(config_view),
2818                                    None => this
2819                                        .children(self.mode_selector.clone())
2820                                        .children(self.model_selector.clone()),
2821                                }
2822                            })
2823                            .child(self.render_send_button(cx)),
2824                    ),
2825            )
2826            .into_any()
2827    }
2828
2829    fn render_message_queue_entries(
2830        &self,
2831        _window: &mut Window,
2832        cx: &Context<Self>,
2833    ) -> impl IntoElement {
2834        let message_editor = self.message_editor.read(cx);
2835        let focus_handle = message_editor.focus_handle(cx);
2836
2837        let queued_message_editors = &self.queued_message_editors;
2838        let queue_len = queued_message_editors.len();
2839        let can_fast_track = self.can_fast_track_queue && queue_len > 0;
2840
2841        v_flex()
2842            .id("message_queue_list")
2843            .max_h_40()
2844            .overflow_y_scroll()
2845            .children(
2846                queued_message_editors
2847                    .iter()
2848                    .enumerate()
2849                    .map(|(index, editor)| {
2850                        let is_next = index == 0;
2851                        let (icon_color, tooltip_text) = if is_next {
2852                            (Color::Accent, "Next in Queue")
2853                        } else {
2854                            (Color::Muted, "In Queue")
2855                        };
2856
2857                        let editor_focused = editor.focus_handle(cx).is_focused(_window);
2858                        let keybinding_size = rems_from_px(12.);
2859
2860                        h_flex()
2861                            .group("queue_entry")
2862                            .w_full()
2863                            .p_1p5()
2864                            .gap_1()
2865                            .bg(cx.theme().colors().editor_background)
2866                            .when(index < queue_len - 1, |this| {
2867                                this.border_b_1()
2868                                    .border_color(cx.theme().colors().border_variant)
2869                            })
2870                            .child(
2871                                div()
2872                                    .id("next_in_queue")
2873                                    .child(
2874                                        Icon::new(IconName::Circle)
2875                                            .size(IconSize::Small)
2876                                            .color(icon_color),
2877                                    )
2878                                    .tooltip(Tooltip::text(tooltip_text)),
2879                            )
2880                            .child(editor.clone())
2881                            .child(if editor_focused {
2882                                h_flex()
2883                                    .gap_1()
2884                                    .min_w(rems_from_px(150.))
2885                                    .justify_end()
2886                                    .child(
2887                                        IconButton::new(("edit", index), IconName::Pencil)
2888                                            .icon_size(IconSize::Small)
2889                                            .tooltip(|_window, cx| {
2890                                                Tooltip::with_meta(
2891                                                    "Edit Queued Message",
2892                                                    None,
2893                                                    "Type anything to edit",
2894                                                    cx,
2895                                                )
2896                                            })
2897                                            .on_click(cx.listener(move |this, _, window, cx| {
2898                                                this.move_queued_message_to_main_editor(
2899                                                    index, None, window, cx,
2900                                                );
2901                                            })),
2902                                    )
2903                                    .child(
2904                                        Button::new(("send_now_focused", index), "Send Now")
2905                                            .label_size(LabelSize::Small)
2906                                            .style(ButtonStyle::Outlined)
2907                                            .key_binding(
2908                                                KeyBinding::for_action_in(
2909                                                    &SendImmediately,
2910                                                    &editor.focus_handle(cx),
2911                                                    cx,
2912                                                )
2913                                                .map(|kb| kb.size(keybinding_size)),
2914                                            )
2915                                            .on_click(cx.listener(move |this, _, window, cx| {
2916                                                this.send_queued_message_at_index(
2917                                                    index, true, window, cx,
2918                                                );
2919                                            })),
2920                                    )
2921                            } else {
2922                                h_flex()
2923                                    .when(!is_next, |this| this.visible_on_hover("queue_entry"))
2924                                    .gap_1()
2925                                    .min_w(rems_from_px(150.))
2926                                    .justify_end()
2927                                    .child(
2928                                        IconButton::new(("delete", index), IconName::Trash)
2929                                            .icon_size(IconSize::Small)
2930                                            .tooltip({
2931                                                let focus_handle = focus_handle.clone();
2932                                                move |_window, cx| {
2933                                                    if is_next {
2934                                                        Tooltip::for_action_in(
2935                                                            "Remove Message from Queue",
2936                                                            &RemoveFirstQueuedMessage,
2937                                                            &focus_handle,
2938                                                            cx,
2939                                                        )
2940                                                    } else {
2941                                                        Tooltip::simple(
2942                                                            "Remove Message from Queue",
2943                                                            cx,
2944                                                        )
2945                                                    }
2946                                                }
2947                                            })
2948                                            .on_click(cx.listener(move |this, _, _, cx| {
2949                                                this.remove_from_queue(index, cx);
2950                                                cx.notify();
2951                                            })),
2952                                    )
2953                                    .child(
2954                                        IconButton::new(("edit", index), IconName::Pencil)
2955                                            .icon_size(IconSize::Small)
2956                                            .tooltip({
2957                                                let focus_handle = focus_handle.clone();
2958                                                move |_window, cx| {
2959                                                    if is_next {
2960                                                        Tooltip::for_action_in(
2961                                                            "Edit",
2962                                                            &EditFirstQueuedMessage,
2963                                                            &focus_handle,
2964                                                            cx,
2965                                                        )
2966                                                    } else {
2967                                                        Tooltip::simple("Edit", cx)
2968                                                    }
2969                                                }
2970                                            })
2971                                            .on_click(cx.listener(move |this, _, window, cx| {
2972                                                this.move_queued_message_to_main_editor(
2973                                                    index, None, window, cx,
2974                                                );
2975                                            })),
2976                                    )
2977                                    .child(
2978                                        Button::new(("send_now", index), "Send Now")
2979                                            .label_size(LabelSize::Small)
2980                                            .when(is_next, |this| this.style(ButtonStyle::Outlined))
2981                                            .when(is_next && message_editor.is_empty(cx), |this| {
2982                                                let action: Box<dyn gpui::Action> =
2983                                                    if can_fast_track {
2984                                                        Box::new(Chat)
2985                                                    } else {
2986                                                        Box::new(SendNextQueuedMessage)
2987                                                    };
2988
2989                                                this.key_binding(
2990                                                    KeyBinding::for_action_in(
2991                                                        action.as_ref(),
2992                                                        &focus_handle.clone(),
2993                                                        cx,
2994                                                    )
2995                                                    .map(|kb| kb.size(keybinding_size)),
2996                                                )
2997                                            })
2998                                            .on_click(cx.listener(move |this, _, window, cx| {
2999                                                this.send_queued_message_at_index(
3000                                                    index, true, window, cx,
3001                                                );
3002                                            })),
3003                                    )
3004                            })
3005                    }),
3006            )
3007            .into_any_element()
3008    }
3009
3010    fn supports_split_token_display(&self, cx: &App) -> bool {
3011        self.as_native_thread(cx)
3012            .and_then(|thread| thread.read(cx).model())
3013            .is_some_and(|model| model.supports_split_token_display())
3014    }
3015
3016    fn render_token_usage(&self, cx: &mut Context<Self>) -> Option<impl IntoElement> {
3017        let thread = self.thread.read(cx);
3018        let usage = thread.token_usage()?;
3019        let is_generating = thread.status() != ThreadStatus::Idle;
3020        let show_split = self.supports_split_token_display(cx);
3021
3022        let separator_color = Color::Custom(cx.theme().colors().text_muted.opacity(0.5));
3023        let token_label = |text: String, animation_id: &'static str| {
3024            Label::new(text)
3025                .size(LabelSize::Small)
3026                .color(Color::Muted)
3027                .map(|label| {
3028                    if is_generating {
3029                        label
3030                            .with_animation(
3031                                animation_id,
3032                                Animation::new(Duration::from_secs(2))
3033                                    .repeat()
3034                                    .with_easing(pulsating_between(0.3, 0.8)),
3035                                |label, delta| label.alpha(delta),
3036                            )
3037                            .into_any()
3038                    } else {
3039                        label.into_any_element()
3040                    }
3041                })
3042        };
3043
3044        if show_split {
3045            let max_output_tokens = self
3046                .as_native_thread(cx)
3047                .and_then(|thread| thread.read(cx).model())
3048                .and_then(|model| model.max_output_tokens())
3049                .unwrap_or(0);
3050
3051            let input = crate::text_thread_editor::humanize_token_count(usage.input_tokens);
3052            let input_max = crate::text_thread_editor::humanize_token_count(
3053                usage.max_tokens.saturating_sub(max_output_tokens),
3054            );
3055            let output = crate::text_thread_editor::humanize_token_count(usage.output_tokens);
3056            let output_max = crate::text_thread_editor::humanize_token_count(max_output_tokens);
3057
3058            Some(
3059                h_flex()
3060                    .flex_shrink_0()
3061                    .gap_1()
3062                    .mr_1p5()
3063                    .child(
3064                        h_flex()
3065                            .gap_0p5()
3066                            .child(
3067                                Icon::new(IconName::ArrowUp)
3068                                    .size(IconSize::XSmall)
3069                                    .color(Color::Muted),
3070                            )
3071                            .child(token_label(input, "input-tokens-label"))
3072                            .child(
3073                                Label::new("/")
3074                                    .size(LabelSize::Small)
3075                                    .color(separator_color),
3076                            )
3077                            .child(
3078                                Label::new(input_max)
3079                                    .size(LabelSize::Small)
3080                                    .color(Color::Muted),
3081                            ),
3082                    )
3083                    .child(
3084                        h_flex()
3085                            .gap_0p5()
3086                            .child(
3087                                Icon::new(IconName::ArrowDown)
3088                                    .size(IconSize::XSmall)
3089                                    .color(Color::Muted),
3090                            )
3091                            .child(token_label(output, "output-tokens-label"))
3092                            .child(
3093                                Label::new("/")
3094                                    .size(LabelSize::Small)
3095                                    .color(separator_color),
3096                            )
3097                            .child(
3098                                Label::new(output_max)
3099                                    .size(LabelSize::Small)
3100                                    .color(Color::Muted),
3101                            ),
3102                    )
3103                    .into_any_element(),
3104            )
3105        } else {
3106            let used = crate::text_thread_editor::humanize_token_count(usage.used_tokens);
3107            let max = crate::text_thread_editor::humanize_token_count(usage.max_tokens);
3108            let progress_ratio = if usage.max_tokens > 0 {
3109                usage.used_tokens as f32 / usage.max_tokens as f32
3110            } else {
3111                0.0
3112            };
3113
3114            let progress_color = if progress_ratio >= 0.85 {
3115                cx.theme().status().warning
3116            } else {
3117                cx.theme().colors().text_muted
3118            };
3119            let separator_color = Color::Custom(cx.theme().colors().text_disabled.opacity(0.6));
3120
3121            let percentage = format!("{}%", (progress_ratio * 100.0).round() as u32);
3122
3123            let (user_rules_count, project_rules_count) = self
3124                .as_native_thread(cx)
3125                .map(|thread| {
3126                    let project_context = thread.read(cx).project_context().read(cx);
3127                    let user_rules = project_context.user_rules.len();
3128                    let project_rules = project_context
3129                        .worktrees
3130                        .iter()
3131                        .filter(|wt| wt.rules_file.is_some())
3132                        .count();
3133                    (user_rules, project_rules)
3134                })
3135                .unwrap_or((0, 0));
3136
3137            Some(
3138                h_flex()
3139                    .id("circular_progress_tokens")
3140                    .mt_px()
3141                    .mr_1()
3142                    .child(
3143                        CircularProgress::new(
3144                            usage.used_tokens as f32,
3145                            usage.max_tokens as f32,
3146                            px(16.0),
3147                            cx,
3148                        )
3149                        .stroke_width(px(2.))
3150                        .progress_color(progress_color),
3151                    )
3152                    .tooltip(Tooltip::element({
3153                        move |_, cx| {
3154                            v_flex()
3155                                .min_w_40()
3156                                .child(
3157                                    Label::new("Context")
3158                                        .color(Color::Muted)
3159                                        .size(LabelSize::Small),
3160                                )
3161                                .child(
3162                                    h_flex()
3163                                        .gap_0p5()
3164                                        .child(Label::new(percentage.clone()))
3165                                        .child(Label::new("•").color(separator_color).mx_1())
3166                                        .child(Label::new(used.clone()))
3167                                        .child(Label::new("/").color(separator_color))
3168                                        .child(Label::new(max.clone()).color(Color::Muted)),
3169                                )
3170                                .when(user_rules_count > 0 || project_rules_count > 0, |this| {
3171                                    this.child(
3172                                        v_flex()
3173                                            .mt_1p5()
3174                                            .pt_1p5()
3175                                            .border_t_1()
3176                                            .border_color(cx.theme().colors().border_variant)
3177                                            .child(
3178                                                Label::new("Rules")
3179                                                    .color(Color::Muted)
3180                                                    .size(LabelSize::Small),
3181                                            )
3182                                            .when(user_rules_count > 0, |this| {
3183                                                this.child(Label::new(format!(
3184                                                    "{} user rules",
3185                                                    user_rules_count
3186                                                )))
3187                                            })
3188                                            .when(project_rules_count > 0, |this| {
3189                                                this.child(Label::new(format!(
3190                                                    "{} project rules",
3191                                                    project_rules_count
3192                                                )))
3193                                            }),
3194                                    )
3195                                })
3196                                .into_any_element()
3197                        }
3198                    }))
3199                    .into_any_element(),
3200            )
3201        }
3202    }
3203
3204    fn fast_mode_available(&self, cx: &Context<Self>) -> bool {
3205        if !cx.is_staff() {
3206            return false;
3207        }
3208        self.as_native_thread(cx)
3209            .and_then(|thread| thread.read(cx).model())
3210            .map(|model| model.supports_fast_mode())
3211            .unwrap_or(false)
3212    }
3213
3214    fn render_fast_mode_control(&self, cx: &mut Context<Self>) -> Option<AnyElement> {
3215        if !self.fast_mode_available(cx) {
3216            return None;
3217        }
3218
3219        let thread = self.as_native_thread(cx)?.read(cx);
3220
3221        let (tooltip_label, color, icon) = if matches!(thread.speed(), Some(Speed::Fast)) {
3222            ("Disable Fast Mode", Color::Muted, IconName::FastForward)
3223        } else {
3224            (
3225                "Enable Fast Mode",
3226                Color::Custom(cx.theme().colors().icon_disabled.opacity(0.8)),
3227                IconName::FastForwardOff,
3228            )
3229        };
3230
3231        let focus_handle = self.message_editor.focus_handle(cx);
3232
3233        Some(
3234            IconButton::new("fast-mode", icon)
3235                .icon_size(IconSize::Small)
3236                .icon_color(color)
3237                .tooltip(move |_, cx| {
3238                    Tooltip::for_action_in(tooltip_label, &ToggleFastMode, &focus_handle, cx)
3239                })
3240                .on_click(cx.listener(move |this, _, _window, cx| {
3241                    this.toggle_fast_mode(cx);
3242                }))
3243                .into_any_element(),
3244        )
3245    }
3246
3247    fn render_thinking_control(&self, cx: &mut Context<Self>) -> Option<AnyElement> {
3248        let thread = self.as_native_thread(cx)?.read(cx);
3249        let model = thread.model()?;
3250
3251        let supports_thinking = model.supports_thinking();
3252        if !supports_thinking {
3253            return None;
3254        }
3255
3256        let thinking = thread.thinking_enabled();
3257
3258        let (tooltip_label, icon, color) = if thinking {
3259            (
3260                "Disable Thinking Mode",
3261                IconName::ThinkingMode,
3262                Color::Muted,
3263            )
3264        } else {
3265            (
3266                "Enable Thinking Mode",
3267                IconName::ThinkingModeOff,
3268                Color::Custom(cx.theme().colors().icon_disabled.opacity(0.8)),
3269            )
3270        };
3271
3272        let focus_handle = self.message_editor.focus_handle(cx);
3273
3274        let thinking_toggle = IconButton::new("thinking-mode", icon)
3275            .icon_size(IconSize::Small)
3276            .icon_color(color)
3277            .tooltip(move |_, cx| {
3278                Tooltip::for_action_in(tooltip_label, &ToggleThinkingMode, &focus_handle, cx)
3279            })
3280            .on_click(cx.listener(move |this, _, _window, cx| {
3281                if let Some(thread) = this.as_native_thread(cx) {
3282                    thread.update(cx, |thread, cx| {
3283                        let enable_thinking = !thread.thinking_enabled();
3284                        thread.set_thinking_enabled(enable_thinking, cx);
3285
3286                        let fs = thread.project().read(cx).fs().clone();
3287                        update_settings_file(fs, cx, move |settings, _| {
3288                            if let Some(agent) = settings.agent.as_mut()
3289                                && let Some(default_model) = agent.default_model.as_mut()
3290                            {
3291                                default_model.enable_thinking = enable_thinking;
3292                            }
3293                        });
3294                    });
3295                }
3296            }));
3297
3298        if model.supported_effort_levels().is_empty() {
3299            return Some(thinking_toggle.into_any_element());
3300        }
3301
3302        if !model.supported_effort_levels().is_empty() && !thinking {
3303            return Some(thinking_toggle.into_any_element());
3304        }
3305
3306        let left_btn = thinking_toggle;
3307        let right_btn = self.render_effort_selector(
3308            model.supported_effort_levels(),
3309            thread.thinking_effort().cloned(),
3310            cx,
3311        );
3312
3313        Some(
3314            SplitButton::new(left_btn, right_btn.into_any_element())
3315                .style(SplitButtonStyle::Transparent)
3316                .into_any_element(),
3317        )
3318    }
3319
3320    fn render_effort_selector(
3321        &self,
3322        supported_effort_levels: Vec<LanguageModelEffortLevel>,
3323        selected_effort: Option<String>,
3324        cx: &Context<Self>,
3325    ) -> impl IntoElement {
3326        let weak_self = cx.weak_entity();
3327
3328        let default_effort_level = supported_effort_levels
3329            .iter()
3330            .find(|effort_level| effort_level.is_default)
3331            .cloned();
3332
3333        let selected = selected_effort.and_then(|effort| {
3334            supported_effort_levels
3335                .iter()
3336                .find(|level| level.value == effort)
3337                .cloned()
3338        });
3339
3340        let label = selected
3341            .clone()
3342            .or(default_effort_level)
3343            .map_or("Select Effort".into(), |effort| effort.name);
3344
3345        let (label_color, icon) = if self.thinking_effort_menu_handle.is_deployed() {
3346            (Color::Accent, IconName::ChevronUp)
3347        } else {
3348            (Color::Muted, IconName::ChevronDown)
3349        };
3350
3351        let focus_handle = self.message_editor.focus_handle(cx);
3352        let show_cycle_row = supported_effort_levels.len() > 1;
3353
3354        let tooltip = Tooltip::element({
3355            move |_, cx| {
3356                let mut content = v_flex().gap_1().child(
3357                    h_flex()
3358                        .gap_2()
3359                        .justify_between()
3360                        .child(Label::new("Change Thinking Effort"))
3361                        .child(KeyBinding::for_action_in(
3362                            &ToggleThinkingEffortMenu,
3363                            &focus_handle,
3364                            cx,
3365                        )),
3366                );
3367
3368                if show_cycle_row {
3369                    content = content.child(
3370                        h_flex()
3371                            .pt_1()
3372                            .gap_2()
3373                            .justify_between()
3374                            .border_t_1()
3375                            .border_color(cx.theme().colors().border_variant)
3376                            .child(Label::new("Cycle Thinking Effort"))
3377                            .child(KeyBinding::for_action_in(
3378                                &CycleThinkingEffort,
3379                                &focus_handle,
3380                                cx,
3381                            )),
3382                    );
3383                }
3384
3385                content.into_any_element()
3386            }
3387        });
3388
3389        PopoverMenu::new("effort-selector")
3390            .trigger_with_tooltip(
3391                ButtonLike::new_rounded_right("effort-selector-trigger")
3392                    .selected_style(ButtonStyle::Tinted(TintColor::Accent))
3393                    .child(Label::new(label).size(LabelSize::Small).color(label_color))
3394                    .child(Icon::new(icon).size(IconSize::XSmall).color(Color::Muted)),
3395                tooltip,
3396            )
3397            .menu(move |window, cx| {
3398                Some(ContextMenu::build(window, cx, |mut menu, _window, _cx| {
3399                    menu = menu.header("Change Thinking Effort");
3400
3401                    for effort_level in supported_effort_levels.clone() {
3402                        let is_selected = selected
3403                            .as_ref()
3404                            .is_some_and(|selected| selected.value == effort_level.value);
3405                        let entry = ContextMenuEntry::new(effort_level.name)
3406                            .toggleable(IconPosition::End, is_selected);
3407
3408                        menu.push_item(entry.handler({
3409                            let effort = effort_level.value.clone();
3410                            let weak_self = weak_self.clone();
3411                            move |_window, cx| {
3412                                let effort = effort.clone();
3413                                weak_self
3414                                    .update(cx, |this, cx| {
3415                                        if let Some(thread) = this.as_native_thread(cx) {
3416                                            thread.update(cx, |thread, cx| {
3417                                                thread.set_thinking_effort(
3418                                                    Some(effort.to_string()),
3419                                                    cx,
3420                                                );
3421
3422                                                let fs = thread.project().read(cx).fs().clone();
3423                                                update_settings_file(fs, cx, move |settings, _| {
3424                                                    if let Some(agent) = settings.agent.as_mut()
3425                                                        && let Some(default_model) =
3426                                                            agent.default_model.as_mut()
3427                                                    {
3428                                                        default_model.effort =
3429                                                            Some(effort.to_string());
3430                                                    }
3431                                                });
3432                                            });
3433                                        }
3434                                    })
3435                                    .ok();
3436                            }
3437                        }));
3438                    }
3439
3440                    menu
3441                }))
3442            })
3443            .with_handle(self.thinking_effort_menu_handle.clone())
3444            .offset(gpui::Point {
3445                x: px(0.0),
3446                y: px(-2.0),
3447            })
3448            .anchor(Corner::BottomLeft)
3449    }
3450
3451    fn render_send_button(&self, cx: &mut Context<Self>) -> AnyElement {
3452        let message_editor = self.message_editor.read(cx);
3453        let is_editor_empty = message_editor.is_empty(cx);
3454        let focus_handle = message_editor.focus_handle(cx);
3455
3456        let is_generating = self.thread.read(cx).status() != ThreadStatus::Idle;
3457
3458        if self.is_loading_contents {
3459            div()
3460                .id("loading-message-content")
3461                .px_1()
3462                .tooltip(Tooltip::text("Loading Added Context…"))
3463                .child(loading_contents_spinner(IconSize::default()))
3464                .into_any_element()
3465        } else if is_generating && is_editor_empty {
3466            IconButton::new("stop-generation", IconName::Stop)
3467                .icon_color(Color::Error)
3468                .style(ButtonStyle::Tinted(TintColor::Error))
3469                .tooltip(move |_window, cx| {
3470                    Tooltip::for_action("Stop Generation", &editor::actions::Cancel, cx)
3471                })
3472                .on_click(cx.listener(|this, _event, _, cx| this.cancel_generation(cx)))
3473                .into_any_element()
3474        } else {
3475            let send_icon = if is_generating {
3476                IconName::QueueMessage
3477            } else {
3478                IconName::Send
3479            };
3480            IconButton::new("send-message", send_icon)
3481                .style(ButtonStyle::Filled)
3482                .map(|this| {
3483                    if is_editor_empty && !is_generating {
3484                        this.disabled(true).icon_color(Color::Muted)
3485                    } else {
3486                        this.icon_color(Color::Accent)
3487                    }
3488                })
3489                .tooltip(move |_window, cx| {
3490                    if is_editor_empty && !is_generating {
3491                        Tooltip::for_action("Type to Send", &Chat, cx)
3492                    } else if is_generating {
3493                        let focus_handle = focus_handle.clone();
3494
3495                        Tooltip::element(move |_window, cx| {
3496                            v_flex()
3497                                .gap_1()
3498                                .child(
3499                                    h_flex()
3500                                        .gap_2()
3501                                        .justify_between()
3502                                        .child(Label::new("Queue and Send"))
3503                                        .child(KeyBinding::for_action_in(&Chat, &focus_handle, cx)),
3504                                )
3505                                .child(
3506                                    h_flex()
3507                                        .pt_1()
3508                                        .gap_2()
3509                                        .justify_between()
3510                                        .border_t_1()
3511                                        .border_color(cx.theme().colors().border_variant)
3512                                        .child(Label::new("Send Immediately"))
3513                                        .child(KeyBinding::for_action_in(
3514                                            &SendImmediately,
3515                                            &focus_handle,
3516                                            cx,
3517                                        )),
3518                                )
3519                                .into_any_element()
3520                        })(_window, cx)
3521                    } else {
3522                        Tooltip::for_action("Send Message", &Chat, cx)
3523                    }
3524                })
3525                .on_click(cx.listener(|this, _, window, cx| {
3526                    this.send(window, cx);
3527                }))
3528                .into_any_element()
3529        }
3530    }
3531
3532    fn render_add_context_button(&mut self, cx: &mut Context<Self>) -> impl IntoElement {
3533        let focus_handle = self.message_editor.focus_handle(cx);
3534        let weak_self = cx.weak_entity();
3535
3536        PopoverMenu::new("add-context-menu")
3537            .trigger_with_tooltip(
3538                IconButton::new("add-context", IconName::Plus)
3539                    .icon_size(IconSize::Small)
3540                    .icon_color(Color::Muted),
3541                {
3542                    move |_window, cx| {
3543                        Tooltip::for_action_in(
3544                            "Add Context",
3545                            &OpenAddContextMenu,
3546                            &focus_handle,
3547                            cx,
3548                        )
3549                    }
3550                },
3551            )
3552            .anchor(Corner::BottomLeft)
3553            .with_handle(self.add_context_menu_handle.clone())
3554            .offset(gpui::Point {
3555                x: px(0.0),
3556                y: px(-2.0),
3557            })
3558            .menu(move |window, cx| {
3559                weak_self
3560                    .update(cx, |this, cx| this.build_add_context_menu(window, cx))
3561                    .ok()
3562            })
3563    }
3564
3565    fn build_add_context_menu(
3566        &self,
3567        window: &mut Window,
3568        cx: &mut Context<Self>,
3569    ) -> Entity<ContextMenu> {
3570        let message_editor = self.message_editor.clone();
3571        let workspace = self.workspace.clone();
3572        let supports_images = self.prompt_capabilities.borrow().image;
3573
3574        let has_editor_selection = workspace
3575            .upgrade()
3576            .and_then(|ws| {
3577                ws.read(cx)
3578                    .active_item(cx)
3579                    .and_then(|item| item.downcast::<Editor>())
3580            })
3581            .is_some_and(|editor| {
3582                editor.update(cx, |editor, cx| {
3583                    editor.has_non_empty_selection(&editor.display_snapshot(cx))
3584                })
3585            });
3586
3587        let has_terminal_selection = workspace
3588            .upgrade()
3589            .and_then(|ws| ws.read(cx).panel::<TerminalPanel>(cx))
3590            .is_some_and(|panel| !panel.read(cx).terminal_selections(cx).is_empty());
3591
3592        let has_selection = has_editor_selection || has_terminal_selection;
3593
3594        ContextMenu::build(window, cx, move |menu, _window, _cx| {
3595            menu.key_context("AddContextMenu")
3596                .header("Context")
3597                .item(
3598                    ContextMenuEntry::new("Files & Directories")
3599                        .icon(IconName::File)
3600                        .icon_color(Color::Muted)
3601                        .icon_size(IconSize::XSmall)
3602                        .handler({
3603                            let message_editor = message_editor.clone();
3604                            move |window, cx| {
3605                                message_editor.focus_handle(cx).focus(window, cx);
3606                                message_editor.update(cx, |editor, cx| {
3607                                    editor.insert_context_type("file", window, cx);
3608                                });
3609                            }
3610                        }),
3611                )
3612                .item(
3613                    ContextMenuEntry::new("Symbols")
3614                        .icon(IconName::Code)
3615                        .icon_color(Color::Muted)
3616                        .icon_size(IconSize::XSmall)
3617                        .handler({
3618                            let message_editor = message_editor.clone();
3619                            move |window, cx| {
3620                                message_editor.focus_handle(cx).focus(window, cx);
3621                                message_editor.update(cx, |editor, cx| {
3622                                    editor.insert_context_type("symbol", window, cx);
3623                                });
3624                            }
3625                        }),
3626                )
3627                .item(
3628                    ContextMenuEntry::new("Threads")
3629                        .icon(IconName::Thread)
3630                        .icon_color(Color::Muted)
3631                        .icon_size(IconSize::XSmall)
3632                        .handler({
3633                            let message_editor = message_editor.clone();
3634                            move |window, cx| {
3635                                message_editor.focus_handle(cx).focus(window, cx);
3636                                message_editor.update(cx, |editor, cx| {
3637                                    editor.insert_context_type("thread", window, cx);
3638                                });
3639                            }
3640                        }),
3641                )
3642                .item(
3643                    ContextMenuEntry::new("Rules")
3644                        .icon(IconName::Reader)
3645                        .icon_color(Color::Muted)
3646                        .icon_size(IconSize::XSmall)
3647                        .handler({
3648                            let message_editor = message_editor.clone();
3649                            move |window, cx| {
3650                                message_editor.focus_handle(cx).focus(window, cx);
3651                                message_editor.update(cx, |editor, cx| {
3652                                    editor.insert_context_type("rule", window, cx);
3653                                });
3654                            }
3655                        }),
3656                )
3657                .item(
3658                    ContextMenuEntry::new("Image")
3659                        .icon(IconName::Image)
3660                        .icon_color(Color::Muted)
3661                        .icon_size(IconSize::XSmall)
3662                        .disabled(!supports_images)
3663                        .handler({
3664                            let message_editor = message_editor.clone();
3665                            move |window, cx| {
3666                                message_editor.focus_handle(cx).focus(window, cx);
3667                                message_editor.update(cx, |editor, cx| {
3668                                    editor.add_images_from_picker(window, cx);
3669                                });
3670                            }
3671                        }),
3672                )
3673                .item(
3674                    ContextMenuEntry::new("Selection")
3675                        .icon(IconName::CursorIBeam)
3676                        .icon_color(Color::Muted)
3677                        .icon_size(IconSize::XSmall)
3678                        .disabled(!has_selection)
3679                        .handler({
3680                            move |window, cx| {
3681                                window.dispatch_action(
3682                                    zed_actions::agent::AddSelectionToThread.boxed_clone(),
3683                                    cx,
3684                                );
3685                            }
3686                        }),
3687                )
3688        })
3689    }
3690
3691    fn render_follow_toggle(&self, cx: &mut Context<Self>) -> impl IntoElement {
3692        let following = self.is_following(cx);
3693
3694        let tooltip_label = if following {
3695            if self.agent_name == "Zed Agent" {
3696                format!("Stop Following the {}", self.agent_name)
3697            } else {
3698                format!("Stop Following {}", self.agent_name)
3699            }
3700        } else {
3701            if self.agent_name == "Zed Agent" {
3702                format!("Follow the {}", self.agent_name)
3703            } else {
3704                format!("Follow {}", self.agent_name)
3705            }
3706        };
3707
3708        IconButton::new("follow-agent", IconName::Crosshair)
3709            .icon_size(IconSize::Small)
3710            .icon_color(Color::Muted)
3711            .toggle_state(following)
3712            .selected_icon_color(Some(Color::Custom(cx.theme().players().agent().cursor)))
3713            .tooltip(move |_window, cx| {
3714                if following {
3715                    Tooltip::for_action(tooltip_label.clone(), &Follow, cx)
3716                } else {
3717                    Tooltip::with_meta(
3718                        tooltip_label.clone(),
3719                        Some(&Follow),
3720                        "Track the agent's location as it reads and edits files.",
3721                        cx,
3722                    )
3723                }
3724            })
3725            .on_click(cx.listener(move |this, _, window, cx| {
3726                this.toggle_following(window, cx);
3727            }))
3728    }
3729}
3730
3731impl ThreadView {
3732    pub(crate) fn render_entries(&mut self, cx: &mut Context<Self>) -> List {
3733        list(
3734            self.list_state.clone(),
3735            cx.processor(|this, index: usize, window, cx| {
3736                let entries = this.thread.read(cx).entries();
3737                let Some(entry) = entries.get(index) else {
3738                    return Empty.into_any();
3739                };
3740                this.render_entry(index, entries.len(), entry, window, cx)
3741            }),
3742        )
3743        .with_sizing_behavior(gpui::ListSizingBehavior::Auto)
3744        .flex_grow()
3745    }
3746
3747    fn render_entry(
3748        &self,
3749        entry_ix: usize,
3750        total_entries: usize,
3751        entry: &AgentThreadEntry,
3752        window: &Window,
3753        cx: &Context<Self>,
3754    ) -> AnyElement {
3755        let is_indented = entry.is_indented();
3756        let is_first_indented = is_indented
3757            && self
3758                .thread
3759                .read(cx)
3760                .entries()
3761                .get(entry_ix.saturating_sub(1))
3762                .is_none_or(|entry| !entry.is_indented());
3763
3764        let primary = match &entry {
3765            AgentThreadEntry::UserMessage(message) => {
3766                let Some(editor) = self
3767                    .entry_view_state
3768                    .read(cx)
3769                    .entry(entry_ix)
3770                    .and_then(|entry| entry.message_editor())
3771                    .cloned()
3772                else {
3773                    return Empty.into_any_element();
3774                };
3775
3776                let editing = self.editing_message == Some(entry_ix);
3777                let editor_focus = editor.focus_handle(cx).is_focused(window);
3778                let focus_border = cx.theme().colors().border_focused;
3779
3780                let rules_item = if entry_ix == 0 {
3781                    self.render_rules_item(cx)
3782                } else {
3783                    None
3784                };
3785
3786                let has_checkpoint_button = message
3787                    .checkpoint
3788                    .as_ref()
3789                    .is_some_and(|checkpoint| checkpoint.show);
3790
3791                let agent_name = self.agent_name.clone();
3792                let is_subagent = self.is_subagent();
3793
3794                let non_editable_icon = || {
3795                    IconButton::new("non_editable", IconName::PencilUnavailable)
3796                        .icon_size(IconSize::Small)
3797                        .icon_color(Color::Muted)
3798                        .style(ButtonStyle::Transparent)
3799                };
3800
3801                v_flex()
3802                    .id(("user_message", entry_ix))
3803                    .map(|this| {
3804                        if is_first_indented {
3805                            this.pt_0p5()
3806                        } else if entry_ix == 0 && !has_checkpoint_button && rules_item.is_none()  {
3807                            this.pt(rems_from_px(18.))
3808                        } else if rules_item.is_some() {
3809                            this.pt_3()
3810                        } else {
3811                            this.pt_2()
3812                        }
3813                    })
3814                    .pb_3()
3815                    .px_2()
3816                    .gap_1p5()
3817                    .w_full()
3818                    .children(rules_item)
3819                    .children(message.id.clone().and_then(|message_id| {
3820                        message.checkpoint.as_ref()?.show.then(|| {
3821                            h_flex()
3822                                .px_3()
3823                                .gap_2()
3824                                .child(Divider::horizontal())
3825                                .child(
3826                                    Button::new("restore-checkpoint", "Restore Checkpoint")
3827                                        .icon(IconName::Undo)
3828                                        .icon_size(IconSize::XSmall)
3829                                        .icon_position(IconPosition::Start)
3830                                        .label_size(LabelSize::XSmall)
3831                                        .icon_color(Color::Muted)
3832                                        .color(Color::Muted)
3833                                        .tooltip(Tooltip::text("Restores all files in the project to the content they had at this point in the conversation."))
3834                                        .on_click(cx.listener(move |this, _, _window, cx| {
3835                                            this.restore_checkpoint(&message_id, cx);
3836                                        }))
3837                                )
3838                                .child(Divider::horizontal())
3839                        })
3840                    }))
3841                    .child(
3842                        div()
3843                            .relative()
3844                            .child(
3845                                div()
3846                                    .py_3()
3847                                    .px_2()
3848                                    .rounded_md()
3849                                    .bg(cx.theme().colors().editor_background)
3850                                    .border_1()
3851                                    .when(is_indented, |this| {
3852                                        this.py_2().px_2().shadow_sm()
3853                                    })
3854                                    .border_color(cx.theme().colors().border)
3855                                    .map(|this| {
3856                                        if is_subagent {
3857                                            return this.border_dashed();
3858                                        }
3859                                        if editing && editor_focus {
3860                                            return this.border_color(focus_border);
3861                                        }
3862                                        if editing && !editor_focus {
3863                                            return this.border_dashed()
3864                                        }
3865                                        if message.id.is_some() {
3866                                            return this.shadow_md().hover(|s| {
3867                                                s.border_color(focus_border.opacity(0.8))
3868                                            });
3869                                        }
3870                                        this
3871                                    })
3872                                    .text_xs()
3873                                    .child(editor.clone().into_any_element())
3874                            )
3875                            .when(editor_focus, |this| {
3876                                let base_container = h_flex()
3877                                    .absolute()
3878                                    .top_neg_3p5()
3879                                    .right_3()
3880                                    .gap_1()
3881                                    .rounded_sm()
3882                                    .border_1()
3883                                    .border_color(cx.theme().colors().border)
3884                                    .bg(cx.theme().colors().editor_background)
3885                                    .overflow_hidden();
3886
3887                                let is_loading_contents = self.is_loading_contents;
3888                                if is_subagent {
3889                                    this.child(
3890                                        base_container.border_dashed().child(
3891                                            non_editable_icon().tooltip(move |_, cx| {
3892                                                Tooltip::with_meta(
3893                                                    "Unavailable Editing",
3894                                                    None,
3895                                                    "Editing subagent messages is currently not supported.",
3896                                                    cx,
3897                                                )
3898                                            }),
3899                                        ),
3900                                    )
3901                                } else if message.id.is_some() {
3902                                    this.child(
3903                                        base_container
3904                                            .child(
3905                                                IconButton::new("cancel", IconName::Close)
3906                                                    .disabled(is_loading_contents)
3907                                                    .icon_color(Color::Error)
3908                                                    .icon_size(IconSize::XSmall)
3909                                                    .on_click(cx.listener(Self::cancel_editing))
3910                                            )
3911                                            .child(
3912                                                if is_loading_contents {
3913                                                    div()
3914                                                        .id("loading-edited-message-content")
3915                                                        .tooltip(Tooltip::text("Loading Added Context…"))
3916                                                        .child(loading_contents_spinner(IconSize::XSmall))
3917                                                        .into_any_element()
3918                                                } else {
3919                                                    IconButton::new("regenerate", IconName::Return)
3920                                                        .icon_color(Color::Muted)
3921                                                        .icon_size(IconSize::XSmall)
3922                                                        .tooltip(Tooltip::text(
3923                                                            "Editing will restart the thread from this point."
3924                                                        ))
3925                                                        .on_click(cx.listener({
3926                                                            let editor = editor.clone();
3927                                                            move |this, _, window, cx| {
3928                                                                this.regenerate(
3929                                                                    entry_ix, editor.clone(), window, cx,
3930                                                                );
3931                                                            }
3932                                                        })).into_any_element()
3933                                                }
3934                                            )
3935                                    )
3936                                } else {
3937                                    this.child(
3938                                        base_container
3939                                            .border_dashed()
3940                                            .child(
3941                                                non_editable_icon()
3942                                                    .tooltip(Tooltip::element({
3943                                                        move |_, _| {
3944                                                            v_flex()
3945                                                                .gap_1()
3946                                                                .child(Label::new("Unavailable Editing")).child(
3947                                                                    div().max_w_64().child(
3948                                                                        Label::new(format!(
3949                                                                            "Editing previous messages is not available for {} yet.",
3950                                                                            agent_name.clone()
3951                                                                        ))
3952                                                                        .size(LabelSize::Small)
3953                                                                        .color(Color::Muted),
3954                                                                    ),
3955                                                                )
3956                                                                .into_any_element()
3957                                                        }
3958                                                    }))
3959                                            )
3960                                    )
3961                                }
3962                            }),
3963                    )
3964                    .into_any()
3965            }
3966            AgentThreadEntry::AssistantMessage(AssistantMessage {
3967                chunks,
3968                indented: _,
3969                is_subagent_output: _,
3970            }) => {
3971                let mut is_blank = true;
3972                let is_last = entry_ix + 1 == total_entries;
3973
3974                let style = MarkdownStyle::themed(MarkdownFont::Agent, window, cx);
3975                let message_body = v_flex()
3976                    .w_full()
3977                    .gap_3()
3978                    .children(chunks.iter().enumerate().filter_map(
3979                        |(chunk_ix, chunk)| match chunk {
3980                            AssistantMessageChunk::Message { block } => {
3981                                block.markdown().and_then(|md| {
3982                                    let this_is_blank = md.read(cx).source().trim().is_empty();
3983                                    is_blank = is_blank && this_is_blank;
3984                                    if this_is_blank {
3985                                        return None;
3986                                    }
3987
3988                                    Some(
3989                                        self.render_markdown(md.clone(), style.clone())
3990                                            .into_any_element(),
3991                                    )
3992                                })
3993                            }
3994                            AssistantMessageChunk::Thought { block } => {
3995                                block.markdown().and_then(|md| {
3996                                    let this_is_blank = md.read(cx).source().trim().is_empty();
3997                                    is_blank = is_blank && this_is_blank;
3998                                    if this_is_blank {
3999                                        return None;
4000                                    }
4001                                    Some(
4002                                        self.render_thinking_block(
4003                                            entry_ix,
4004                                            chunk_ix,
4005                                            md.clone(),
4006                                            window,
4007                                            cx,
4008                                        )
4009                                        .into_any_element(),
4010                                    )
4011                                })
4012                            }
4013                        },
4014                    ))
4015                    .into_any();
4016
4017                if is_blank {
4018                    Empty.into_any()
4019                } else {
4020                    v_flex()
4021                        .px_5()
4022                        .py_1p5()
4023                        .when(is_last, |this| this.pb_4())
4024                        .w_full()
4025                        .text_ui(cx)
4026                        .child(self.render_message_context_menu(entry_ix, message_body, cx))
4027                        .into_any()
4028                }
4029            }
4030            AgentThreadEntry::ToolCall(tool_call) => self
4031                .render_any_tool_call(
4032                    &self.id,
4033                    entry_ix,
4034                    tool_call,
4035                    &self.focus_handle(cx),
4036                    false,
4037                    window,
4038                    cx,
4039                )
4040                .into_any(),
4041        };
4042
4043        let is_subagent_output = self.is_subagent()
4044            && matches!(entry, AgentThreadEntry::AssistantMessage(msg) if msg.is_subagent_output);
4045
4046        let primary = if is_subagent_output {
4047            v_flex()
4048                .w_full()
4049                .child(
4050                    h_flex()
4051                        .id("subagent_output")
4052                        .px_5()
4053                        .py_1()
4054                        .gap_2()
4055                        .child(Divider::horizontal())
4056                        .child(
4057                            h_flex()
4058                                .gap_1()
4059                                .child(
4060                                    Icon::new(IconName::ForwardArrowUp)
4061                                        .color(Color::Muted)
4062                                        .size(IconSize::Small),
4063                                )
4064                                .child(
4065                                    Label::new("Subagent Output")
4066                                        .size(LabelSize::Custom(self.tool_name_font_size()))
4067                                        .color(Color::Muted),
4068                                ),
4069                        )
4070                        .child(Divider::horizontal())
4071                        .tooltip(Tooltip::text("Everything below this line was sent as output from this subagent to the main agent.")),
4072                )
4073                .child(primary)
4074                .into_any_element()
4075        } else {
4076            primary
4077        };
4078
4079        let primary = if is_indented {
4080            let line_top = if is_first_indented {
4081                rems_from_px(-12.0)
4082            } else {
4083                rems_from_px(0.0)
4084            };
4085
4086            div()
4087                .relative()
4088                .w_full()
4089                .pl_5()
4090                .bg(cx.theme().colors().panel_background.opacity(0.2))
4091                .child(
4092                    div()
4093                        .absolute()
4094                        .left(rems_from_px(18.0))
4095                        .top(line_top)
4096                        .bottom_0()
4097                        .w_px()
4098                        .bg(cx.theme().colors().border.opacity(0.6)),
4099                )
4100                .child(primary)
4101                .into_any_element()
4102        } else {
4103            primary
4104        };
4105
4106        let needs_confirmation = if let AgentThreadEntry::ToolCall(tool_call) = entry {
4107            matches!(
4108                tool_call.status,
4109                ToolCallStatus::WaitingForConfirmation { .. }
4110            )
4111        } else {
4112            false
4113        };
4114
4115        let thread = self.thread.clone();
4116        let comments_editor = self.thread_feedback.comments_editor.clone();
4117
4118        let primary = if entry_ix + 1 == total_entries {
4119            v_flex()
4120                .w_full()
4121                .child(primary)
4122                .map(|this| {
4123                    if needs_confirmation {
4124                        this.child(self.render_generating(true, cx))
4125                    } else {
4126                        this.child(self.render_thread_controls(&thread, cx))
4127                    }
4128                })
4129                .when_some(comments_editor, |this, editor| {
4130                    this.child(Self::render_feedback_feedback_editor(editor, cx))
4131                })
4132                .into_any_element()
4133        } else {
4134            primary
4135        };
4136
4137        if let Some(editing_index) = self.editing_message
4138            && editing_index < entry_ix
4139        {
4140            let is_subagent = self.is_subagent();
4141
4142            let backdrop = div()
4143                .id(("backdrop", entry_ix))
4144                .size_full()
4145                .absolute()
4146                .inset_0()
4147                .bg(cx.theme().colors().panel_background)
4148                .opacity(0.8)
4149                .block_mouse_except_scroll()
4150                .on_click(cx.listener(Self::cancel_editing));
4151
4152            div()
4153                .relative()
4154                .child(primary)
4155                .when(!is_subagent, |this| this.child(backdrop))
4156                .into_any_element()
4157        } else {
4158            primary
4159        }
4160    }
4161
4162    fn render_feedback_feedback_editor(editor: Entity<Editor>, cx: &Context<Self>) -> Div {
4163        h_flex()
4164            .key_context("AgentFeedbackMessageEditor")
4165            .on_action(cx.listener(move |this, _: &menu::Cancel, _, cx| {
4166                this.thread_feedback.dismiss_comments();
4167                cx.notify();
4168            }))
4169            .on_action(cx.listener(move |this, _: &menu::Confirm, _window, cx| {
4170                this.submit_feedback_message(cx);
4171            }))
4172            .p_2()
4173            .mb_2()
4174            .mx_5()
4175            .gap_1()
4176            .rounded_md()
4177            .border_1()
4178            .border_color(cx.theme().colors().border)
4179            .bg(cx.theme().colors().editor_background)
4180            .child(div().w_full().child(editor))
4181            .child(
4182                h_flex()
4183                    .child(
4184                        IconButton::new("dismiss-feedback-message", IconName::Close)
4185                            .icon_color(Color::Error)
4186                            .icon_size(IconSize::XSmall)
4187                            .shape(ui::IconButtonShape::Square)
4188                            .on_click(cx.listener(move |this, _, _window, cx| {
4189                                this.thread_feedback.dismiss_comments();
4190                                cx.notify();
4191                            })),
4192                    )
4193                    .child(
4194                        IconButton::new("submit-feedback-message", IconName::Return)
4195                            .icon_size(IconSize::XSmall)
4196                            .shape(ui::IconButtonShape::Square)
4197                            .on_click(cx.listener(move |this, _, _window, cx| {
4198                                this.submit_feedback_message(cx);
4199                            })),
4200                    ),
4201            )
4202    }
4203
4204    fn render_thread_controls(
4205        &self,
4206        thread: &Entity<AcpThread>,
4207        cx: &Context<Self>,
4208    ) -> impl IntoElement {
4209        let is_generating = matches!(thread.read(cx).status(), ThreadStatus::Generating);
4210        if is_generating {
4211            return self.render_generating(false, cx).into_any_element();
4212        }
4213
4214        let open_as_markdown = IconButton::new("open-as-markdown", IconName::FileMarkdown)
4215            .shape(ui::IconButtonShape::Square)
4216            .icon_size(IconSize::Small)
4217            .icon_color(Color::Ignored)
4218            .tooltip(Tooltip::text("Open Thread as Markdown"))
4219            .on_click(cx.listener(move |this, _, window, cx| {
4220                if let Some(workspace) = this.workspace.upgrade() {
4221                    this.open_thread_as_markdown(workspace, window, cx)
4222                        .detach_and_log_err(cx);
4223                }
4224            }));
4225
4226        let scroll_to_recent_user_prompt =
4227            IconButton::new("scroll_to_recent_user_prompt", IconName::ForwardArrow)
4228                .shape(ui::IconButtonShape::Square)
4229                .icon_size(IconSize::Small)
4230                .icon_color(Color::Ignored)
4231                .tooltip(Tooltip::text("Scroll To Most Recent User Prompt"))
4232                .on_click(cx.listener(move |this, _, _, cx| {
4233                    this.scroll_to_most_recent_user_prompt(cx);
4234                }));
4235
4236        let scroll_to_top = IconButton::new("scroll_to_top", IconName::ArrowUp)
4237            .shape(ui::IconButtonShape::Square)
4238            .icon_size(IconSize::Small)
4239            .icon_color(Color::Ignored)
4240            .tooltip(Tooltip::text("Scroll To Top"))
4241            .on_click(cx.listener(move |this, _, _, cx| {
4242                this.scroll_to_top(cx);
4243            }));
4244
4245        let show_stats = AgentSettings::get_global(cx).show_turn_stats;
4246        let last_turn_clock = show_stats
4247            .then(|| {
4248                self.turn_fields
4249                    .last_turn_duration
4250                    .filter(|&duration| duration > STOPWATCH_THRESHOLD)
4251                    .map(|duration| {
4252                        Label::new(duration_alt_display(duration))
4253                            .size(LabelSize::Small)
4254                            .color(Color::Muted)
4255                    })
4256            })
4257            .flatten();
4258
4259        let last_turn_tokens_label = last_turn_clock
4260            .is_some()
4261            .then(|| {
4262                self.turn_fields
4263                    .last_turn_tokens
4264                    .filter(|&tokens| tokens > TOKEN_THRESHOLD)
4265                    .map(|tokens| {
4266                        Label::new(format!(
4267                            "{} tokens",
4268                            crate::text_thread_editor::humanize_token_count(tokens)
4269                        ))
4270                        .size(LabelSize::Small)
4271                        .color(Color::Muted)
4272                    })
4273            })
4274            .flatten();
4275
4276        let mut container = h_flex()
4277            .w_full()
4278            .py_2()
4279            .px_5()
4280            .gap_px()
4281            .opacity(0.6)
4282            .hover(|s| s.opacity(1.))
4283            .justify_end()
4284            .when(
4285                last_turn_tokens_label.is_some() || last_turn_clock.is_some(),
4286                |this| {
4287                    this.child(
4288                        h_flex()
4289                            .gap_1()
4290                            .px_1()
4291                            .when_some(last_turn_tokens_label, |this, label| this.child(label))
4292                            .when_some(last_turn_clock, |this, label| this.child(label)),
4293                    )
4294                },
4295            );
4296
4297        if AgentSettings::get_global(cx).enable_feedback
4298            && self.thread.read(cx).connection().telemetry().is_some()
4299        {
4300            let feedback = self.thread_feedback.feedback;
4301
4302            let tooltip_meta = || {
4303                SharedString::new(
4304                    "Rating the thread sends all of your current conversation to the Zed team.",
4305                )
4306            };
4307
4308            container = container
4309                    .child(
4310                        IconButton::new("feedback-thumbs-up", IconName::ThumbsUp)
4311                            .shape(ui::IconButtonShape::Square)
4312                            .icon_size(IconSize::Small)
4313                            .icon_color(match feedback {
4314                                Some(ThreadFeedback::Positive) => Color::Accent,
4315                                _ => Color::Ignored,
4316                            })
4317                            .tooltip(move |window, cx| match feedback {
4318                                Some(ThreadFeedback::Positive) => {
4319                                    Tooltip::text("Thanks for your feedback!")(window, cx)
4320                                }
4321                                _ => {
4322                                    Tooltip::with_meta("Helpful Response", None, tooltip_meta(), cx)
4323                                }
4324                            })
4325                            .on_click(cx.listener(move |this, _, window, cx| {
4326                                this.handle_feedback_click(ThreadFeedback::Positive, window, cx);
4327                            })),
4328                    )
4329                    .child(
4330                        IconButton::new("feedback-thumbs-down", IconName::ThumbsDown)
4331                            .shape(ui::IconButtonShape::Square)
4332                            .icon_size(IconSize::Small)
4333                            .icon_color(match feedback {
4334                                Some(ThreadFeedback::Negative) => Color::Accent,
4335                                _ => Color::Ignored,
4336                            })
4337                            .tooltip(move |window, cx| match feedback {
4338                                Some(ThreadFeedback::Negative) => {
4339                                    Tooltip::text(
4340                                    "We appreciate your feedback and will use it to improve in the future.",
4341                                )(window, cx)
4342                                }
4343                                _ => {
4344                                    Tooltip::with_meta(
4345                                        "Not Helpful Response",
4346                                        None,
4347                                        tooltip_meta(),
4348                                        cx,
4349                                    )
4350                                }
4351                            })
4352                            .on_click(cx.listener(move |this, _, window, cx| {
4353                                this.handle_feedback_click(ThreadFeedback::Negative, window, cx);
4354                            })),
4355                    );
4356        }
4357
4358        if let Some(project) = self.project.upgrade()
4359            && let Some(server_view) = self.server_view.upgrade()
4360            && cx.has_flag::<AgentSharingFeatureFlag>()
4361            && project.read(cx).client().status().borrow().is_connected()
4362        {
4363            let button = if self.is_imported_thread(cx) {
4364                IconButton::new("sync-thread", IconName::ArrowCircle)
4365                    .shape(ui::IconButtonShape::Square)
4366                    .icon_size(IconSize::Small)
4367                    .icon_color(Color::Ignored)
4368                    .tooltip(Tooltip::text("Sync with source thread"))
4369                    .on_click(cx.listener(move |this, _, window, cx| {
4370                        this.sync_thread(project.clone(), server_view.clone(), window, cx);
4371                    }))
4372            } else {
4373                IconButton::new("share-thread", IconName::ArrowUpRight)
4374                    .shape(ui::IconButtonShape::Square)
4375                    .icon_size(IconSize::Small)
4376                    .icon_color(Color::Ignored)
4377                    .tooltip(Tooltip::text("Share Thread"))
4378                    .on_click(cx.listener(move |this, _, window, cx| {
4379                        this.share_thread(window, cx);
4380                    }))
4381            };
4382
4383            container = container.child(button);
4384        }
4385
4386        container
4387            .child(open_as_markdown)
4388            .child(scroll_to_recent_user_prompt)
4389            .child(scroll_to_top)
4390            .into_any_element()
4391    }
4392
4393    pub(crate) fn scroll_to_most_recent_user_prompt(&mut self, cx: &mut Context<Self>) {
4394        let entries = self.thread.read(cx).entries();
4395        if entries.is_empty() {
4396            return;
4397        }
4398
4399        // Find the most recent user message and scroll it to the top of the viewport.
4400        // (Fallback: if no user message exists, scroll to the bottom.)
4401        if let Some(ix) = entries
4402            .iter()
4403            .rposition(|entry| matches!(entry, AgentThreadEntry::UserMessage(_)))
4404        {
4405            self.list_state.scroll_to(ListOffset {
4406                item_ix: ix,
4407                offset_in_item: px(0.0),
4408            });
4409            cx.notify();
4410        } else {
4411            self.scroll_to_bottom(cx);
4412        }
4413    }
4414
4415    pub fn scroll_to_bottom(&mut self, cx: &mut Context<Self>) {
4416        let entry_count = self.thread.read(cx).entries().len();
4417        self.list_state.reset(entry_count);
4418        cx.notify();
4419    }
4420
4421    fn handle_feedback_click(
4422        &mut self,
4423        feedback: ThreadFeedback,
4424        window: &mut Window,
4425        cx: &mut Context<Self>,
4426    ) {
4427        self.thread_feedback
4428            .submit(self.thread.clone(), feedback, window, cx);
4429        cx.notify();
4430    }
4431
4432    fn submit_feedback_message(&mut self, cx: &mut Context<Self>) {
4433        let thread = self.thread.clone();
4434        self.thread_feedback.submit_comments(thread, cx);
4435        cx.notify();
4436    }
4437
4438    pub(crate) fn scroll_to_top(&mut self, cx: &mut Context<Self>) {
4439        self.list_state.scroll_to(ListOffset::default());
4440        cx.notify();
4441    }
4442
4443    pub fn open_thread_as_markdown(
4444        &self,
4445        workspace: Entity<Workspace>,
4446        window: &mut Window,
4447        cx: &mut App,
4448    ) -> Task<Result<()>> {
4449        let markdown_language_task = workspace
4450            .read(cx)
4451            .app_state()
4452            .languages
4453            .language_for_name("Markdown");
4454
4455        let thread = self.thread.read(cx);
4456        let thread_title = thread.title().to_string();
4457        let markdown = thread.to_markdown(cx);
4458
4459        let project = workspace.read(cx).project().clone();
4460        window.spawn(cx, async move |cx| {
4461            let markdown_language = markdown_language_task.await?;
4462
4463            let buffer = project
4464                .update(cx, |project, cx| {
4465                    project.create_buffer(Some(markdown_language), false, cx)
4466                })
4467                .await?;
4468
4469            buffer.update(cx, |buffer, cx| {
4470                buffer.set_text(markdown, cx);
4471                buffer.set_capability(language::Capability::ReadWrite, cx);
4472            });
4473
4474            workspace.update_in(cx, |workspace, window, cx| {
4475                let buffer = cx
4476                    .new(|cx| MultiBuffer::singleton(buffer, cx).with_title(thread_title.clone()));
4477
4478                workspace.add_item_to_active_pane(
4479                    Box::new(cx.new(|cx| {
4480                        let mut editor =
4481                            Editor::for_multibuffer(buffer, Some(project.clone()), window, cx);
4482                        editor.set_breadcrumb_header(thread_title);
4483                        editor
4484                    })),
4485                    None,
4486                    true,
4487                    window,
4488                    cx,
4489                );
4490            })?;
4491            anyhow::Ok(())
4492        })
4493    }
4494
4495    fn render_generating(&self, confirmation: bool, cx: &App) -> impl IntoElement {
4496        let show_stats = AgentSettings::get_global(cx).show_turn_stats;
4497        let elapsed_label = show_stats
4498            .then(|| {
4499                self.turn_fields.turn_started_at.and_then(|started_at| {
4500                    let elapsed = started_at.elapsed();
4501                    (elapsed > STOPWATCH_THRESHOLD).then(|| duration_alt_display(elapsed))
4502                })
4503            })
4504            .flatten();
4505
4506        let is_blocked_on_terminal_command =
4507            !confirmation && self.is_blocked_on_terminal_command(cx);
4508        let is_waiting = confirmation || self.thread.read(cx).has_in_progress_tool_calls();
4509
4510        let turn_tokens_label = elapsed_label
4511            .is_some()
4512            .then(|| {
4513                self.turn_fields
4514                    .turn_tokens
4515                    .filter(|&tokens| tokens > TOKEN_THRESHOLD)
4516                    .map(|tokens| crate::text_thread_editor::humanize_token_count(tokens))
4517            })
4518            .flatten();
4519
4520        let arrow_icon = if is_waiting {
4521            IconName::ArrowUp
4522        } else {
4523            IconName::ArrowDown
4524        };
4525
4526        h_flex()
4527            .id("generating-spinner")
4528            .py_2()
4529            .px(rems_from_px(22.))
4530            .gap_2()
4531            .map(|this| {
4532                if confirmation {
4533                    this.child(
4534                        h_flex()
4535                            .w_2()
4536                            .child(SpinnerLabel::sand().size(LabelSize::Small)),
4537                    )
4538                    .child(
4539                        div().min_w(rems(8.)).child(
4540                            LoadingLabel::new("Awaiting Confirmation")
4541                                .size(LabelSize::Small)
4542                                .color(Color::Muted),
4543                        ),
4544                    )
4545                } else if is_blocked_on_terminal_command {
4546                    this
4547                } else {
4548                    this.child(SpinnerLabel::new().size(LabelSize::Small))
4549                }
4550            })
4551            .when_some(elapsed_label, |this, elapsed| {
4552                this.child(
4553                    Label::new(elapsed)
4554                        .size(LabelSize::Small)
4555                        .color(Color::Muted),
4556                )
4557            })
4558            .when_some(turn_tokens_label, |this, tokens| {
4559                this.child(
4560                    h_flex()
4561                        .gap_0p5()
4562                        .child(
4563                            Icon::new(arrow_icon)
4564                                .size(IconSize::XSmall)
4565                                .color(Color::Muted),
4566                        )
4567                        .child(
4568                            Label::new(format!("{} tokens", tokens))
4569                                .size(LabelSize::Small)
4570                                .color(Color::Muted),
4571                        ),
4572                )
4573            })
4574            .into_any_element()
4575    }
4576
4577    fn render_thinking_block(
4578        &self,
4579        entry_ix: usize,
4580        chunk_ix: usize,
4581        chunk: Entity<Markdown>,
4582        window: &Window,
4583        cx: &Context<Self>,
4584    ) -> AnyElement {
4585        let header_id = SharedString::from(format!("thinking-block-header-{}", entry_ix));
4586        let card_header_id = SharedString::from("inner-card-header");
4587
4588        let key = (entry_ix, chunk_ix);
4589
4590        let is_open = self.expanded_thinking_blocks.contains(&key);
4591
4592        let scroll_handle = self
4593            .entry_view_state
4594            .read(cx)
4595            .entry(entry_ix)
4596            .and_then(|entry| entry.scroll_handle_for_assistant_message_chunk(chunk_ix));
4597
4598        let thinking_content = {
4599            div()
4600                .id(("thinking-content", chunk_ix))
4601                .when_some(scroll_handle, |this, scroll_handle| {
4602                    this.track_scroll(&scroll_handle)
4603                })
4604                .text_ui_sm(cx)
4605                .overflow_hidden()
4606                .child(self.render_markdown(
4607                    chunk,
4608                    MarkdownStyle::themed(MarkdownFont::Agent, window, cx),
4609                ))
4610        };
4611
4612        v_flex()
4613            .gap_1()
4614            .child(
4615                h_flex()
4616                    .id(header_id)
4617                    .group(&card_header_id)
4618                    .relative()
4619                    .w_full()
4620                    .pr_1()
4621                    .justify_between()
4622                    .child(
4623                        h_flex()
4624                            .h(window.line_height() - px(2.))
4625                            .gap_1p5()
4626                            .overflow_hidden()
4627                            .child(
4628                                Icon::new(IconName::ToolThink)
4629                                    .size(IconSize::Small)
4630                                    .color(Color::Muted),
4631                            )
4632                            .child(
4633                                div()
4634                                    .text_size(self.tool_name_font_size())
4635                                    .text_color(cx.theme().colors().text_muted)
4636                                    .child("Thinking"),
4637                            ),
4638                    )
4639                    .child(
4640                        Disclosure::new(("expand", entry_ix), is_open)
4641                            .opened_icon(IconName::ChevronUp)
4642                            .closed_icon(IconName::ChevronDown)
4643                            .visible_on_hover(&card_header_id)
4644                            .on_click(cx.listener({
4645                                move |this, _event, _window, cx| {
4646                                    if is_open {
4647                                        this.expanded_thinking_blocks.remove(&key);
4648                                    } else {
4649                                        this.expanded_thinking_blocks.insert(key);
4650                                    }
4651                                    cx.notify();
4652                                }
4653                            })),
4654                    )
4655                    .on_click(cx.listener(move |this, _event, _window, cx| {
4656                        if is_open {
4657                            this.expanded_thinking_blocks.remove(&key);
4658                        } else {
4659                            this.expanded_thinking_blocks.insert(key);
4660                        }
4661                        cx.notify();
4662                    })),
4663            )
4664            .when(is_open, |this| {
4665                this.child(
4666                    div()
4667                        .ml_1p5()
4668                        .pl_3p5()
4669                        .border_l_1()
4670                        .border_color(self.tool_card_border_color(cx))
4671                        .child(thinking_content),
4672                )
4673            })
4674            .into_any_element()
4675    }
4676
4677    fn render_message_context_menu(
4678        &self,
4679        entry_ix: usize,
4680        message_body: AnyElement,
4681        cx: &Context<Self>,
4682    ) -> AnyElement {
4683        let entity = cx.entity();
4684        let workspace = self.workspace.clone();
4685
4686        right_click_menu(format!("agent_context_menu-{}", entry_ix))
4687            .trigger(move |_, _, _| message_body)
4688            .menu(move |window, cx| {
4689                let focus = window.focused(cx);
4690                let entity = entity.clone();
4691                let workspace = workspace.clone();
4692
4693                ContextMenu::build(window, cx, move |menu, _, cx| {
4694                    let this = entity.read(cx);
4695                    let is_at_top = this.list_state.logical_scroll_top().item_ix == 0;
4696
4697                    let has_selection = this
4698                        .thread
4699                        .read(cx)
4700                        .entries()
4701                        .get(entry_ix)
4702                        .and_then(|entry| match &entry {
4703                            AgentThreadEntry::AssistantMessage(msg) => Some(&msg.chunks),
4704                            _ => None,
4705                        })
4706                        .map(|chunks| {
4707                            chunks.iter().any(|chunk| {
4708                                let md = match chunk {
4709                                    AssistantMessageChunk::Message { block } => block.markdown(),
4710                                    AssistantMessageChunk::Thought { block } => block.markdown(),
4711                                };
4712                                md.map_or(false, |m| m.read(cx).selected_text().is_some())
4713                            })
4714                        })
4715                        .unwrap_or(false);
4716
4717                    let copy_this_agent_response =
4718                        ContextMenuEntry::new("Copy This Agent Response").handler({
4719                            let entity = entity.clone();
4720                            move |_, cx| {
4721                                entity.update(cx, |this, cx| {
4722                                    let entries = this.thread.read(cx).entries();
4723                                    if let Some(text) =
4724                                        Self::get_agent_message_content(entries, entry_ix, cx)
4725                                    {
4726                                        cx.write_to_clipboard(ClipboardItem::new_string(text));
4727                                    }
4728                                });
4729                            }
4730                        });
4731
4732                    let scroll_item = if is_at_top {
4733                        ContextMenuEntry::new("Scroll to Bottom").handler({
4734                            let entity = entity.clone();
4735                            move |_, cx| {
4736                                entity.update(cx, |this, cx| {
4737                                    this.scroll_to_bottom(cx);
4738                                });
4739                            }
4740                        })
4741                    } else {
4742                        ContextMenuEntry::new("Scroll to Top").handler({
4743                            let entity = entity.clone();
4744                            move |_, cx| {
4745                                entity.update(cx, |this, cx| {
4746                                    this.scroll_to_top(cx);
4747                                });
4748                            }
4749                        })
4750                    };
4751
4752                    let open_thread_as_markdown = ContextMenuEntry::new("Open Thread as Markdown")
4753                        .handler({
4754                            let entity = entity.clone();
4755                            let workspace = workspace.clone();
4756                            move |window, cx| {
4757                                if let Some(workspace) = workspace.upgrade() {
4758                                    entity
4759                                        .update(cx, |this, cx| {
4760                                            this.open_thread_as_markdown(workspace, window, cx)
4761                                        })
4762                                        .detach_and_log_err(cx);
4763                                }
4764                            }
4765                        });
4766
4767                    menu.when_some(focus, |menu, focus| menu.context(focus))
4768                        .action_disabled_when(
4769                            !has_selection,
4770                            "Copy Selection",
4771                            Box::new(markdown::CopyAsMarkdown),
4772                        )
4773                        .item(copy_this_agent_response)
4774                        .separator()
4775                        .item(scroll_item)
4776                        .item(open_thread_as_markdown)
4777                })
4778            })
4779            .into_any_element()
4780    }
4781
4782    fn get_agent_message_content(
4783        entries: &[AgentThreadEntry],
4784        entry_index: usize,
4785        cx: &App,
4786    ) -> Option<String> {
4787        let entry = entries.get(entry_index)?;
4788        if matches!(entry, AgentThreadEntry::UserMessage(_)) {
4789            return None;
4790        }
4791
4792        let start_index = (0..entry_index)
4793            .rev()
4794            .find(|&i| matches!(entries.get(i), Some(AgentThreadEntry::UserMessage(_))))
4795            .map(|i| i + 1)
4796            .unwrap_or(0);
4797
4798        let end_index = (entry_index + 1..entries.len())
4799            .find(|&i| matches!(entries.get(i), Some(AgentThreadEntry::UserMessage(_))))
4800            .map(|i| i - 1)
4801            .unwrap_or(entries.len() - 1);
4802
4803        let parts: Vec<String> = (start_index..=end_index)
4804            .filter_map(|i| entries.get(i))
4805            .filter_map(|entry| {
4806                if let AgentThreadEntry::AssistantMessage(message) = entry {
4807                    let text: String = message
4808                        .chunks
4809                        .iter()
4810                        .filter_map(|chunk| match chunk {
4811                            AssistantMessageChunk::Message { block } => {
4812                                let markdown = block.to_markdown(cx);
4813                                if markdown.trim().is_empty() {
4814                                    None
4815                                } else {
4816                                    Some(markdown.to_string())
4817                                }
4818                            }
4819                            AssistantMessageChunk::Thought { .. } => None,
4820                        })
4821                        .collect::<Vec<_>>()
4822                        .join("\n\n");
4823
4824                    if text.is_empty() { None } else { Some(text) }
4825                } else {
4826                    None
4827                }
4828            })
4829            .collect();
4830
4831        let text = parts.join("\n\n");
4832        if text.is_empty() { None } else { Some(text) }
4833    }
4834
4835    fn is_blocked_on_terminal_command(&self, cx: &App) -> bool {
4836        let thread = self.thread.read(cx);
4837        if !matches!(thread.status(), ThreadStatus::Generating) {
4838            return false;
4839        }
4840
4841        let mut has_running_terminal_call = false;
4842
4843        for entry in thread.entries().iter().rev() {
4844            match entry {
4845                AgentThreadEntry::UserMessage(_) => break,
4846                AgentThreadEntry::ToolCall(tool_call)
4847                    if matches!(
4848                        tool_call.status,
4849                        ToolCallStatus::InProgress | ToolCallStatus::Pending
4850                    ) =>
4851                {
4852                    if matches!(tool_call.kind, acp::ToolKind::Execute) {
4853                        has_running_terminal_call = true;
4854                    } else {
4855                        return false;
4856                    }
4857                }
4858                AgentThreadEntry::ToolCall(_) | AgentThreadEntry::AssistantMessage(_) => {}
4859            }
4860        }
4861
4862        has_running_terminal_call
4863    }
4864
4865    fn render_collapsible_command(
4866        &self,
4867        group: SharedString,
4868        is_preview: bool,
4869        command_source: &str,
4870        cx: &Context<Self>,
4871    ) -> Div {
4872        v_flex()
4873            .p_1p5()
4874            .bg(self.tool_card_header_bg(cx))
4875            .when(is_preview, |this| {
4876                this.pt_1().child(
4877                    // Wrapping this label on a container with 24px height to avoid
4878                    // layout shift when it changes from being a preview label
4879                    // to the actual path where the command will run in
4880                    h_flex().h_6().child(
4881                        Label::new("Run Command")
4882                            .buffer_font(cx)
4883                            .size(LabelSize::XSmall)
4884                            .color(Color::Muted),
4885                    ),
4886                )
4887            })
4888            .children(command_source.lines().map(|line| {
4889                let text: SharedString = if line.is_empty() {
4890                    " ".into()
4891                } else {
4892                    line.to_string().into()
4893                };
4894
4895                Label::new(text).buffer_font(cx).size(LabelSize::Small)
4896            }))
4897            .child(
4898                div().absolute().top_1().right_1().child(
4899                    CopyButton::new("copy-command", command_source.to_string())
4900                        .tooltip_label("Copy Command")
4901                        .visible_on_hover(group),
4902                ),
4903            )
4904    }
4905
4906    fn render_terminal_tool_call(
4907        &self,
4908        active_session_id: &acp::SessionId,
4909        entry_ix: usize,
4910        terminal: &Entity<acp_thread::Terminal>,
4911        tool_call: &ToolCall,
4912        focus_handle: &FocusHandle,
4913        is_subagent: bool,
4914        window: &Window,
4915        cx: &Context<Self>,
4916    ) -> AnyElement {
4917        let terminal_data = terminal.read(cx);
4918        let working_dir = terminal_data.working_dir();
4919        let command = terminal_data.command();
4920        let started_at = terminal_data.started_at();
4921
4922        let tool_failed = matches!(
4923            &tool_call.status,
4924            ToolCallStatus::Rejected | ToolCallStatus::Canceled | ToolCallStatus::Failed
4925        );
4926
4927        let confirmation_options = match &tool_call.status {
4928            ToolCallStatus::WaitingForConfirmation { options, .. } => Some(options),
4929            _ => None,
4930        };
4931        let needs_confirmation = confirmation_options.is_some();
4932
4933        let output = terminal_data.output();
4934        let command_finished = output.is_some()
4935            && !matches!(
4936                tool_call.status,
4937                ToolCallStatus::InProgress | ToolCallStatus::Pending
4938            );
4939        let truncated_output =
4940            output.is_some_and(|output| output.original_content_len > output.content.len());
4941        let output_line_count = output.map(|output| output.content_line_count).unwrap_or(0);
4942
4943        let command_failed = command_finished
4944            && output.is_some_and(|o| o.exit_status.is_some_and(|status| !status.success()));
4945
4946        let time_elapsed = if let Some(output) = output {
4947            output.ended_at.duration_since(started_at)
4948        } else {
4949            started_at.elapsed()
4950        };
4951
4952        let header_id =
4953            SharedString::from(format!("terminal-tool-header-{}", terminal.entity_id()));
4954        let header_group = SharedString::from(format!(
4955            "terminal-tool-header-group-{}",
4956            terminal.entity_id()
4957        ));
4958        let header_bg = cx
4959            .theme()
4960            .colors()
4961            .element_background
4962            .blend(cx.theme().colors().editor_foreground.opacity(0.025));
4963        let border_color = cx.theme().colors().border.opacity(0.6);
4964
4965        let working_dir = working_dir
4966            .as_ref()
4967            .map(|path| path.display().to_string())
4968            .unwrap_or_else(|| "current directory".to_string());
4969
4970        // Since the command's source is wrapped in a markdown code block
4971        // (```\n...\n```), we need to strip that so we're left with only the
4972        // command's content.
4973        let command_source = command.read(cx).source();
4974        let command_content = command_source
4975            .strip_prefix("```\n")
4976            .and_then(|s| s.strip_suffix("\n```"))
4977            .unwrap_or(&command_source);
4978
4979        let command_element =
4980            self.render_collapsible_command(header_group.clone(), false, command_content, cx);
4981
4982        let is_expanded = self.expanded_tool_calls.contains(&tool_call.id);
4983
4984        let header = h_flex()
4985            .id(header_id)
4986            .pt_1()
4987            .pl_1p5()
4988            .pr_1()
4989            .flex_none()
4990            .gap_1()
4991            .justify_between()
4992            .rounded_t_md()
4993            .child(
4994                div()
4995                    .id(("command-target-path", terminal.entity_id()))
4996                    .w_full()
4997                    .max_w_full()
4998                    .overflow_x_scroll()
4999                    .child(
5000                        Label::new(working_dir)
5001                            .buffer_font(cx)
5002                            .size(LabelSize::XSmall)
5003                            .color(Color::Muted),
5004                    ),
5005            )
5006            .child(
5007                Disclosure::new(
5008                    SharedString::from(format!(
5009                        "terminal-tool-disclosure-{}",
5010                        terminal.entity_id()
5011                    )),
5012                    is_expanded,
5013                )
5014                .opened_icon(IconName::ChevronUp)
5015                .closed_icon(IconName::ChevronDown)
5016                .visible_on_hover(&header_group)
5017                .on_click(cx.listener({
5018                    let id = tool_call.id.clone();
5019                    move |this, _event, _window, cx| {
5020                        if is_expanded {
5021                            this.expanded_tool_calls.remove(&id);
5022                        } else {
5023                            this.expanded_tool_calls.insert(id.clone());
5024                        }
5025                        cx.notify();
5026                    }
5027                })),
5028            )
5029            .when(time_elapsed > Duration::from_secs(10), |header| {
5030                header.child(
5031                    Label::new(format!("({})", duration_alt_display(time_elapsed)))
5032                        .buffer_font(cx)
5033                        .color(Color::Muted)
5034                        .size(LabelSize::XSmall),
5035                )
5036            })
5037            .when(!command_finished && !needs_confirmation, |header| {
5038                header
5039                    .gap_1p5()
5040                    .child(
5041                        Icon::new(IconName::ArrowCircle)
5042                            .size(IconSize::XSmall)
5043                            .color(Color::Muted)
5044                            .with_rotate_animation(2)
5045                    )
5046                    .child(div().h(relative(0.6)).ml_1p5().child(Divider::vertical().color(DividerColor::Border)))
5047                    .child(
5048                        IconButton::new(
5049                            SharedString::from(format!("stop-terminal-{}", terminal.entity_id())),
5050                            IconName::Stop
5051                        )
5052                        .icon_size(IconSize::Small)
5053                        .icon_color(Color::Error)
5054                        .tooltip(move |_window, cx| {
5055                            Tooltip::with_meta(
5056                                "Stop This Command",
5057                                None,
5058                                "Also possible by placing your cursor inside the terminal and using regular terminal bindings.",
5059                                cx,
5060                            )
5061                        })
5062                        .on_click({
5063                            let terminal = terminal.clone();
5064                            cx.listener(move |this, _event, _window, cx| {
5065                                terminal.update(cx, |terminal, cx| {
5066                                    terminal.stop_by_user(cx);
5067                                });
5068                                if AgentSettings::get_global(cx).cancel_generation_on_terminal_stop {
5069                                    this.cancel_generation(cx);
5070                                }
5071                            })
5072                        }),
5073                    )
5074            })
5075            .when(truncated_output, |header| {
5076                let tooltip = if let Some(output) = output {
5077                    if output_line_count + 10 > terminal::MAX_SCROLL_HISTORY_LINES {
5078                       format!("Output exceeded terminal max lines and was \
5079                            truncated, the model received the first {}.", format_file_size(output.content.len() as u64, true))
5080                    } else {
5081                        format!(
5082                            "Output is {} long, and to avoid unexpected token usage, \
5083                                only {} was sent back to the agent.",
5084                            format_file_size(output.original_content_len as u64, true),
5085                             format_file_size(output.content.len() as u64, true)
5086                        )
5087                    }
5088                } else {
5089                    "Output was truncated".to_string()
5090                };
5091
5092                header.child(
5093                    h_flex()
5094                        .id(("terminal-tool-truncated-label", terminal.entity_id()))
5095                        .gap_1()
5096                        .child(
5097                            Icon::new(IconName::Info)
5098                                .size(IconSize::XSmall)
5099                                .color(Color::Ignored),
5100                        )
5101                        .child(
5102                            Label::new("Truncated")
5103                                .color(Color::Muted)
5104                                .size(LabelSize::XSmall),
5105                        )
5106                        .tooltip(Tooltip::text(tooltip)),
5107                )
5108            })
5109            .when(tool_failed || command_failed, |header| {
5110                header.child(
5111                    div()
5112                        .id(("terminal-tool-error-code-indicator", terminal.entity_id()))
5113                        .child(
5114                            Icon::new(IconName::Close)
5115                                .size(IconSize::Small)
5116                                .color(Color::Error),
5117                        )
5118                        .when_some(output.and_then(|o| o.exit_status), |this, status| {
5119                            this.tooltip(Tooltip::text(format!(
5120                                "Exited with code {}",
5121                                status.code().unwrap_or(-1),
5122                            )))
5123                        }),
5124                )
5125            })
5126;
5127
5128        let terminal_view = self
5129            .entry_view_state
5130            .read(cx)
5131            .entry(entry_ix)
5132            .and_then(|entry| entry.terminal(terminal));
5133
5134        v_flex()
5135            .when(!is_subagent, |this| {
5136                this.my_1p5()
5137                    .mx_5()
5138                    .border_1()
5139                    .when(tool_failed || command_failed, |card| card.border_dashed())
5140                    .border_color(border_color)
5141                    .rounded_md()
5142            })
5143            .overflow_hidden()
5144            .child(
5145                v_flex()
5146                    .group(&header_group)
5147                    .bg(header_bg)
5148                    .text_xs()
5149                    .child(header)
5150                    .child(command_element),
5151            )
5152            .when(is_expanded && terminal_view.is_some(), |this| {
5153                this.child(
5154                    div()
5155                        .pt_2()
5156                        .border_t_1()
5157                        .when(tool_failed || command_failed, |card| card.border_dashed())
5158                        .border_color(border_color)
5159                        .bg(cx.theme().colors().editor_background)
5160                        .rounded_b_md()
5161                        .text_ui_sm(cx)
5162                        .h_full()
5163                        .children(terminal_view.map(|terminal_view| {
5164                            let element = if terminal_view
5165                                .read(cx)
5166                                .content_mode(window, cx)
5167                                .is_scrollable()
5168                            {
5169                                div().h_72().child(terminal_view).into_any_element()
5170                            } else {
5171                                terminal_view.into_any_element()
5172                            };
5173
5174                            div()
5175                                .on_action(cx.listener(|_this, _: &NewTerminal, window, cx| {
5176                                    window.dispatch_action(NewThread.boxed_clone(), cx);
5177                                    cx.stop_propagation();
5178                                }))
5179                                .child(element)
5180                                .into_any_element()
5181                        })),
5182                )
5183            })
5184            .when_some(confirmation_options, |this, options| {
5185                let is_first = self.is_first_tool_call(active_session_id, &tool_call.id, cx);
5186                this.child(self.render_permission_buttons(
5187                    self.id.clone(),
5188                    is_first,
5189                    options,
5190                    entry_ix,
5191                    tool_call.id.clone(),
5192                    focus_handle,
5193                    cx,
5194                ))
5195            })
5196            .into_any()
5197    }
5198
5199    fn is_first_tool_call(
5200        &self,
5201        active_session_id: &acp::SessionId,
5202        tool_call_id: &acp::ToolCallId,
5203        cx: &App,
5204    ) -> bool {
5205        self.conversation
5206            .read(cx)
5207            .pending_tool_call(active_session_id, cx)
5208            .map_or(false, |(pending_session_id, pending_tool_call_id, _)| {
5209                self.id == pending_session_id && tool_call_id == &pending_tool_call_id
5210            })
5211    }
5212
5213    fn render_any_tool_call(
5214        &self,
5215        active_session_id: &acp::SessionId,
5216        entry_ix: usize,
5217        tool_call: &ToolCall,
5218        focus_handle: &FocusHandle,
5219        is_subagent: bool,
5220        window: &Window,
5221        cx: &Context<Self>,
5222    ) -> Div {
5223        let has_terminals = tool_call.terminals().next().is_some();
5224
5225        div().w_full().map(|this| {
5226            if tool_call.is_subagent() {
5227                this.child(
5228                    self.render_subagent_tool_call(
5229                        active_session_id,
5230                        entry_ix,
5231                        tool_call,
5232                        tool_call
5233                            .subagent_session_info
5234                            .as_ref()
5235                            .map(|i| i.session_id.clone()),
5236                        focus_handle,
5237                        window,
5238                        cx,
5239                    ),
5240                )
5241            } else if has_terminals {
5242                this.children(tool_call.terminals().map(|terminal| {
5243                    self.render_terminal_tool_call(
5244                        active_session_id,
5245                        entry_ix,
5246                        terminal,
5247                        tool_call,
5248                        focus_handle,
5249                        is_subagent,
5250                        window,
5251                        cx,
5252                    )
5253                }))
5254            } else {
5255                this.child(self.render_tool_call(
5256                    active_session_id,
5257                    entry_ix,
5258                    tool_call,
5259                    focus_handle,
5260                    is_subagent,
5261                    window,
5262                    cx,
5263                ))
5264            }
5265        })
5266    }
5267
5268    fn render_tool_call(
5269        &self,
5270        active_session_id: &acp::SessionId,
5271        entry_ix: usize,
5272        tool_call: &ToolCall,
5273        focus_handle: &FocusHandle,
5274        is_subagent: bool,
5275        window: &Window,
5276        cx: &Context<Self>,
5277    ) -> Div {
5278        let has_location = tool_call.locations.len() == 1;
5279        let card_header_id = SharedString::from("inner-tool-call-header");
5280
5281        let failed_or_canceled = match &tool_call.status {
5282            ToolCallStatus::Rejected | ToolCallStatus::Canceled | ToolCallStatus::Failed => true,
5283            _ => false,
5284        };
5285
5286        let needs_confirmation = matches!(
5287            tool_call.status,
5288            ToolCallStatus::WaitingForConfirmation { .. }
5289        );
5290        let is_terminal_tool = matches!(tool_call.kind, acp::ToolKind::Execute);
5291
5292        let is_edit =
5293            matches!(tool_call.kind, acp::ToolKind::Edit) || tool_call.diffs().next().is_some();
5294
5295        let is_cancelled_edit = is_edit && matches!(tool_call.status, ToolCallStatus::Canceled);
5296        let (has_revealed_diff, tool_call_output_focus) = tool_call
5297            .diffs()
5298            .next()
5299            .and_then(|diff| {
5300                let editor = self
5301                    .entry_view_state
5302                    .read(cx)
5303                    .entry(entry_ix)
5304                    .and_then(|entry| entry.editor_for_diff(diff))?;
5305                let has_revealed_diff = diff.read(cx).has_revealed_range(cx);
5306                let has_focus = editor.read(cx).is_focused(window);
5307                Some((has_revealed_diff, has_focus))
5308            })
5309            .unwrap_or((false, false));
5310
5311        let use_card_layout = needs_confirmation || is_edit || is_terminal_tool;
5312
5313        let has_image_content = tool_call.content.iter().any(|c| c.image().is_some());
5314        let is_collapsible = !tool_call.content.is_empty() && !needs_confirmation;
5315        let mut is_open = self.expanded_tool_calls.contains(&tool_call.id);
5316
5317        is_open |= needs_confirmation;
5318
5319        let should_show_raw_input = !is_terminal_tool && !is_edit && !has_image_content;
5320
5321        let input_output_header = |label: SharedString| {
5322            Label::new(label)
5323                .size(LabelSize::XSmall)
5324                .color(Color::Muted)
5325                .buffer_font(cx)
5326        };
5327
5328        let tool_output_display = if is_open {
5329            match &tool_call.status {
5330                ToolCallStatus::WaitingForConfirmation { options, .. } => v_flex()
5331                    .w_full()
5332                    .children(
5333                        tool_call
5334                            .content
5335                            .iter()
5336                            .enumerate()
5337                            .map(|(content_ix, content)| {
5338                                div()
5339                                    .child(self.render_tool_call_content(
5340                                        active_session_id,
5341                                        entry_ix,
5342                                        content,
5343                                        content_ix,
5344                                        tool_call,
5345                                        use_card_layout,
5346                                        has_image_content,
5347                                        failed_or_canceled,
5348                                        focus_handle,
5349                                        window,
5350                                        cx,
5351                                    ))
5352                                    .into_any_element()
5353                            }),
5354                    )
5355                    .when(should_show_raw_input, |this| {
5356                        let is_raw_input_expanded =
5357                            self.expanded_tool_call_raw_inputs.contains(&tool_call.id);
5358
5359                        let input_header = if is_raw_input_expanded {
5360                            "Raw Input:"
5361                        } else {
5362                            "View Raw Input"
5363                        };
5364
5365                        this.child(
5366                            v_flex()
5367                                .p_2()
5368                                .gap_1()
5369                                .border_t_1()
5370                                .border_color(self.tool_card_border_color(cx))
5371                                .child(
5372                                    h_flex()
5373                                        .id("disclosure_container")
5374                                        .pl_0p5()
5375                                        .gap_1()
5376                                        .justify_between()
5377                                        .rounded_xs()
5378                                        .hover(|s| s.bg(cx.theme().colors().element_hover))
5379                                        .child(input_output_header(input_header.into()))
5380                                        .child(
5381                                            Disclosure::new(
5382                                                ("raw-input-disclosure", entry_ix),
5383                                                is_raw_input_expanded,
5384                                            )
5385                                            .opened_icon(IconName::ChevronUp)
5386                                            .closed_icon(IconName::ChevronDown),
5387                                        )
5388                                        .on_click(cx.listener({
5389                                            let id = tool_call.id.clone();
5390
5391                                            move |this: &mut Self, _, _, cx| {
5392                                                if this.expanded_tool_call_raw_inputs.contains(&id)
5393                                                {
5394                                                    this.expanded_tool_call_raw_inputs.remove(&id);
5395                                                } else {
5396                                                    this.expanded_tool_call_raw_inputs
5397                                                        .insert(id.clone());
5398                                                }
5399                                                cx.notify();
5400                                            }
5401                                        })),
5402                                )
5403                                .when(is_raw_input_expanded, |this| {
5404                                    this.children(tool_call.raw_input_markdown.clone().map(
5405                                        |input| {
5406                                            self.render_markdown(
5407                                                input,
5408                                                MarkdownStyle::themed(
5409                                                    MarkdownFont::Agent,
5410                                                    window,
5411                                                    cx,
5412                                                ),
5413                                            )
5414                                        },
5415                                    ))
5416                                }),
5417                        )
5418                    })
5419                    .child(self.render_permission_buttons(
5420                        self.id.clone(),
5421                        self.is_first_tool_call(active_session_id, &tool_call.id, cx),
5422                        options,
5423                        entry_ix,
5424                        tool_call.id.clone(),
5425                        focus_handle,
5426                        cx,
5427                    ))
5428                    .into_any(),
5429                ToolCallStatus::Pending | ToolCallStatus::InProgress
5430                    if is_edit
5431                        && tool_call.content.is_empty()
5432                        && self.as_native_connection(cx).is_some() =>
5433                {
5434                    self.render_diff_loading(cx)
5435                }
5436                ToolCallStatus::Pending
5437                | ToolCallStatus::InProgress
5438                | ToolCallStatus::Completed
5439                | ToolCallStatus::Failed
5440                | ToolCallStatus::Canceled => v_flex()
5441                    .when(should_show_raw_input, |this| {
5442                        this.mt_1p5().w_full().child(
5443                            v_flex()
5444                                .ml(rems(0.4))
5445                                .px_3p5()
5446                                .pb_1()
5447                                .gap_1()
5448                                .border_l_1()
5449                                .border_color(self.tool_card_border_color(cx))
5450                                .child(input_output_header("Raw Input:".into()))
5451                                .children(tool_call.raw_input_markdown.clone().map(|input| {
5452                                    div().id(("tool-call-raw-input-markdown", entry_ix)).child(
5453                                        self.render_markdown(
5454                                            input,
5455                                            MarkdownStyle::themed(MarkdownFont::Agent, window, cx),
5456                                        ),
5457                                    )
5458                                }))
5459                                .child(input_output_header("Output:".into())),
5460                        )
5461                    })
5462                    .children(
5463                        tool_call
5464                            .content
5465                            .iter()
5466                            .enumerate()
5467                            .map(|(content_ix, content)| {
5468                                div().id(("tool-call-output", entry_ix)).child(
5469                                    self.render_tool_call_content(
5470                                        active_session_id,
5471                                        entry_ix,
5472                                        content,
5473                                        content_ix,
5474                                        tool_call,
5475                                        use_card_layout,
5476                                        has_image_content,
5477                                        failed_or_canceled,
5478                                        focus_handle,
5479                                        window,
5480                                        cx,
5481                                    ),
5482                                )
5483                            }),
5484                    )
5485                    .into_any(),
5486                ToolCallStatus::Rejected => Empty.into_any(),
5487            }
5488            .into()
5489        } else {
5490            None
5491        };
5492
5493        v_flex()
5494            .map(|this| {
5495                if is_subagent {
5496                    this
5497                } else if use_card_layout {
5498                    this.my_1p5()
5499                        .rounded_md()
5500                        .border_1()
5501                        .when(failed_or_canceled, |this| this.border_dashed())
5502                        .border_color(self.tool_card_border_color(cx))
5503                        .bg(cx.theme().colors().editor_background)
5504                        .overflow_hidden()
5505                } else {
5506                    this.my_1()
5507                }
5508            })
5509            .when(!is_subagent, |this| {
5510                this.map(|this| {
5511                    if has_location && !use_card_layout {
5512                        this.ml_4()
5513                    } else {
5514                        this.ml_5()
5515                    }
5516                })
5517                .mr_5()
5518            })
5519            .map(|this| {
5520                if is_terminal_tool {
5521                    let label_source = tool_call.label.read(cx).source();
5522                    this.child(self.render_collapsible_command(
5523                        card_header_id.clone(),
5524                        true,
5525                        label_source,
5526                        cx,
5527                    ))
5528                } else {
5529                    this.child(
5530                        h_flex()
5531                            .group(&card_header_id)
5532                            .relative()
5533                            .w_full()
5534                            .gap_1()
5535                            .justify_between()
5536                            .when(use_card_layout, |this| {
5537                                this.p_0p5()
5538                                    .rounded_t(rems_from_px(5.))
5539                                    .bg(self.tool_card_header_bg(cx))
5540                            })
5541                            .child(self.render_tool_call_label(
5542                                entry_ix,
5543                                tool_call,
5544                                is_edit,
5545                                is_cancelled_edit,
5546                                has_revealed_diff,
5547                                use_card_layout,
5548                                window,
5549                                cx,
5550                            ))
5551                            .child(
5552                                h_flex()
5553                                    .gap_0p5()
5554                                    .when(is_collapsible || failed_or_canceled, |this| {
5555                                        let diff_for_discard = if has_revealed_diff
5556                                            && is_cancelled_edit
5557                                            && cx.has_flag::<AgentV2FeatureFlag>()
5558                                        {
5559                                            tool_call.diffs().next().cloned()
5560                                        } else {
5561                                            None
5562                                        };
5563
5564                                        this.child(
5565                                            h_flex()
5566                                                .px_1()
5567                                                .when_some(diff_for_discard.clone(), |this, _| {
5568                                                    this.pr_0p5()
5569                                                })
5570                                                .gap_1()
5571                                                .when(is_collapsible, |this| {
5572                                                    this.child(
5573                                                        Disclosure::new(
5574                                                            ("expand-output", entry_ix),
5575                                                            is_open,
5576                                                        )
5577                                                        .opened_icon(IconName::ChevronUp)
5578                                                        .closed_icon(IconName::ChevronDown)
5579                                                        .visible_on_hover(&card_header_id)
5580                                                        .on_click(cx.listener({
5581                                                            let id = tool_call.id.clone();
5582                                                            move |this: &mut Self,
5583                                                                  _,
5584                                                                  _,
5585                                                                  cx: &mut Context<Self>| {
5586                                                                if is_open {
5587                                                                    this.expanded_tool_calls
5588                                                                        .remove(&id);
5589                                                                } else {
5590                                                                    this.expanded_tool_calls
5591                                                                        .insert(id.clone());
5592                                                                }
5593                                                                cx.notify();
5594                                                            }
5595                                                        })),
5596                                                    )
5597                                                })
5598                                                .when(failed_or_canceled, |this| {
5599                                                    if is_cancelled_edit && !has_revealed_diff {
5600                                                        this.child(
5601                                                            div()
5602                                                                .id(entry_ix)
5603                                                                .tooltip(Tooltip::text(
5604                                                                    "Interrupted Edit",
5605                                                                ))
5606                                                                .child(
5607                                                                    Icon::new(IconName::XCircle)
5608                                                                        .color(Color::Muted)
5609                                                                        .size(IconSize::Small),
5610                                                                ),
5611                                                        )
5612                                                    } else if is_cancelled_edit {
5613                                                        this
5614                                                    } else {
5615                                                        this.child(
5616                                                            Icon::new(IconName::Close)
5617                                                                .color(Color::Error)
5618                                                                .size(IconSize::Small),
5619                                                        )
5620                                                    }
5621                                                })
5622                                                .when_some(diff_for_discard, |this, diff| {
5623                                                    let tool_call_id = tool_call.id.clone();
5624                                                    let is_discarded = self
5625                                                        .discarded_partial_edits
5626                                                        .contains(&tool_call_id);
5627
5628                                                    this.when(!is_discarded, |this| {
5629                                                        this.child(
5630                                                            IconButton::new(
5631                                                                ("discard-partial-edit", entry_ix),
5632                                                                IconName::Undo,
5633                                                            )
5634                                                            .icon_size(IconSize::Small)
5635                                                            .tooltip(move |_, cx| {
5636                                                                Tooltip::with_meta(
5637                                                                    "Discard Interrupted Edit",
5638                                                                    None,
5639                                                                    "You can discard this interrupted partial edit and restore the original file content.",
5640                                                                    cx,
5641                                                                )
5642                                                            })
5643                                                            .on_click(cx.listener({
5644                                                                let tool_call_id =
5645                                                                    tool_call_id.clone();
5646                                                                move |this, _, _window, cx| {
5647                                                                    let diff_data = diff.read(cx);
5648                                                                    let base_text = diff_data
5649                                                                        .base_text()
5650                                                                        .clone();
5651                                                                    let buffer =
5652                                                                        diff_data.buffer().clone();
5653                                                                    buffer.update(
5654                                                                        cx,
5655                                                                        |buffer, cx| {
5656                                                                            buffer.set_text(
5657                                                                                base_text.as_ref(),
5658                                                                                cx,
5659                                                                            );
5660                                                                        },
5661                                                                    );
5662                                                                    this.discarded_partial_edits
5663                                                                        .insert(
5664                                                                            tool_call_id.clone(),
5665                                                                        );
5666                                                                    cx.notify();
5667                                                                }
5668                                                            })),
5669                                                        )
5670                                                    })
5671                                                }),
5672                                        )
5673                                    })
5674                                    .when(tool_call_output_focus, |this| {
5675                                        this.child(
5676                                            Button::new("open-file-button", "Open File")
5677                                                .label_size(LabelSize::Small)
5678                                                .style(ButtonStyle::OutlinedGhost)
5679                                                .key_binding(
5680                                                    KeyBinding::for_action(&OpenExcerpts, cx)
5681                                                        .map(|s| s.size(rems_from_px(12.))),
5682                                                )
5683                                                .on_click(|_, window, cx| {
5684                                                    window.dispatch_action(
5685                                                        Box::new(OpenExcerpts),
5686                                                        cx,
5687                                                    )
5688                                                }),
5689                                        )
5690                                    }),
5691                            )
5692
5693                    )
5694                }
5695            })
5696            .children(tool_output_display)
5697    }
5698
5699    fn render_permission_buttons(
5700        &self,
5701        session_id: acp::SessionId,
5702        is_first: bool,
5703        options: &PermissionOptions,
5704        entry_ix: usize,
5705        tool_call_id: acp::ToolCallId,
5706        focus_handle: &FocusHandle,
5707        cx: &Context<Self>,
5708    ) -> Div {
5709        match options {
5710            PermissionOptions::Flat(options) => self.render_permission_buttons_flat(
5711                session_id,
5712                is_first,
5713                options,
5714                entry_ix,
5715                tool_call_id,
5716                focus_handle,
5717                cx,
5718            ),
5719            PermissionOptions::Dropdown(options) => self.render_permission_buttons_dropdown(
5720                session_id,
5721                is_first,
5722                options,
5723                entry_ix,
5724                tool_call_id,
5725                focus_handle,
5726                cx,
5727            ),
5728        }
5729    }
5730
5731    fn render_permission_buttons_dropdown(
5732        &self,
5733        session_id: acp::SessionId,
5734        is_first: bool,
5735        choices: &[PermissionOptionChoice],
5736        entry_ix: usize,
5737        tool_call_id: acp::ToolCallId,
5738        focus_handle: &FocusHandle,
5739        cx: &Context<Self>,
5740    ) -> Div {
5741        // Get the selected granularity index, defaulting to the last option ("Only this time")
5742        let selected_index = self
5743            .conversation
5744            .read(cx)
5745            .selected_permission_granularity(&session_id, &tool_call_id)
5746            .unwrap_or_else(|| choices.len().saturating_sub(1));
5747
5748        let selected_choice = choices.get(selected_index).or(choices.last());
5749
5750        let dropdown_label: SharedString = selected_choice
5751            .map(|choice| choice.label())
5752            .unwrap_or_else(|| "Only this time".into());
5753
5754        let (allow_option_id, allow_option_kind, deny_option_id, deny_option_kind) =
5755            if let Some(choice) = selected_choice {
5756                (
5757                    choice.allow.option_id.clone(),
5758                    choice.allow.kind,
5759                    choice.deny.option_id.clone(),
5760                    choice.deny.kind,
5761                )
5762            } else {
5763                (
5764                    acp::PermissionOptionId::new("allow"),
5765                    acp::PermissionOptionKind::AllowOnce,
5766                    acp::PermissionOptionId::new("deny"),
5767                    acp::PermissionOptionKind::RejectOnce,
5768                )
5769            };
5770
5771        h_flex()
5772            .w_full()
5773            .p_1()
5774            .gap_2()
5775            .justify_between()
5776            .border_t_1()
5777            .border_color(self.tool_card_border_color(cx))
5778            .child(
5779                h_flex()
5780                    .gap_0p5()
5781                    .child(
5782                        Button::new(("allow-btn", entry_ix), "Allow")
5783                            .icon(IconName::Check)
5784                            .icon_color(Color::Success)
5785                            .icon_position(IconPosition::Start)
5786                            .icon_size(IconSize::XSmall)
5787                            .label_size(LabelSize::Small)
5788                            .when(is_first, |this| {
5789                                this.key_binding(
5790                                    KeyBinding::for_action_in(
5791                                        &AllowOnce as &dyn Action,
5792                                        focus_handle,
5793                                        cx,
5794                                    )
5795                                    .map(|kb| kb.size(rems_from_px(10.))),
5796                                )
5797                            })
5798                            .on_click(cx.listener({
5799                                let session_id = session_id.clone();
5800                                let tool_call_id = tool_call_id.clone();
5801                                let option_id = allow_option_id;
5802                                let option_kind = allow_option_kind;
5803                                move |this, _, window, cx| {
5804                                    this.authorize_tool_call(
5805                                        session_id.clone(),
5806                                        tool_call_id.clone(),
5807                                        option_id.clone(),
5808                                        option_kind,
5809                                        window,
5810                                        cx,
5811                                    );
5812                                }
5813                            })),
5814                    )
5815                    .child(
5816                        Button::new(("deny-btn", entry_ix), "Deny")
5817                            .icon(IconName::Close)
5818                            .icon_color(Color::Error)
5819                            .icon_position(IconPosition::Start)
5820                            .icon_size(IconSize::XSmall)
5821                            .label_size(LabelSize::Small)
5822                            .when(is_first, |this| {
5823                                this.key_binding(
5824                                    KeyBinding::for_action_in(
5825                                        &RejectOnce as &dyn Action,
5826                                        focus_handle,
5827                                        cx,
5828                                    )
5829                                    .map(|kb| kb.size(rems_from_px(10.))),
5830                                )
5831                            })
5832                            .on_click(cx.listener({
5833                                let session_id = session_id.clone();
5834                                let tool_call_id = tool_call_id.clone();
5835                                let option_id = deny_option_id;
5836                                let option_kind = deny_option_kind;
5837                                move |this, _, window, cx| {
5838                                    this.authorize_tool_call(
5839                                        session_id.clone(),
5840                                        tool_call_id.clone(),
5841                                        option_id.clone(),
5842                                        option_kind,
5843                                        window,
5844                                        cx,
5845                                    );
5846                                }
5847                            })),
5848                    ),
5849            )
5850            .child(self.render_permission_granularity_dropdown(
5851                choices,
5852                dropdown_label,
5853                entry_ix,
5854                session_id,
5855                tool_call_id,
5856                selected_index,
5857                is_first,
5858                cx,
5859            ))
5860    }
5861
5862    fn render_permission_granularity_dropdown(
5863        &self,
5864        choices: &[PermissionOptionChoice],
5865        current_label: SharedString,
5866        entry_ix: usize,
5867        session_id: acp::SessionId,
5868        tool_call_id: acp::ToolCallId,
5869        selected_index: usize,
5870        is_first: bool,
5871        cx: &Context<Self>,
5872    ) -> AnyElement {
5873        let menu_options: Vec<(usize, SharedString)> = choices
5874            .iter()
5875            .enumerate()
5876            .map(|(i, choice)| (i, choice.label()))
5877            .collect();
5878
5879        let permission_dropdown_handle = self.permission_dropdown_handle.clone();
5880
5881        let conversation = self.conversation.clone();
5882
5883        PopoverMenu::new(("permission-granularity", entry_ix))
5884            .with_handle(permission_dropdown_handle)
5885            .trigger(
5886                Button::new(("granularity-trigger", entry_ix), current_label)
5887                    .icon(IconName::ChevronDown)
5888                    .icon_size(IconSize::XSmall)
5889                    .icon_color(Color::Muted)
5890                    .label_size(LabelSize::Small)
5891                    .when(is_first, |this| {
5892                        this.key_binding(
5893                            KeyBinding::for_action_in(
5894                                &crate::OpenPermissionDropdown as &dyn Action,
5895                                &self.focus_handle(cx),
5896                                cx,
5897                            )
5898                            .map(|kb| kb.size(rems_from_px(10.))),
5899                        )
5900                    }),
5901            )
5902            .menu(move |window, cx| {
5903                let session_id = session_id.clone();
5904                let conversation = conversation.clone();
5905                let tool_call_id = tool_call_id.clone();
5906                let options = menu_options.clone();
5907
5908                Some(ContextMenu::build(window, cx, move |mut menu, _, _| {
5909                    for (index, display_name) in options.iter() {
5910                        let display_name = display_name.clone();
5911                        let index = *index;
5912                        let session_id = session_id.clone();
5913                        let conversation = conversation.clone();
5914                        let tool_call_id = tool_call_id.clone();
5915                        let is_selected = index == selected_index;
5916                        menu = menu.toggleable_entry(
5917                            display_name,
5918                            is_selected,
5919                            IconPosition::End,
5920                            None,
5921                            move |_window, cx| {
5922                                conversation.update(cx, |conversation, _cx| {
5923                                    conversation.set_selected_permission_granularity(
5924                                        session_id.clone(),
5925                                        tool_call_id.clone(),
5926                                        index,
5927                                    );
5928                                });
5929                            },
5930                        );
5931                    }
5932
5933                    menu
5934                }))
5935            })
5936            .into_any_element()
5937    }
5938
5939    fn render_permission_buttons_flat(
5940        &self,
5941        session_id: acp::SessionId,
5942        is_first: bool,
5943        options: &[acp::PermissionOption],
5944        entry_ix: usize,
5945        tool_call_id: acp::ToolCallId,
5946        focus_handle: &FocusHandle,
5947        cx: &Context<Self>,
5948    ) -> Div {
5949        let mut seen_kinds: ArrayVec<acp::PermissionOptionKind, 3> = ArrayVec::new();
5950
5951        div()
5952            .p_1()
5953            .border_t_1()
5954            .border_color(self.tool_card_border_color(cx))
5955            .w_full()
5956            .v_flex()
5957            .gap_0p5()
5958            .children(options.iter().map(move |option| {
5959                let option_id = SharedString::from(option.option_id.0.clone());
5960                Button::new((option_id, entry_ix), option.name.clone())
5961                    .map(|this| {
5962                        let (this, action) = match option.kind {
5963                            acp::PermissionOptionKind::AllowOnce => (
5964                                this.icon(IconName::Check).icon_color(Color::Success),
5965                                Some(&AllowOnce as &dyn Action),
5966                            ),
5967                            acp::PermissionOptionKind::AllowAlways => (
5968                                this.icon(IconName::CheckDouble).icon_color(Color::Success),
5969                                Some(&AllowAlways as &dyn Action),
5970                            ),
5971                            acp::PermissionOptionKind::RejectOnce => (
5972                                this.icon(IconName::Close).icon_color(Color::Error),
5973                                Some(&RejectOnce as &dyn Action),
5974                            ),
5975                            acp::PermissionOptionKind::RejectAlways | _ => {
5976                                (this.icon(IconName::Close).icon_color(Color::Error), None)
5977                            }
5978                        };
5979
5980                        let Some(action) = action else {
5981                            return this;
5982                        };
5983
5984                        if !is_first || seen_kinds.contains(&option.kind) {
5985                            return this;
5986                        }
5987
5988                        seen_kinds.push(option.kind);
5989
5990                        this.key_binding(
5991                            KeyBinding::for_action_in(action, focus_handle, cx)
5992                                .map(|kb| kb.size(rems_from_px(10.))),
5993                        )
5994                    })
5995                    .icon_position(IconPosition::Start)
5996                    .icon_size(IconSize::XSmall)
5997                    .label_size(LabelSize::Small)
5998                    .on_click(cx.listener({
5999                        let session_id = session_id.clone();
6000                        let tool_call_id = tool_call_id.clone();
6001                        let option_id = option.option_id.clone();
6002                        let option_kind = option.kind;
6003                        move |this, _, window, cx| {
6004                            this.authorize_tool_call(
6005                                session_id.clone(),
6006                                tool_call_id.clone(),
6007                                option_id.clone(),
6008                                option_kind,
6009                                window,
6010                                cx,
6011                            );
6012                        }
6013                    }))
6014            }))
6015    }
6016
6017    fn render_diff_loading(&self, cx: &Context<Self>) -> AnyElement {
6018        let bar = |n: u64, width_class: &str| {
6019            let bg_color = cx.theme().colors().element_active;
6020            let base = h_flex().h_1().rounded_full();
6021
6022            let modified = match width_class {
6023                "w_4_5" => base.w_3_4(),
6024                "w_1_4" => base.w_1_4(),
6025                "w_2_4" => base.w_2_4(),
6026                "w_3_5" => base.w_3_5(),
6027                "w_2_5" => base.w_2_5(),
6028                _ => base.w_1_2(),
6029            };
6030
6031            modified.with_animation(
6032                ElementId::Integer(n),
6033                Animation::new(Duration::from_secs(2)).repeat(),
6034                move |tab, delta| {
6035                    let delta = (delta - 0.15 * n as f32) / 0.7;
6036                    let delta = 1.0 - (0.5 - delta).abs() * 2.;
6037                    let delta = ease_in_out(delta.clamp(0., 1.));
6038                    let delta = 0.1 + 0.9 * delta;
6039
6040                    tab.bg(bg_color.opacity(delta))
6041                },
6042            )
6043        };
6044
6045        v_flex()
6046            .p_3()
6047            .gap_1()
6048            .rounded_b_md()
6049            .bg(cx.theme().colors().editor_background)
6050            .child(bar(0, "w_4_5"))
6051            .child(bar(1, "w_1_4"))
6052            .child(bar(2, "w_2_4"))
6053            .child(bar(3, "w_3_5"))
6054            .child(bar(4, "w_2_5"))
6055            .into_any_element()
6056    }
6057
6058    fn render_tool_call_label(
6059        &self,
6060        entry_ix: usize,
6061        tool_call: &ToolCall,
6062        is_edit: bool,
6063        has_failed: bool,
6064        has_revealed_diff: bool,
6065        use_card_layout: bool,
6066        window: &Window,
6067        cx: &Context<Self>,
6068    ) -> Div {
6069        let has_location = tool_call.locations.len() == 1;
6070        let is_file = tool_call.kind == acp::ToolKind::Edit && has_location;
6071        let is_subagent_tool_call = tool_call.is_subagent();
6072
6073        let file_icon = if has_location {
6074            FileIcons::get_icon(&tool_call.locations[0].path, cx)
6075                .map(Icon::from_path)
6076                .unwrap_or(Icon::new(IconName::ToolPencil))
6077        } else {
6078            Icon::new(IconName::ToolPencil)
6079        };
6080
6081        let tool_icon = if is_file && has_failed && has_revealed_diff {
6082            div()
6083                .id(entry_ix)
6084                .tooltip(Tooltip::text("Interrupted Edit"))
6085                .child(DecoratedIcon::new(
6086                    file_icon,
6087                    Some(
6088                        IconDecoration::new(
6089                            IconDecorationKind::Triangle,
6090                            self.tool_card_header_bg(cx),
6091                            cx,
6092                        )
6093                        .color(cx.theme().status().warning)
6094                        .position(gpui::Point {
6095                            x: px(-2.),
6096                            y: px(-2.),
6097                        }),
6098                    ),
6099                ))
6100                .into_any_element()
6101        } else if is_file {
6102            div().child(file_icon).into_any_element()
6103        } else if is_subagent_tool_call {
6104            Icon::new(self.agent_icon)
6105                .size(IconSize::Small)
6106                .color(Color::Muted)
6107                .into_any_element()
6108        } else {
6109            Icon::new(match tool_call.kind {
6110                acp::ToolKind::Read => IconName::ToolSearch,
6111                acp::ToolKind::Edit => IconName::ToolPencil,
6112                acp::ToolKind::Delete => IconName::ToolDeleteFile,
6113                acp::ToolKind::Move => IconName::ArrowRightLeft,
6114                acp::ToolKind::Search => IconName::ToolSearch,
6115                acp::ToolKind::Execute => IconName::ToolTerminal,
6116                acp::ToolKind::Think => IconName::ToolThink,
6117                acp::ToolKind::Fetch => IconName::ToolWeb,
6118                acp::ToolKind::SwitchMode => IconName::ArrowRightLeft,
6119                acp::ToolKind::Other | _ => IconName::ToolHammer,
6120            })
6121            .size(IconSize::Small)
6122            .color(Color::Muted)
6123            .into_any_element()
6124        };
6125
6126        let gradient_overlay = {
6127            div()
6128                .absolute()
6129                .top_0()
6130                .right_0()
6131                .w_12()
6132                .h_full()
6133                .map(|this| {
6134                    if use_card_layout {
6135                        this.bg(linear_gradient(
6136                            90.,
6137                            linear_color_stop(self.tool_card_header_bg(cx), 1.),
6138                            linear_color_stop(self.tool_card_header_bg(cx).opacity(0.2), 0.),
6139                        ))
6140                    } else {
6141                        this.bg(linear_gradient(
6142                            90.,
6143                            linear_color_stop(cx.theme().colors().panel_background, 1.),
6144                            linear_color_stop(
6145                                cx.theme().colors().panel_background.opacity(0.2),
6146                                0.,
6147                            ),
6148                        ))
6149                    }
6150                })
6151        };
6152
6153        h_flex()
6154            .relative()
6155            .w_full()
6156            .h(window.line_height() - px(2.))
6157            .text_size(self.tool_name_font_size())
6158            .gap_1p5()
6159            .when(has_location || use_card_layout, |this| this.px_1())
6160            .when(has_location, |this| {
6161                this.cursor(CursorStyle::PointingHand)
6162                    .rounded(rems_from_px(3.)) // Concentric border radius
6163                    .hover(|s| s.bg(cx.theme().colors().element_hover.opacity(0.5)))
6164            })
6165            .overflow_hidden()
6166            .child(tool_icon)
6167            .child(if has_location {
6168                h_flex()
6169                    .id(("open-tool-call-location", entry_ix))
6170                    .w_full()
6171                    .map(|this| {
6172                        if use_card_layout {
6173                            this.text_color(cx.theme().colors().text)
6174                        } else {
6175                            this.text_color(cx.theme().colors().text_muted)
6176                        }
6177                    })
6178                    .child(
6179                        self.render_markdown(
6180                            tool_call.label.clone(),
6181                            MarkdownStyle {
6182                                prevent_mouse_interaction: true,
6183                                ..MarkdownStyle::themed(MarkdownFont::Agent, window, cx)
6184                                    .with_muted_text(cx)
6185                            },
6186                        ),
6187                    )
6188                    .tooltip(Tooltip::text("Go to File"))
6189                    .on_click(cx.listener(move |this, _, window, cx| {
6190                        this.open_tool_call_location(entry_ix, 0, window, cx);
6191                    }))
6192                    .into_any_element()
6193            } else {
6194                h_flex()
6195                    .w_full()
6196                    .child(self.render_markdown(
6197                        tool_call.label.clone(),
6198                        MarkdownStyle::themed(MarkdownFont::Agent, window, cx).with_muted_text(cx),
6199                    ))
6200                    .into_any()
6201            })
6202            .when(!is_edit, |this| this.child(gradient_overlay))
6203    }
6204
6205    fn open_tool_call_location(
6206        &self,
6207        entry_ix: usize,
6208        location_ix: usize,
6209        window: &mut Window,
6210        cx: &mut Context<Self>,
6211    ) -> Option<()> {
6212        let (tool_call_location, agent_location) = self
6213            .thread
6214            .read(cx)
6215            .entries()
6216            .get(entry_ix)?
6217            .location(location_ix)?;
6218
6219        let project_path = self
6220            .project
6221            .upgrade()?
6222            .read(cx)
6223            .find_project_path(&tool_call_location.path, cx)?;
6224
6225        let open_task = self
6226            .workspace
6227            .update(cx, |workspace, cx| {
6228                workspace.open_path(project_path, None, true, window, cx)
6229            })
6230            .log_err()?;
6231        window
6232            .spawn(cx, async move |cx| {
6233                let item = open_task.await?;
6234
6235                let Some(active_editor) = item.downcast::<Editor>() else {
6236                    return anyhow::Ok(());
6237                };
6238
6239                active_editor.update_in(cx, |editor, window, cx| {
6240                    let singleton = editor
6241                        .buffer()
6242                        .read(cx)
6243                        .read(cx)
6244                        .as_singleton()
6245                        .map(|(a, b, _)| (a, b));
6246                    if let Some((excerpt_id, buffer_id)) = singleton
6247                        && let Some(agent_buffer) = agent_location.buffer.upgrade()
6248                        && agent_buffer.read(cx).remote_id() == buffer_id
6249                    {
6250                        let anchor = editor::Anchor::in_buffer(excerpt_id, agent_location.position);
6251                        editor.change_selections(Default::default(), window, cx, |selections| {
6252                            selections.select_anchor_ranges([anchor..anchor]);
6253                        })
6254                    } else {
6255                        let row = tool_call_location.line.unwrap_or_default();
6256                        editor.change_selections(Default::default(), window, cx, |selections| {
6257                            selections.select_ranges([Point::new(row, 0)..Point::new(row, 0)]);
6258                        })
6259                    }
6260                })?;
6261
6262                anyhow::Ok(())
6263            })
6264            .detach_and_log_err(cx);
6265
6266        None
6267    }
6268
6269    fn render_tool_call_content(
6270        &self,
6271        session_id: &acp::SessionId,
6272        entry_ix: usize,
6273        content: &ToolCallContent,
6274        context_ix: usize,
6275        tool_call: &ToolCall,
6276        card_layout: bool,
6277        is_image_tool_call: bool,
6278        has_failed: bool,
6279        focus_handle: &FocusHandle,
6280        window: &Window,
6281        cx: &Context<Self>,
6282    ) -> AnyElement {
6283        match content {
6284            ToolCallContent::ContentBlock(content) => {
6285                if let Some(resource_link) = content.resource_link() {
6286                    self.render_resource_link(resource_link, cx)
6287                } else if let Some(markdown) = content.markdown() {
6288                    self.render_markdown_output(
6289                        markdown.clone(),
6290                        tool_call.id.clone(),
6291                        context_ix,
6292                        card_layout,
6293                        window,
6294                        cx,
6295                    )
6296                } else if let Some(image) = content.image() {
6297                    let location = tool_call.locations.first().cloned();
6298                    self.render_image_output(
6299                        entry_ix,
6300                        image.clone(),
6301                        location,
6302                        card_layout,
6303                        is_image_tool_call,
6304                        cx,
6305                    )
6306                } else {
6307                    Empty.into_any_element()
6308                }
6309            }
6310            ToolCallContent::Diff(diff) => {
6311                self.render_diff_editor(entry_ix, diff, tool_call, has_failed, cx)
6312            }
6313            ToolCallContent::Terminal(terminal) => self.render_terminal_tool_call(
6314                session_id,
6315                entry_ix,
6316                terminal,
6317                tool_call,
6318                focus_handle,
6319                false,
6320                window,
6321                cx,
6322            ),
6323        }
6324    }
6325
6326    fn render_resource_link(
6327        &self,
6328        resource_link: &acp::ResourceLink,
6329        cx: &Context<Self>,
6330    ) -> AnyElement {
6331        let uri: SharedString = resource_link.uri.clone().into();
6332        let is_file = resource_link.uri.strip_prefix("file://");
6333
6334        let Some(project) = self.project.upgrade() else {
6335            return Empty.into_any_element();
6336        };
6337
6338        let label: SharedString = if let Some(abs_path) = is_file {
6339            if let Some(project_path) = project
6340                .read(cx)
6341                .project_path_for_absolute_path(&Path::new(abs_path), cx)
6342                && let Some(worktree) = project
6343                    .read(cx)
6344                    .worktree_for_id(project_path.worktree_id, cx)
6345            {
6346                worktree
6347                    .read(cx)
6348                    .full_path(&project_path.path)
6349                    .to_string_lossy()
6350                    .to_string()
6351                    .into()
6352            } else {
6353                abs_path.to_string().into()
6354            }
6355        } else {
6356            uri.clone()
6357        };
6358
6359        let button_id = SharedString::from(format!("item-{}", uri));
6360
6361        div()
6362            .ml(rems(0.4))
6363            .pl_2p5()
6364            .border_l_1()
6365            .border_color(self.tool_card_border_color(cx))
6366            .overflow_hidden()
6367            .child(
6368                Button::new(button_id, label)
6369                    .label_size(LabelSize::Small)
6370                    .color(Color::Muted)
6371                    .truncate(true)
6372                    .when(is_file.is_none(), |this| {
6373                        this.icon(IconName::ArrowUpRight)
6374                            .icon_size(IconSize::XSmall)
6375                            .icon_color(Color::Muted)
6376                    })
6377                    .on_click(cx.listener({
6378                        let workspace = self.workspace.clone();
6379                        move |_, _, window, cx: &mut Context<Self>| {
6380                            open_link(uri.clone(), &workspace, window, cx);
6381                        }
6382                    })),
6383            )
6384            .into_any_element()
6385    }
6386
6387    fn render_diff_editor(
6388        &self,
6389        entry_ix: usize,
6390        diff: &Entity<acp_thread::Diff>,
6391        tool_call: &ToolCall,
6392        has_failed: bool,
6393        cx: &Context<Self>,
6394    ) -> AnyElement {
6395        let tool_progress = matches!(
6396            &tool_call.status,
6397            ToolCallStatus::InProgress | ToolCallStatus::Pending
6398        );
6399
6400        let revealed_diff_editor = if let Some(entry) =
6401            self.entry_view_state.read(cx).entry(entry_ix)
6402            && let Some(editor) = entry.editor_for_diff(diff)
6403            && diff.read(cx).has_revealed_range(cx)
6404        {
6405            Some(editor)
6406        } else {
6407            None
6408        };
6409
6410        let show_top_border = !has_failed || revealed_diff_editor.is_some();
6411
6412        v_flex()
6413            .h_full()
6414            .when(show_top_border, |this| {
6415                this.border_t_1()
6416                    .when(has_failed, |this| this.border_dashed())
6417                    .border_color(self.tool_card_border_color(cx))
6418            })
6419            .child(if let Some(editor) = revealed_diff_editor {
6420                editor.into_any_element()
6421            } else if tool_progress && self.as_native_connection(cx).is_some() {
6422                self.render_diff_loading(cx)
6423            } else {
6424                Empty.into_any()
6425            })
6426            .into_any()
6427    }
6428
6429    fn render_markdown_output(
6430        &self,
6431        markdown: Entity<Markdown>,
6432        tool_call_id: acp::ToolCallId,
6433        context_ix: usize,
6434        card_layout: bool,
6435        window: &Window,
6436        cx: &Context<Self>,
6437    ) -> AnyElement {
6438        let button_id = SharedString::from(format!("tool_output-{:?}", tool_call_id));
6439
6440        v_flex()
6441            .gap_2()
6442            .map(|this| {
6443                if card_layout {
6444                    this.when(context_ix > 0, |this| {
6445                        this.pt_2()
6446                            .border_t_1()
6447                            .border_color(self.tool_card_border_color(cx))
6448                    })
6449                } else {
6450                    this.ml(rems(0.4))
6451                        .px_3p5()
6452                        .border_l_1()
6453                        .border_color(self.tool_card_border_color(cx))
6454                }
6455            })
6456            .text_xs()
6457            .text_color(cx.theme().colors().text_muted)
6458            .child(self.render_markdown(
6459                markdown,
6460                MarkdownStyle::themed(MarkdownFont::Agent, window, cx),
6461            ))
6462            .when(!card_layout, |this| {
6463                this.child(
6464                    IconButton::new(button_id, IconName::ChevronUp)
6465                        .full_width()
6466                        .style(ButtonStyle::Outlined)
6467                        .icon_color(Color::Muted)
6468                        .on_click(cx.listener({
6469                            move |this: &mut Self, _, _, cx: &mut Context<Self>| {
6470                                this.expanded_tool_calls.remove(&tool_call_id);
6471                                cx.notify();
6472                            }
6473                        })),
6474                )
6475            })
6476            .into_any_element()
6477    }
6478
6479    fn render_image_output(
6480        &self,
6481        entry_ix: usize,
6482        image: Arc<gpui::Image>,
6483        location: Option<acp::ToolCallLocation>,
6484        card_layout: bool,
6485        show_dimensions: bool,
6486        cx: &Context<Self>,
6487    ) -> AnyElement {
6488        let dimensions_label = if show_dimensions {
6489            let format_name = match image.format() {
6490                gpui::ImageFormat::Png => "PNG",
6491                gpui::ImageFormat::Jpeg => "JPEG",
6492                gpui::ImageFormat::Webp => "WebP",
6493                gpui::ImageFormat::Gif => "GIF",
6494                gpui::ImageFormat::Svg => "SVG",
6495                gpui::ImageFormat::Bmp => "BMP",
6496                gpui::ImageFormat::Tiff => "TIFF",
6497                gpui::ImageFormat::Ico => "ICO",
6498            };
6499            let dimensions = image::ImageReader::new(std::io::Cursor::new(image.bytes()))
6500                .with_guessed_format()
6501                .ok()
6502                .and_then(|reader| reader.into_dimensions().ok());
6503            dimensions.map(|(w, h)| format!("{}×{} {}", w, h, format_name))
6504        } else {
6505            None
6506        };
6507
6508        v_flex()
6509            .gap_2()
6510            .map(|this| {
6511                if card_layout {
6512                    this
6513                } else {
6514                    this.ml(rems(0.4))
6515                        .px_3p5()
6516                        .border_l_1()
6517                        .border_color(self.tool_card_border_color(cx))
6518                }
6519            })
6520            .when(dimensions_label.is_some() || location.is_some(), |this| {
6521                this.child(
6522                    h_flex()
6523                        .w_full()
6524                        .justify_between()
6525                        .items_center()
6526                        .children(dimensions_label.map(|label| {
6527                            Label::new(label)
6528                                .size(LabelSize::XSmall)
6529                                .color(Color::Muted)
6530                                .buffer_font(cx)
6531                        }))
6532                        .when_some(location, |this, _loc| {
6533                            this.child(
6534                                Button::new(("go-to-file", entry_ix), "Go to File")
6535                                    .label_size(LabelSize::Small)
6536                                    .on_click(cx.listener(move |this, _, window, cx| {
6537                                        this.open_tool_call_location(entry_ix, 0, window, cx);
6538                                    })),
6539                            )
6540                        }),
6541                )
6542            })
6543            .child(
6544                img(image)
6545                    .max_w_96()
6546                    .max_h_96()
6547                    .object_fit(ObjectFit::ScaleDown),
6548            )
6549            .into_any_element()
6550    }
6551
6552    fn render_subagent_tool_call(
6553        &self,
6554        active_session_id: &acp::SessionId,
6555        entry_ix: usize,
6556        tool_call: &ToolCall,
6557        subagent_session_id: Option<acp::SessionId>,
6558        focus_handle: &FocusHandle,
6559        window: &Window,
6560        cx: &Context<Self>,
6561    ) -> Div {
6562        let subagent_thread_view = subagent_session_id.and_then(|id| {
6563            self.server_view
6564                .upgrade()
6565                .and_then(|server_view| server_view.read(cx).as_connected())
6566                .and_then(|connected| connected.threads.get(&id))
6567        });
6568
6569        let content = self.render_subagent_card(
6570            active_session_id,
6571            entry_ix,
6572            subagent_thread_view,
6573            tool_call,
6574            focus_handle,
6575            window,
6576            cx,
6577        );
6578
6579        v_flex().mx_5().my_1p5().gap_3().child(content)
6580    }
6581
6582    fn render_subagent_card(
6583        &self,
6584        active_session_id: &acp::SessionId,
6585        entry_ix: usize,
6586        thread_view: Option<&Entity<ThreadView>>,
6587        tool_call: &ToolCall,
6588        focus_handle: &FocusHandle,
6589        window: &Window,
6590        cx: &Context<Self>,
6591    ) -> AnyElement {
6592        let thread = thread_view
6593            .as_ref()
6594            .map(|view| view.read(cx).thread.clone());
6595        let subagent_session_id = thread
6596            .as_ref()
6597            .map(|thread| thread.read(cx).session_id().clone());
6598        let action_log = thread.as_ref().map(|thread| thread.read(cx).action_log());
6599        let changed_buffers = action_log
6600            .map(|log| log.read(cx).changed_buffers(cx))
6601            .unwrap_or_default();
6602
6603        let is_pending_tool_call = thread
6604            .as_ref()
6605            .and_then(|thread| {
6606                self.conversation
6607                    .read(cx)
6608                    .pending_tool_call(thread.read(cx).session_id(), cx)
6609            })
6610            .is_some();
6611
6612        let is_expanded = self.expanded_tool_calls.contains(&tool_call.id);
6613        let files_changed = changed_buffers.len();
6614        let diff_stats = DiffStats::all_files(&changed_buffers, cx);
6615
6616        let is_running = matches!(
6617            tool_call.status,
6618            ToolCallStatus::Pending
6619                | ToolCallStatus::InProgress
6620                | ToolCallStatus::WaitingForConfirmation { .. }
6621        );
6622
6623        let is_failed = matches!(
6624            tool_call.status,
6625            ToolCallStatus::Failed | ToolCallStatus::Rejected
6626        );
6627
6628        let is_cancelled = matches!(tool_call.status, ToolCallStatus::Canceled)
6629            || tool_call.content.iter().any(|c| match c {
6630                ToolCallContent::ContentBlock(ContentBlock::Markdown { markdown }) => {
6631                    markdown.read(cx).source() == "User canceled"
6632                }
6633                _ => false,
6634            });
6635
6636        let thread_title = thread
6637            .as_ref()
6638            .map(|t| t.read(cx).title())
6639            .filter(|t| !t.is_empty());
6640        let tool_call_label = tool_call.label.read(cx).source().to_string();
6641        let has_tool_call_label = !tool_call_label.is_empty();
6642
6643        let has_title = thread_title.is_some() || has_tool_call_label;
6644        let has_no_title_or_canceled = !has_title || is_failed || is_cancelled;
6645
6646        let title: SharedString = if let Some(thread_title) = thread_title {
6647            thread_title
6648        } else if !tool_call_label.is_empty() {
6649            tool_call_label.into()
6650        } else if is_cancelled {
6651            "Subagent Canceled".into()
6652        } else if is_failed {
6653            "Subagent Failed".into()
6654        } else {
6655            "Spawning Agent…".into()
6656        };
6657
6658        let card_header_id = format!("subagent-header-{}", entry_ix);
6659        let status_icon = format!("status-icon-{}", entry_ix);
6660        let diff_stat_id = format!("subagent-diff-{}", entry_ix);
6661
6662        let icon = h_flex().w_4().justify_center().child(if is_running {
6663            SpinnerLabel::new()
6664                .size(LabelSize::Small)
6665                .into_any_element()
6666        } else if is_cancelled {
6667            div()
6668                .id(status_icon)
6669                .child(
6670                    Icon::new(IconName::Circle)
6671                        .size(IconSize::Small)
6672                        .color(Color::Custom(
6673                            cx.theme().colors().icon_disabled.opacity(0.5),
6674                        )),
6675                )
6676                .tooltip(Tooltip::text("Subagent Cancelled"))
6677                .into_any_element()
6678        } else if is_failed {
6679            div()
6680                .id(status_icon)
6681                .child(
6682                    Icon::new(IconName::Close)
6683                        .size(IconSize::Small)
6684                        .color(Color::Error),
6685                )
6686                .tooltip(Tooltip::text("Subagent Failed"))
6687                .into_any_element()
6688        } else {
6689            Icon::new(IconName::Check)
6690                .size(IconSize::Small)
6691                .color(Color::Success)
6692                .into_any_element()
6693        });
6694
6695        let has_expandable_content = thread
6696            .as_ref()
6697            .map_or(false, |thread| !thread.read(cx).entries().is_empty());
6698
6699        let tooltip_meta_description = if is_expanded {
6700            "Click to Collapse"
6701        } else {
6702            "Click to Preview"
6703        };
6704
6705        let error_message = self.subagent_error_message(&tool_call.status, tool_call, cx);
6706
6707        v_flex()
6708            .w_full()
6709            .rounded_md()
6710            .border_1()
6711            .when(has_no_title_or_canceled, |this| this.border_dashed())
6712            .border_color(self.tool_card_border_color(cx))
6713            .overflow_hidden()
6714            .child(
6715                h_flex()
6716                    .group(&card_header_id)
6717                    .h_8()
6718                    .p_1()
6719                    .w_full()
6720                    .justify_between()
6721                    .when(!has_no_title_or_canceled, |this| {
6722                        this.bg(self.tool_card_header_bg(cx))
6723                    })
6724                    .child(
6725                        h_flex()
6726                            .id(format!("subagent-title-{}", entry_ix))
6727                            .px_1()
6728                            .min_w_0()
6729                            .size_full()
6730                            .gap_2()
6731                            .justify_between()
6732                            .rounded_sm()
6733                            .overflow_hidden()
6734                            .child(
6735                                h_flex()
6736                                    .min_w_0()
6737                                    .w_full()
6738                                    .gap_1p5()
6739                                    .child(icon)
6740                                    .child(
6741                                        Label::new(title.to_string())
6742                                            .size(LabelSize::Custom(self.tool_name_font_size()))
6743                                            .truncate(),
6744                                    )
6745                                    .when(files_changed > 0, |this| {
6746                                        this.child(
6747                                            Label::new(format!(
6748                                                "— {} {} changed",
6749                                                files_changed,
6750                                                if files_changed == 1 { "file" } else { "files" }
6751                                            ))
6752                                            .size(LabelSize::Custom(self.tool_name_font_size()))
6753                                            .color(Color::Muted),
6754                                        )
6755                                        .child(
6756                                            DiffStat::new(
6757                                                diff_stat_id.clone(),
6758                                                diff_stats.lines_added as usize,
6759                                                diff_stats.lines_removed as usize,
6760                                            )
6761                                            .label_size(LabelSize::Custom(
6762                                                self.tool_name_font_size(),
6763                                            )),
6764                                        )
6765                                    }),
6766                            )
6767                            .when(!has_no_title_or_canceled && !is_pending_tool_call, |this| {
6768                                this.tooltip(move |_, cx| {
6769                                    Tooltip::with_meta(
6770                                        title.to_string(),
6771                                        None,
6772                                        tooltip_meta_description,
6773                                        cx,
6774                                    )
6775                                })
6776                            })
6777                            .when(has_expandable_content && !is_pending_tool_call, |this| {
6778                                this.cursor_pointer()
6779                                    .hover(|s| s.bg(cx.theme().colors().element_hover))
6780                                    .child(
6781                                        div().visible_on_hover(card_header_id).child(
6782                                            Icon::new(if is_expanded {
6783                                                IconName::ChevronUp
6784                                            } else {
6785                                                IconName::ChevronDown
6786                                            })
6787                                            .color(Color::Muted)
6788                                            .size(IconSize::Small),
6789                                        ),
6790                                    )
6791                                    .on_click(cx.listener({
6792                                        let tool_call_id = tool_call.id.clone();
6793                                        move |this, _, _, cx| {
6794                                            if this.expanded_tool_calls.contains(&tool_call_id) {
6795                                                this.expanded_tool_calls.remove(&tool_call_id);
6796                                            } else {
6797                                                this.expanded_tool_calls
6798                                                    .insert(tool_call_id.clone());
6799                                            }
6800                                            let expanded =
6801                                                this.expanded_tool_calls.contains(&tool_call_id);
6802                                            telemetry::event!("Subagent Toggled", expanded);
6803                                            cx.notify();
6804                                        }
6805                                    }))
6806                            }),
6807                    )
6808                    .when(is_running && subagent_session_id.is_some(), |buttons| {
6809                        buttons.child(
6810                            IconButton::new(format!("stop-subagent-{}", entry_ix), IconName::Stop)
6811                                .icon_size(IconSize::Small)
6812                                .icon_color(Color::Error)
6813                                .tooltip(Tooltip::text("Stop Subagent"))
6814                                .when_some(
6815                                    thread_view
6816                                        .as_ref()
6817                                        .map(|view| view.read(cx).thread.clone()),
6818                                    |this, thread| {
6819                                        this.on_click(cx.listener(
6820                                            move |_this, _event, _window, cx| {
6821                                                telemetry::event!("Subagent Stopped");
6822                                                thread.update(cx, |thread, cx| {
6823                                                    thread.cancel(cx).detach();
6824                                                });
6825                                            },
6826                                        ))
6827                                    },
6828                                ),
6829                        )
6830                    }),
6831            )
6832            .when_some(thread_view, |this, thread_view| {
6833                let thread = &thread_view.read(cx).thread;
6834                let pending_tool_call = self
6835                    .conversation
6836                    .read(cx)
6837                    .pending_tool_call(thread.read(cx).session_id(), cx);
6838
6839                let session_id = thread.read(cx).session_id().clone();
6840
6841                let fullscreen_toggle = h_flex()
6842                    .id(entry_ix)
6843                    .py_1()
6844                    .w_full()
6845                    .justify_center()
6846                    .border_t_1()
6847                    .when(is_failed, |this| this.border_dashed())
6848                    .border_color(self.tool_card_border_color(cx))
6849                    .cursor_pointer()
6850                    .hover(|s| s.bg(cx.theme().colors().element_hover))
6851                    .child(
6852                        Icon::new(IconName::Maximize)
6853                            .color(Color::Muted)
6854                            .size(IconSize::Small),
6855                    )
6856                    .tooltip(Tooltip::text("Make Subagent Full Screen"))
6857                    .on_click(cx.listener(move |this, _event, window, cx| {
6858                        telemetry::event!("Subagent Maximized");
6859                        this.server_view
6860                            .update(cx, |this, cx| {
6861                                this.navigate_to_session(session_id.clone(), window, cx);
6862                            })
6863                            .ok();
6864                    }));
6865
6866                if is_running && let Some((_, subagent_tool_call_id, _)) = pending_tool_call {
6867                    if let Some((entry_ix, tool_call)) =
6868                        thread.read(cx).tool_call(&subagent_tool_call_id)
6869                    {
6870                        this.child(Divider::horizontal().color(DividerColor::Border))
6871                            .child(thread_view.read(cx).render_any_tool_call(
6872                                active_session_id,
6873                                entry_ix,
6874                                tool_call,
6875                                focus_handle,
6876                                true,
6877                                window,
6878                                cx,
6879                            ))
6880                            .child(fullscreen_toggle)
6881                    } else {
6882                        this
6883                    }
6884                } else {
6885                    this.when(is_expanded, |this| {
6886                        this.child(self.render_subagent_expanded_content(
6887                            thread_view,
6888                            is_running,
6889                            tool_call,
6890                            window,
6891                            cx,
6892                        ))
6893                        .when_some(error_message, |this, message| {
6894                            this.child(
6895                                Callout::new()
6896                                    .severity(Severity::Error)
6897                                    .icon(IconName::XCircle)
6898                                    .title(message),
6899                            )
6900                        })
6901                        .child(fullscreen_toggle)
6902                    })
6903                }
6904            })
6905            .into_any_element()
6906    }
6907
6908    fn render_subagent_expanded_content(
6909        &self,
6910        thread_view: &Entity<ThreadView>,
6911        is_running: bool,
6912        tool_call: &ToolCall,
6913        window: &Window,
6914        cx: &Context<Self>,
6915    ) -> impl IntoElement {
6916        const MAX_PREVIEW_ENTRIES: usize = 8;
6917
6918        let subagent_view = thread_view.read(cx);
6919        let session_id = subagent_view.thread.read(cx).session_id().clone();
6920
6921        let is_canceled_or_failed = matches!(
6922            tool_call.status,
6923            ToolCallStatus::Canceled | ToolCallStatus::Failed | ToolCallStatus::Rejected
6924        );
6925
6926        let editor_bg = cx.theme().colors().editor_background;
6927        let overlay = {
6928            div()
6929                .absolute()
6930                .inset_0()
6931                .size_full()
6932                .bg(linear_gradient(
6933                    180.,
6934                    linear_color_stop(editor_bg.opacity(0.5), 0.),
6935                    linear_color_stop(editor_bg.opacity(0.), 0.1),
6936                ))
6937                .block_mouse_except_scroll()
6938        };
6939
6940        let entries = subagent_view.thread.read(cx).entries();
6941        let total_entries = entries.len();
6942        let mut entry_range = if let Some(info) = tool_call.subagent_session_info.as_ref() {
6943            info.message_start_index
6944                ..info
6945                    .message_end_index
6946                    .map(|i| (i + 1).min(total_entries))
6947                    .unwrap_or(total_entries)
6948        } else {
6949            0..total_entries
6950        };
6951        entry_range.start = entry_range
6952            .end
6953            .saturating_sub(MAX_PREVIEW_ENTRIES)
6954            .max(entry_range.start);
6955        let start_ix = entry_range.start;
6956
6957        let scroll_handle = self
6958            .subagent_scroll_handles
6959            .borrow_mut()
6960            .entry(session_id.clone())
6961            .or_default()
6962            .clone();
6963        if is_running {
6964            scroll_handle.scroll_to_bottom();
6965        }
6966
6967        let rendered_entries: Vec<AnyElement> = entries
6968            .get(entry_range)
6969            .unwrap_or_default()
6970            .iter()
6971            .enumerate()
6972            .map(|(i, entry)| {
6973                let actual_ix = start_ix + i;
6974                subagent_view.render_entry(actual_ix, total_entries, entry, window, cx)
6975            })
6976            .collect();
6977
6978        v_flex()
6979            .w_full()
6980            .border_t_1()
6981            .when(is_canceled_or_failed, |this| this.border_dashed())
6982            .border_color(self.tool_card_border_color(cx))
6983            .overflow_hidden()
6984            .child(
6985                div()
6986                    .pb_1()
6987                    .min_h_0()
6988                    .id(format!("subagent-entries-{}", session_id))
6989                    .track_scroll(&scroll_handle)
6990                    .children(rendered_entries),
6991            )
6992            .h_56()
6993            .child(overlay)
6994            .into_any_element()
6995    }
6996
6997    fn subagent_error_message(
6998        &self,
6999        status: &ToolCallStatus,
7000        tool_call: &ToolCall,
7001        cx: &App,
7002    ) -> Option<SharedString> {
7003        if matches!(status, ToolCallStatus::Failed) {
7004            tool_call.content.iter().find_map(|content| {
7005                if let ToolCallContent::ContentBlock(block) = content {
7006                    if let acp_thread::ContentBlock::Markdown { markdown } = block {
7007                        let source = markdown.read(cx).source().to_string();
7008                        if !source.is_empty() {
7009                            if source == "User canceled" {
7010                                return None;
7011                            } else {
7012                                return Some(SharedString::from(source));
7013                            }
7014                        }
7015                    }
7016                }
7017                None
7018            })
7019        } else {
7020            None
7021        }
7022    }
7023
7024    fn render_rules_item(&self, cx: &Context<Self>) -> Option<AnyElement> {
7025        let project_context = self
7026            .as_native_thread(cx)?
7027            .read(cx)
7028            .project_context()
7029            .read(cx);
7030
7031        let user_rules_text = if project_context.user_rules.is_empty() {
7032            None
7033        } else if project_context.user_rules.len() == 1 {
7034            let user_rules = &project_context.user_rules[0];
7035
7036            match user_rules.title.as_ref() {
7037                Some(title) => Some(format!("Using \"{title}\" user rule")),
7038                None => Some("Using user rule".into()),
7039            }
7040        } else {
7041            Some(format!(
7042                "Using {} user rules",
7043                project_context.user_rules.len()
7044            ))
7045        };
7046
7047        let first_user_rules_id = project_context
7048            .user_rules
7049            .first()
7050            .map(|user_rules| user_rules.uuid.0);
7051
7052        let rules_files = project_context
7053            .worktrees
7054            .iter()
7055            .filter_map(|worktree| worktree.rules_file.as_ref())
7056            .collect::<Vec<_>>();
7057
7058        let rules_file_text = match rules_files.as_slice() {
7059            &[] => None,
7060            &[rules_file] => Some(format!(
7061                "Using project {:?} file",
7062                rules_file.path_in_worktree
7063            )),
7064            rules_files => Some(format!("Using {} project rules files", rules_files.len())),
7065        };
7066
7067        if user_rules_text.is_none() && rules_file_text.is_none() {
7068            return None;
7069        }
7070
7071        let has_both = user_rules_text.is_some() && rules_file_text.is_some();
7072
7073        Some(
7074            h_flex()
7075                .px_2p5()
7076                .child(
7077                    Icon::new(IconName::Attach)
7078                        .size(IconSize::XSmall)
7079                        .color(Color::Disabled),
7080                )
7081                .when_some(user_rules_text, |parent, user_rules_text| {
7082                    parent.child(
7083                        h_flex()
7084                            .id("user-rules")
7085                            .ml_1()
7086                            .mr_1p5()
7087                            .child(
7088                                Label::new(user_rules_text)
7089                                    .size(LabelSize::XSmall)
7090                                    .color(Color::Muted)
7091                                    .truncate(),
7092                            )
7093                            .hover(|s| s.bg(cx.theme().colors().element_hover))
7094                            .tooltip(Tooltip::text("View User Rules"))
7095                            .on_click(move |_event, window, cx| {
7096                                window.dispatch_action(
7097                                    Box::new(OpenRulesLibrary {
7098                                        prompt_to_select: first_user_rules_id,
7099                                    }),
7100                                    cx,
7101                                )
7102                            }),
7103                    )
7104                })
7105                .when(has_both, |this| {
7106                    this.child(
7107                        Label::new("•")
7108                            .size(LabelSize::XSmall)
7109                            .color(Color::Disabled),
7110                    )
7111                })
7112                .when_some(rules_file_text, |parent, rules_file_text| {
7113                    parent.child(
7114                        h_flex()
7115                            .id("project-rules")
7116                            .ml_1p5()
7117                            .child(
7118                                Label::new(rules_file_text)
7119                                    .size(LabelSize::XSmall)
7120                                    .color(Color::Muted),
7121                            )
7122                            .hover(|s| s.bg(cx.theme().colors().element_hover))
7123                            .tooltip(Tooltip::text("View Project Rules"))
7124                            .on_click(cx.listener(Self::handle_open_rules)),
7125                    )
7126                })
7127                .into_any(),
7128        )
7129    }
7130
7131    fn tool_card_header_bg(&self, cx: &Context<Self>) -> Hsla {
7132        cx.theme()
7133            .colors()
7134            .element_background
7135            .blend(cx.theme().colors().editor_foreground.opacity(0.025))
7136    }
7137
7138    fn tool_card_border_color(&self, cx: &Context<Self>) -> Hsla {
7139        cx.theme().colors().border.opacity(0.8)
7140    }
7141
7142    fn tool_name_font_size(&self) -> Rems {
7143        rems_from_px(13.)
7144    }
7145
7146    pub(crate) fn render_thread_error(
7147        &mut self,
7148        window: &mut Window,
7149        cx: &mut Context<Self>,
7150    ) -> Option<Div> {
7151        let content = match self.thread_error.as_ref()? {
7152            ThreadError::Other { message, .. } => {
7153                self.render_any_thread_error(message.clone(), window, cx)
7154            }
7155            ThreadError::Refusal => self.render_refusal_error(cx),
7156            ThreadError::AuthenticationRequired(error) => {
7157                self.render_authentication_required_error(error.clone(), cx)
7158            }
7159            ThreadError::PaymentRequired => self.render_payment_required_error(cx),
7160        };
7161
7162        Some(div().child(content))
7163    }
7164
7165    fn render_refusal_error(&self, cx: &mut Context<'_, Self>) -> Callout {
7166        let model_or_agent_name = self.current_model_name(cx);
7167        let refusal_message = format!(
7168            "{} refused to respond to this prompt. \
7169            This can happen when a model believes the prompt violates its content policy \
7170            or safety guidelines, so rephrasing it can sometimes address the issue.",
7171            model_or_agent_name
7172        );
7173
7174        Callout::new()
7175            .severity(Severity::Error)
7176            .title("Request Refused")
7177            .icon(IconName::XCircle)
7178            .description(refusal_message.clone())
7179            .actions_slot(self.create_copy_button(&refusal_message))
7180            .dismiss_action(self.dismiss_error_button(cx))
7181    }
7182
7183    fn render_authentication_required_error(
7184        &self,
7185        error: SharedString,
7186        cx: &mut Context<Self>,
7187    ) -> Callout {
7188        Callout::new()
7189            .severity(Severity::Error)
7190            .title("Authentication Required")
7191            .icon(IconName::XCircle)
7192            .description(error.clone())
7193            .actions_slot(
7194                h_flex()
7195                    .gap_0p5()
7196                    .child(self.authenticate_button(cx))
7197                    .child(self.create_copy_button(error)),
7198            )
7199            .dismiss_action(self.dismiss_error_button(cx))
7200    }
7201
7202    fn render_payment_required_error(&self, cx: &mut Context<Self>) -> Callout {
7203        const ERROR_MESSAGE: &str =
7204            "You reached your free usage limit. Upgrade to Zed Pro for more prompts.";
7205
7206        Callout::new()
7207            .severity(Severity::Error)
7208            .icon(IconName::XCircle)
7209            .title("Free Usage Exceeded")
7210            .description(ERROR_MESSAGE)
7211            .actions_slot(
7212                h_flex()
7213                    .gap_0p5()
7214                    .child(self.upgrade_button(cx))
7215                    .child(self.create_copy_button(ERROR_MESSAGE)),
7216            )
7217            .dismiss_action(self.dismiss_error_button(cx))
7218    }
7219
7220    fn upgrade_button(&self, cx: &mut Context<Self>) -> impl IntoElement {
7221        Button::new("upgrade", "Upgrade")
7222            .label_size(LabelSize::Small)
7223            .style(ButtonStyle::Tinted(ui::TintColor::Accent))
7224            .on_click(cx.listener({
7225                move |this, _, _, cx| {
7226                    this.clear_thread_error(cx);
7227                    cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx));
7228                }
7229            }))
7230    }
7231
7232    fn authenticate_button(&self, cx: &mut Context<Self>) -> impl IntoElement {
7233        Button::new("authenticate", "Authenticate")
7234            .label_size(LabelSize::Small)
7235            .style(ButtonStyle::Filled)
7236            .on_click(cx.listener({
7237                move |this, _, window, cx| {
7238                    let server_view = this.server_view.clone();
7239                    let agent_name = this.agent_name.clone();
7240
7241                    this.clear_thread_error(cx);
7242                    if let Some(message) = this.in_flight_prompt.take() {
7243                        this.message_editor.update(cx, |editor, cx| {
7244                            editor.set_message(message, window, cx);
7245                        });
7246                    }
7247                    let connection = this.thread.read(cx).connection().clone();
7248                    window.defer(cx, |window, cx| {
7249                        ConnectionView::handle_auth_required(
7250                            server_view,
7251                            AuthRequired::new(),
7252                            agent_name,
7253                            connection,
7254                            window,
7255                            cx,
7256                        );
7257                    })
7258                }
7259            }))
7260    }
7261
7262    fn current_model_name(&self, cx: &App) -> SharedString {
7263        // For native agent (Zed Agent), use the specific model name (e.g., "Claude 3.5 Sonnet")
7264        // For ACP agents, use the agent name (e.g., "Claude Agent", "Gemini CLI")
7265        // This provides better clarity about what refused the request
7266        if self.as_native_connection(cx).is_some() {
7267            self.model_selector
7268                .clone()
7269                .and_then(|selector| selector.read(cx).active_model(cx))
7270                .map(|model| model.name.clone())
7271                .unwrap_or_else(|| SharedString::from("The model"))
7272        } else {
7273            // ACP agent - use the agent name (e.g., "Claude Agent", "Gemini CLI")
7274            self.agent_name.clone()
7275        }
7276    }
7277
7278    fn render_any_thread_error(
7279        &mut self,
7280        error: SharedString,
7281        window: &mut Window,
7282        cx: &mut Context<'_, Self>,
7283    ) -> Callout {
7284        let can_resume = self.thread.read(cx).can_retry(cx);
7285
7286        let markdown = if let Some(markdown) = &self.thread_error_markdown {
7287            markdown.clone()
7288        } else {
7289            let markdown = cx.new(|cx| Markdown::new(error.clone(), None, None, cx));
7290            self.thread_error_markdown = Some(markdown.clone());
7291            markdown
7292        };
7293
7294        let markdown_style =
7295            MarkdownStyle::themed(MarkdownFont::Agent, window, cx).with_muted_text(cx);
7296        let description = self
7297            .render_markdown(markdown, markdown_style)
7298            .into_any_element();
7299
7300        Callout::new()
7301            .severity(Severity::Error)
7302            .icon(IconName::XCircle)
7303            .title("An Error Happened")
7304            .description_slot(description)
7305            .actions_slot(
7306                h_flex()
7307                    .gap_0p5()
7308                    .when(can_resume, |this| {
7309                        this.child(
7310                            IconButton::new("retry", IconName::RotateCw)
7311                                .icon_size(IconSize::Small)
7312                                .tooltip(Tooltip::text("Retry Generation"))
7313                                .on_click(cx.listener(|this, _, _window, cx| {
7314                                    this.retry_generation(cx);
7315                                })),
7316                        )
7317                    })
7318                    .child(self.create_copy_button(error.to_string())),
7319            )
7320            .dismiss_action(self.dismiss_error_button(cx))
7321    }
7322
7323    fn render_markdown(&self, markdown: Entity<Markdown>, style: MarkdownStyle) -> MarkdownElement {
7324        let workspace = self.workspace.clone();
7325        MarkdownElement::new(markdown, style).on_url_click(move |text, window, cx| {
7326            open_link(text, &workspace, window, cx);
7327        })
7328    }
7329
7330    fn create_copy_button(&self, message: impl Into<String>) -> impl IntoElement {
7331        let message = message.into();
7332
7333        CopyButton::new("copy-error-message", message).tooltip_label("Copy Error Message")
7334    }
7335
7336    fn dismiss_error_button(&self, cx: &mut Context<Self>) -> impl IntoElement {
7337        IconButton::new("dismiss", IconName::Close)
7338            .icon_size(IconSize::Small)
7339            .tooltip(Tooltip::text("Dismiss"))
7340            .on_click(cx.listener({
7341                move |this, _, _, cx| {
7342                    this.clear_thread_error(cx);
7343                    cx.notify();
7344                }
7345            }))
7346    }
7347
7348    fn render_resume_notice(_cx: &Context<Self>) -> AnyElement {
7349        let description = "This agent does not support viewing previous messages. However, your session will still continue from where you last left off.";
7350
7351        div()
7352            .px_2()
7353            .pt_2()
7354            .pb_3()
7355            .w_full()
7356            .child(
7357                Callout::new()
7358                    .severity(Severity::Info)
7359                    .icon(IconName::Info)
7360                    .title("Resumed Session")
7361                    .description(description),
7362            )
7363            .into_any_element()
7364    }
7365
7366    fn update_recent_history_from_cache(
7367        &mut self,
7368        history: &Entity<ThreadHistory>,
7369        cx: &mut Context<Self>,
7370    ) {
7371        self.recent_history_entries = history.read(cx).get_recent_sessions(3);
7372        self.hovered_recent_history_item = None;
7373        cx.notify();
7374    }
7375
7376    fn render_empty_state_section_header(
7377        &self,
7378        label: impl Into<SharedString>,
7379        action_slot: Option<AnyElement>,
7380        cx: &mut Context<Self>,
7381    ) -> impl IntoElement {
7382        div().pl_1().pr_1p5().child(
7383            h_flex()
7384                .mt_2()
7385                .pl_1p5()
7386                .pb_1()
7387                .w_full()
7388                .justify_between()
7389                .border_b_1()
7390                .border_color(cx.theme().colors().border_variant)
7391                .child(
7392                    Label::new(label.into())
7393                        .size(LabelSize::Small)
7394                        .color(Color::Muted),
7395                )
7396                .children(action_slot),
7397        )
7398    }
7399
7400    fn render_recent_history(&self, cx: &mut Context<Self>) -> AnyElement {
7401        let render_history = !self.recent_history_entries.is_empty();
7402
7403        v_flex()
7404            .size_full()
7405            .when(render_history, |this| {
7406                let recent_history = self.recent_history_entries.clone();
7407                this.justify_end().child(
7408                    v_flex()
7409                        .child(
7410                            self.render_empty_state_section_header(
7411                                "Recent",
7412                                Some(
7413                                    Button::new("view-history", "View All")
7414                                        .style(ButtonStyle::Subtle)
7415                                        .label_size(LabelSize::Small)
7416                                        .key_binding(
7417                                            KeyBinding::for_action_in(
7418                                                &OpenHistory,
7419                                                &self.focus_handle(cx),
7420                                                cx,
7421                                            )
7422                                            .map(|kb| kb.size(rems_from_px(12.))),
7423                                        )
7424                                        .on_click(move |_event, window, cx| {
7425                                            window.dispatch_action(OpenHistory.boxed_clone(), cx);
7426                                        })
7427                                        .into_any_element(),
7428                                ),
7429                                cx,
7430                            ),
7431                        )
7432                        .child(v_flex().p_1().pr_1p5().gap_1().children({
7433                            let supports_delete = self.history.read(cx).supports_delete();
7434                            recent_history
7435                                .into_iter()
7436                                .enumerate()
7437                                .map(move |(index, entry)| {
7438                                    // TODO: Add keyboard navigation.
7439                                    let is_hovered =
7440                                        self.hovered_recent_history_item == Some(index);
7441                                    crate::thread_history::HistoryEntryElement::new(
7442                                        entry,
7443                                        self.server_view.clone(),
7444                                    )
7445                                    .hovered(is_hovered)
7446                                    .supports_delete(supports_delete)
7447                                    .on_hover(cx.listener(move |this, is_hovered, _window, cx| {
7448                                        if *is_hovered {
7449                                            this.hovered_recent_history_item = Some(index);
7450                                        } else if this.hovered_recent_history_item == Some(index) {
7451                                            this.hovered_recent_history_item = None;
7452                                        }
7453                                        cx.notify();
7454                                    }))
7455                                    .into_any_element()
7456                                })
7457                        })),
7458                )
7459            })
7460            .into_any()
7461    }
7462
7463    fn render_codex_windows_warning(&self, cx: &mut Context<Self>) -> Callout {
7464        Callout::new()
7465            .icon(IconName::Warning)
7466            .severity(Severity::Warning)
7467            .title("Codex on Windows")
7468            .description("For best performance, run Codex in Windows Subsystem for Linux (WSL2)")
7469            .actions_slot(
7470                Button::new("open-wsl-modal", "Open in WSL")
7471                    .icon_size(IconSize::Small)
7472                    .icon_color(Color::Muted)
7473                    .on_click(cx.listener({
7474                        move |_, _, _window, cx| {
7475                            #[cfg(windows)]
7476                            _window.dispatch_action(
7477                                zed_actions::wsl_actions::OpenWsl::default().boxed_clone(),
7478                                cx,
7479                            );
7480                            cx.notify();
7481                        }
7482                    })),
7483            )
7484            .dismiss_action(
7485                IconButton::new("dismiss", IconName::Close)
7486                    .icon_size(IconSize::Small)
7487                    .icon_color(Color::Muted)
7488                    .tooltip(Tooltip::text("Dismiss Warning"))
7489                    .on_click(cx.listener({
7490                        move |this, _, _, cx| {
7491                            this.show_codex_windows_warning = false;
7492                            cx.notify();
7493                        }
7494                    })),
7495            )
7496    }
7497
7498    fn render_external_source_prompt_warning(&self, cx: &mut Context<Self>) -> Callout {
7499        Callout::new()
7500            .icon(IconName::Warning)
7501            .severity(Severity::Warning)
7502            .title("Review before sending")
7503            .description("This prompt was pre-filled by an external link. Read it carefully before you send it.")
7504            .dismiss_action(
7505                IconButton::new("dismiss-external-source-prompt-warning", IconName::Close)
7506                    .icon_size(IconSize::Small)
7507                    .icon_color(Color::Muted)
7508                    .tooltip(Tooltip::text("Dismiss Warning"))
7509                    .on_click(cx.listener({
7510                        move |this, _, _, cx| {
7511                            this.show_external_source_prompt_warning = false;
7512                            cx.notify();
7513                        }
7514                    })),
7515            )
7516    }
7517
7518    fn render_new_version_callout(&self, version: &SharedString, cx: &mut Context<Self>) -> Div {
7519        let server_view = self.server_view.clone();
7520        v_flex().w_full().justify_end().child(
7521            h_flex()
7522                .p_2()
7523                .pr_3()
7524                .w_full()
7525                .gap_1p5()
7526                .border_t_1()
7527                .border_color(cx.theme().colors().border)
7528                .bg(cx.theme().colors().element_background)
7529                .child(
7530                    h_flex()
7531                        .flex_1()
7532                        .gap_1p5()
7533                        .child(
7534                            Icon::new(IconName::Download)
7535                                .color(Color::Accent)
7536                                .size(IconSize::Small),
7537                        )
7538                        .child(Label::new("New version available").size(LabelSize::Small)),
7539                )
7540                .child(
7541                    Button::new("update-button", format!("Update to v{}", version))
7542                        .label_size(LabelSize::Small)
7543                        .style(ButtonStyle::Tinted(TintColor::Accent))
7544                        .on_click(move |_, window, cx| {
7545                            server_view
7546                                .update(cx, |view, cx| view.reset(window, cx))
7547                                .ok();
7548                        }),
7549                ),
7550        )
7551    }
7552
7553    fn render_token_limit_callout(&self, cx: &mut Context<Self>) -> Option<Callout> {
7554        if self.token_limit_callout_dismissed {
7555            return None;
7556        }
7557
7558        let token_usage = self.thread.read(cx).token_usage()?;
7559        let ratio = token_usage.ratio();
7560
7561        let (severity, icon, title) = match ratio {
7562            acp_thread::TokenUsageRatio::Normal => return None,
7563            acp_thread::TokenUsageRatio::Warning => (
7564                Severity::Warning,
7565                IconName::Warning,
7566                "Thread reaching the token limit soon",
7567            ),
7568            acp_thread::TokenUsageRatio::Exceeded => (
7569                Severity::Error,
7570                IconName::XCircle,
7571                "Thread reached the token limit",
7572            ),
7573        };
7574
7575        let description = "To continue, start a new thread from a summary.";
7576
7577        Some(
7578            Callout::new()
7579                .severity(severity)
7580                .icon(icon)
7581                .title(title)
7582                .description(description)
7583                .actions_slot(
7584                    h_flex().gap_0p5().child(
7585                        Button::new("start-new-thread", "Start New Thread")
7586                            .label_size(LabelSize::Small)
7587                            .on_click(cx.listener(|this, _, window, cx| {
7588                                let session_id = this.thread.read(cx).session_id().clone();
7589                                window.dispatch_action(
7590                                    crate::NewNativeAgentThreadFromSummary {
7591                                        from_session_id: session_id,
7592                                    }
7593                                    .boxed_clone(),
7594                                    cx,
7595                                );
7596                            })),
7597                    ),
7598                )
7599                .dismiss_action(self.dismiss_error_button(cx)),
7600        )
7601    }
7602
7603    fn open_permission_dropdown(
7604        &mut self,
7605        _: &crate::OpenPermissionDropdown,
7606        window: &mut Window,
7607        cx: &mut Context<Self>,
7608    ) {
7609        self.permission_dropdown_handle.clone().toggle(window, cx);
7610    }
7611
7612    fn open_add_context_menu(
7613        &mut self,
7614        _action: &OpenAddContextMenu,
7615        window: &mut Window,
7616        cx: &mut Context<Self>,
7617    ) {
7618        let menu_handle = self.add_context_menu_handle.clone();
7619        window.defer(cx, move |window, cx| {
7620            menu_handle.toggle(window, cx);
7621        });
7622    }
7623
7624    fn toggle_fast_mode(&mut self, cx: &mut Context<Self>) {
7625        if !self.fast_mode_available(cx) {
7626            return;
7627        }
7628        let Some(thread) = self.as_native_thread(cx) else {
7629            return;
7630        };
7631        thread.update(cx, |thread, cx| {
7632            thread.set_speed(
7633                thread
7634                    .speed()
7635                    .map(|speed| speed.toggle())
7636                    .unwrap_or(Speed::Fast),
7637                cx,
7638            );
7639        });
7640    }
7641
7642    fn cycle_thinking_effort(&mut self, cx: &mut Context<Self>) {
7643        let Some(thread) = self.as_native_thread(cx) else {
7644            return;
7645        };
7646
7647        let (effort_levels, current_effort) = {
7648            let thread_ref = thread.read(cx);
7649            let Some(model) = thread_ref.model() else {
7650                return;
7651            };
7652            if !model.supports_thinking() || !thread_ref.thinking_enabled() {
7653                return;
7654            }
7655            let effort_levels = model.supported_effort_levels();
7656            if effort_levels.is_empty() {
7657                return;
7658            }
7659            let current_effort = thread_ref.thinking_effort().cloned();
7660            (effort_levels, current_effort)
7661        };
7662
7663        let current_index = current_effort.and_then(|current| {
7664            effort_levels
7665                .iter()
7666                .position(|level| level.value == current)
7667        });
7668        let next_index = match current_index {
7669            Some(index) => (index + 1) % effort_levels.len(),
7670            None => 0,
7671        };
7672        let next_effort = effort_levels[next_index].value.to_string();
7673
7674        thread.update(cx, |thread, cx| {
7675            thread.set_thinking_effort(Some(next_effort.clone()), cx);
7676
7677            let fs = thread.project().read(cx).fs().clone();
7678            update_settings_file(fs, cx, move |settings, _| {
7679                if let Some(agent) = settings.agent.as_mut()
7680                    && let Some(default_model) = agent.default_model.as_mut()
7681                {
7682                    default_model.effort = Some(next_effort);
7683                }
7684            });
7685        });
7686    }
7687
7688    fn toggle_thinking_effort_menu(
7689        &mut self,
7690        _action: &ToggleThinkingEffortMenu,
7691        window: &mut Window,
7692        cx: &mut Context<Self>,
7693    ) {
7694        let menu_handle = self.thinking_effort_menu_handle.clone();
7695        window.defer(cx, move |window, cx| {
7696            menu_handle.toggle(window, cx);
7697        });
7698    }
7699}
7700
7701impl Render for ThreadView {
7702    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
7703        let has_messages = self.list_state.item_count() > 0;
7704        let v2_empty_state = cx.has_flag::<AgentV2FeatureFlag>() && !has_messages;
7705
7706        let conversation = v_flex()
7707            .when(!v2_empty_state, |this| this.flex_1())
7708            .map(|this| {
7709                let this = this.when(self.resumed_without_history, |this| {
7710                    this.child(Self::render_resume_notice(cx))
7711                });
7712                if has_messages {
7713                    let list_state = self.list_state.clone();
7714                    this.child(self.render_entries(cx))
7715                        .vertical_scrollbar_for(&list_state, window, cx)
7716                        .into_any()
7717                } else if v2_empty_state {
7718                    this.into_any()
7719                } else {
7720                    this.child(self.render_recent_history(cx)).into_any()
7721                }
7722            });
7723
7724        v_flex()
7725            .key_context("AcpThread")
7726            .track_focus(&self.focus_handle)
7727            .on_action(cx.listener(|this, _: &menu::Cancel, _, cx| {
7728                if this.parent_id.is_none() {
7729                    this.cancel_generation(cx);
7730                }
7731            }))
7732            .on_action(cx.listener(|this, _: &workspace::GoBack, window, cx| {
7733                if let Some(parent_session_id) = this.parent_id.clone() {
7734                    this.server_view
7735                        .update(cx, |view, cx| {
7736                            view.navigate_to_session(parent_session_id, window, cx);
7737                        })
7738                        .ok();
7739                }
7740            }))
7741            .on_action(cx.listener(Self::keep_all))
7742            .on_action(cx.listener(Self::reject_all))
7743            .on_action(cx.listener(Self::undo_last_reject))
7744            .on_action(cx.listener(Self::allow_always))
7745            .on_action(cx.listener(Self::allow_once))
7746            .on_action(cx.listener(Self::reject_once))
7747            .on_action(cx.listener(Self::handle_authorize_tool_call))
7748            .on_action(cx.listener(Self::open_permission_dropdown))
7749            .on_action(cx.listener(Self::open_add_context_menu))
7750            .on_action(cx.listener(|this, _: &ToggleFastMode, _window, cx| {
7751                this.toggle_fast_mode(cx);
7752            }))
7753            .on_action(cx.listener(|this, _: &ToggleThinkingMode, _window, cx| {
7754                if let Some(thread) = this.as_native_thread(cx) {
7755                    thread.update(cx, |thread, cx| {
7756                        thread.set_thinking_enabled(!thread.thinking_enabled(), cx);
7757                    });
7758                }
7759            }))
7760            .on_action(cx.listener(|this, _: &CycleThinkingEffort, _window, cx| {
7761                this.cycle_thinking_effort(cx);
7762            }))
7763            .on_action(cx.listener(Self::toggle_thinking_effort_menu))
7764            .on_action(cx.listener(|this, _: &SendNextQueuedMessage, window, cx| {
7765                this.send_queued_message_at_index(0, true, window, cx);
7766            }))
7767            .on_action(cx.listener(|this, _: &RemoveFirstQueuedMessage, _, cx| {
7768                this.remove_from_queue(0, cx);
7769                cx.notify();
7770            }))
7771            .on_action(cx.listener(|this, _: &EditFirstQueuedMessage, window, cx| {
7772                this.move_queued_message_to_main_editor(0, None, window, cx);
7773            }))
7774            .on_action(cx.listener(|this, _: &ClearMessageQueue, _, cx| {
7775                this.local_queued_messages.clear();
7776                this.sync_queue_flag_to_native_thread(cx);
7777                this.can_fast_track_queue = false;
7778                cx.notify();
7779            }))
7780            .on_action(cx.listener(|this, _: &ToggleProfileSelector, window, cx| {
7781                if let Some(config_options_view) = this.config_options_view.clone() {
7782                    let handled = config_options_view.update(cx, |view, cx| {
7783                        view.toggle_category_picker(
7784                            acp::SessionConfigOptionCategory::Mode,
7785                            window,
7786                            cx,
7787                        )
7788                    });
7789                    if handled {
7790                        return;
7791                    }
7792                }
7793
7794                if let Some(profile_selector) = this.profile_selector.clone() {
7795                    profile_selector.read(cx).menu_handle().toggle(window, cx);
7796                } else if let Some(mode_selector) = this.mode_selector.clone() {
7797                    mode_selector.read(cx).menu_handle().toggle(window, cx);
7798                }
7799            }))
7800            .on_action(cx.listener(|this, _: &CycleModeSelector, window, cx| {
7801                if let Some(config_options_view) = this.config_options_view.clone() {
7802                    let handled = config_options_view.update(cx, |view, cx| {
7803                        view.cycle_category_option(
7804                            acp::SessionConfigOptionCategory::Mode,
7805                            false,
7806                            cx,
7807                        )
7808                    });
7809                    if handled {
7810                        return;
7811                    }
7812                }
7813
7814                if let Some(profile_selector) = this.profile_selector.clone() {
7815                    profile_selector.update(cx, |profile_selector, cx| {
7816                        profile_selector.cycle_profile(cx);
7817                    });
7818                } else if let Some(mode_selector) = this.mode_selector.clone() {
7819                    mode_selector.update(cx, |mode_selector, cx| {
7820                        mode_selector.cycle_mode(window, cx);
7821                    });
7822                }
7823            }))
7824            .on_action(cx.listener(|this, _: &ToggleModelSelector, window, cx| {
7825                if let Some(config_options_view) = this.config_options_view.clone() {
7826                    let handled = config_options_view.update(cx, |view, cx| {
7827                        view.toggle_category_picker(
7828                            acp::SessionConfigOptionCategory::Model,
7829                            window,
7830                            cx,
7831                        )
7832                    });
7833                    if handled {
7834                        return;
7835                    }
7836                }
7837
7838                if let Some(model_selector) = this.model_selector.clone() {
7839                    model_selector
7840                        .update(cx, |model_selector, cx| model_selector.toggle(window, cx));
7841                }
7842            }))
7843            .on_action(cx.listener(|this, _: &CycleFavoriteModels, window, cx| {
7844                if let Some(config_options_view) = this.config_options_view.clone() {
7845                    let handled = config_options_view.update(cx, |view, cx| {
7846                        view.cycle_category_option(
7847                            acp::SessionConfigOptionCategory::Model,
7848                            true,
7849                            cx,
7850                        )
7851                    });
7852                    if handled {
7853                        return;
7854                    }
7855                }
7856
7857                if let Some(model_selector) = this.model_selector.clone() {
7858                    model_selector.update(cx, |model_selector, cx| {
7859                        model_selector.cycle_favorite_models(window, cx);
7860                    });
7861                }
7862            }))
7863            .size_full()
7864            .children(self.render_subagent_titlebar(cx))
7865            .child(conversation)
7866            .children(self.render_activity_bar(window, cx))
7867            .when(self.show_external_source_prompt_warning, |this| {
7868                this.child(self.render_external_source_prompt_warning(cx))
7869            })
7870            .when(self.show_codex_windows_warning, |this| {
7871                this.child(self.render_codex_windows_warning(cx))
7872            })
7873            .children(self.render_thread_retry_status_callout())
7874            .children(self.render_thread_error(window, cx))
7875            .when_some(
7876                match has_messages {
7877                    true => None,
7878                    false => self.new_server_version_available.clone(),
7879                },
7880                |this, version| this.child(self.render_new_version_callout(&version, cx)),
7881            )
7882            .children(self.render_token_limit_callout(cx))
7883            .child(self.render_message_editor(window, cx))
7884    }
7885}
7886
7887pub(crate) fn open_link(
7888    url: SharedString,
7889    workspace: &WeakEntity<Workspace>,
7890    window: &mut Window,
7891    cx: &mut App,
7892) {
7893    let Some(workspace) = workspace.upgrade() else {
7894        cx.open_url(&url);
7895        return;
7896    };
7897
7898    if let Some(mention) = MentionUri::parse(&url, workspace.read(cx).path_style(cx)).log_err() {
7899        workspace.update(cx, |workspace, cx| match mention {
7900            MentionUri::File { abs_path } => {
7901                let project = workspace.project();
7902                let Some(path) =
7903                    project.update(cx, |project, cx| project.find_project_path(abs_path, cx))
7904                else {
7905                    return;
7906                };
7907
7908                workspace
7909                    .open_path(path, None, true, window, cx)
7910                    .detach_and_log_err(cx);
7911            }
7912            MentionUri::PastedImage => {}
7913            MentionUri::Directory { abs_path } => {
7914                let project = workspace.project();
7915                let Some(entry_id) = project.update(cx, |project, cx| {
7916                    let path = project.find_project_path(abs_path, cx)?;
7917                    project.entry_for_path(&path, cx).map(|entry| entry.id)
7918                }) else {
7919                    return;
7920                };
7921
7922                project.update(cx, |_, cx| {
7923                    cx.emit(project::Event::RevealInProjectPanel(entry_id));
7924                });
7925            }
7926            MentionUri::Symbol {
7927                abs_path: path,
7928                line_range,
7929                ..
7930            }
7931            | MentionUri::Selection {
7932                abs_path: Some(path),
7933                line_range,
7934            } => {
7935                let project = workspace.project();
7936                let Some(path) =
7937                    project.update(cx, |project, cx| project.find_project_path(path, cx))
7938                else {
7939                    return;
7940                };
7941
7942                let item = workspace.open_path(path, None, true, window, cx);
7943                window
7944                    .spawn(cx, async move |cx| {
7945                        let Some(editor) = item.await?.downcast::<Editor>() else {
7946                            return Ok(());
7947                        };
7948                        let range =
7949                            Point::new(*line_range.start(), 0)..Point::new(*line_range.start(), 0);
7950                        editor
7951                            .update_in(cx, |editor, window, cx| {
7952                                editor.change_selections(
7953                                    SelectionEffects::scroll(Autoscroll::center()),
7954                                    window,
7955                                    cx,
7956                                    |s| s.select_ranges(vec![range]),
7957                                );
7958                            })
7959                            .ok();
7960                        anyhow::Ok(())
7961                    })
7962                    .detach_and_log_err(cx);
7963            }
7964            MentionUri::Selection { abs_path: None, .. } => {}
7965            MentionUri::Thread { id, name } => {
7966                if let Some(panel) = workspace.panel::<AgentPanel>(cx) {
7967                    panel.update(cx, |panel, cx| {
7968                        panel.open_thread(id, None, Some(name.into()), window, cx)
7969                    });
7970                }
7971            }
7972            MentionUri::TextThread { path, .. } => {
7973                if let Some(panel) = workspace.panel::<AgentPanel>(cx) {
7974                    panel.update(cx, |panel, cx| {
7975                        panel
7976                            .open_saved_text_thread(path.as_path().into(), window, cx)
7977                            .detach_and_log_err(cx);
7978                    });
7979                }
7980            }
7981            MentionUri::Rule { id, .. } => {
7982                let PromptId::User { uuid } = id else {
7983                    return;
7984                };
7985                window.dispatch_action(
7986                    Box::new(OpenRulesLibrary {
7987                        prompt_to_select: Some(uuid.0),
7988                    }),
7989                    cx,
7990                )
7991            }
7992            MentionUri::Fetch { url } => {
7993                cx.open_url(url.as_str());
7994            }
7995            MentionUri::Diagnostics { .. } => {}
7996            MentionUri::TerminalSelection { .. } => {}
7997            MentionUri::GitDiff { .. } => {}
7998        })
7999    } else {
8000        cx.open_url(&url);
8001    }
8002}