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