1use crate::AssistantPanel;
2use crate::context::{AssistantContext, ContextId};
3use crate::context_picker::MentionLink;
4use crate::thread::{
5 LastRestoreCheckpoint, MessageId, MessageSegment, RequestKind, Thread, ThreadError,
6 ThreadEvent, ThreadFeedback,
7};
8use crate::thread_store::ThreadStore;
9use crate::tool_use::{PendingToolUseStatus, ToolUse, ToolUseStatus};
10use crate::ui::{AddedContext, AgentNotification, AgentNotificationEvent, ContextPill};
11use anyhow::Context as _;
12use assistant_settings::{AssistantSettings, NotifyWhenAgentWaiting};
13use collections::HashMap;
14use editor::scroll::Autoscroll;
15use editor::{Editor, MultiBuffer};
16use gpui::{
17 AbsoluteLength, Animation, AnimationExt, AnyElement, App, ClickEvent, DefiniteLength,
18 EdgesRefinement, Empty, Entity, Focusable, Hsla, Length, ListAlignment, ListState, MouseButton,
19 PlatformDisplay, ScrollHandle, Stateful, StyleRefinement, Subscription, Task,
20 TextStyleRefinement, Transformation, UnderlineStyle, WeakEntity, WindowHandle,
21 linear_color_stop, linear_gradient, list, percentage, pulsating_between,
22};
23use language::{Buffer, LanguageRegistry};
24use language_model::{ConfiguredModel, LanguageModelRegistry, LanguageModelToolUseId, Role};
25use markdown::{Markdown, MarkdownStyle};
26use project::ProjectItem as _;
27use settings::{Settings as _, update_settings_file};
28use std::rc::Rc;
29use std::sync::Arc;
30use std::time::Duration;
31use text::ToPoint;
32use theme::ThemeSettings;
33use ui::{Disclosure, IconButton, KeyBinding, Scrollbar, ScrollbarState, Tooltip, prelude::*};
34use util::ResultExt as _;
35use workspace::{OpenOptions, Workspace};
36
37use crate::context_store::ContextStore;
38
39pub struct ActiveThread {
40 language_registry: Arc<LanguageRegistry>,
41 thread_store: Entity<ThreadStore>,
42 thread: Entity<Thread>,
43 context_store: Entity<ContextStore>,
44 workspace: WeakEntity<Workspace>,
45 save_thread_task: Option<Task<()>>,
46 messages: Vec<MessageId>,
47 list_state: ListState,
48 scrollbar_state: ScrollbarState,
49 rendered_messages_by_id: HashMap<MessageId, RenderedMessage>,
50 rendered_tool_use_labels: HashMap<LanguageModelToolUseId, Entity<Markdown>>,
51 editing_message: Option<(MessageId, EditMessageState)>,
52 expanded_tool_uses: HashMap<LanguageModelToolUseId, bool>,
53 expanded_thinking_segments: HashMap<(MessageId, usize), bool>,
54 last_error: Option<ThreadError>,
55 notifications: Vec<WindowHandle<AgentNotification>>,
56 _subscriptions: Vec<Subscription>,
57 notification_subscriptions: HashMap<WindowHandle<AgentNotification>, Vec<Subscription>>,
58 feedback_message_editor: Option<Entity<Editor>>,
59}
60
61struct RenderedMessage {
62 language_registry: Arc<LanguageRegistry>,
63 segments: Vec<RenderedMessageSegment>,
64}
65
66impl RenderedMessage {
67 fn from_segments(
68 segments: &[MessageSegment],
69 language_registry: Arc<LanguageRegistry>,
70 workspace: WeakEntity<Workspace>,
71 window: &Window,
72 cx: &mut App,
73 ) -> Self {
74 let mut this = Self {
75 language_registry,
76 segments: Vec::with_capacity(segments.len()),
77 };
78 for segment in segments {
79 this.push_segment(segment, workspace.clone(), window, cx);
80 }
81 this
82 }
83
84 fn append_thinking(
85 &mut self,
86 text: &String,
87 workspace: WeakEntity<Workspace>,
88 window: &Window,
89 cx: &mut App,
90 ) {
91 if let Some(RenderedMessageSegment::Thinking {
92 content,
93 scroll_handle,
94 }) = self.segments.last_mut()
95 {
96 content.update(cx, |markdown, cx| {
97 markdown.append(text, cx);
98 });
99 scroll_handle.scroll_to_bottom();
100 } else {
101 self.segments.push(RenderedMessageSegment::Thinking {
102 content: render_markdown(
103 text.into(),
104 self.language_registry.clone(),
105 workspace,
106 window,
107 cx,
108 ),
109 scroll_handle: ScrollHandle::default(),
110 });
111 }
112 }
113
114 fn append_text(
115 &mut self,
116 text: &String,
117 workspace: WeakEntity<Workspace>,
118 window: &Window,
119 cx: &mut App,
120 ) {
121 if let Some(RenderedMessageSegment::Text(markdown)) = self.segments.last_mut() {
122 markdown.update(cx, |markdown, cx| markdown.append(text, cx));
123 } else {
124 self.segments
125 .push(RenderedMessageSegment::Text(render_markdown(
126 SharedString::from(text),
127 self.language_registry.clone(),
128 workspace,
129 window,
130 cx,
131 )));
132 }
133 }
134
135 fn push_segment(
136 &mut self,
137 segment: &MessageSegment,
138 workspace: WeakEntity<Workspace>,
139 window: &Window,
140 cx: &mut App,
141 ) {
142 let rendered_segment = match segment {
143 MessageSegment::Thinking(text) => RenderedMessageSegment::Thinking {
144 content: render_markdown(
145 text.into(),
146 self.language_registry.clone(),
147 workspace,
148 window,
149 cx,
150 ),
151 scroll_handle: ScrollHandle::default(),
152 },
153 MessageSegment::Text(text) => RenderedMessageSegment::Text(render_markdown(
154 text.into(),
155 self.language_registry.clone(),
156 workspace,
157 window,
158 cx,
159 )),
160 };
161 self.segments.push(rendered_segment);
162 }
163}
164
165enum RenderedMessageSegment {
166 Thinking {
167 content: Entity<Markdown>,
168 scroll_handle: ScrollHandle,
169 },
170 Text(Entity<Markdown>),
171}
172
173fn render_markdown(
174 text: SharedString,
175 language_registry: Arc<LanguageRegistry>,
176 workspace: WeakEntity<Workspace>,
177 window: &Window,
178 cx: &mut App,
179) -> Entity<Markdown> {
180 let theme_settings = ThemeSettings::get_global(cx);
181 let colors = cx.theme().colors();
182 let ui_font_size = TextSize::Default.rems(cx);
183 let buffer_font_size = TextSize::Small.rems(cx);
184 let mut text_style = window.text_style();
185
186 text_style.refine(&TextStyleRefinement {
187 font_family: Some(theme_settings.ui_font.family.clone()),
188 font_fallbacks: theme_settings.ui_font.fallbacks.clone(),
189 font_features: Some(theme_settings.ui_font.features.clone()),
190 font_size: Some(ui_font_size.into()),
191 color: Some(cx.theme().colors().text),
192 ..Default::default()
193 });
194
195 let markdown_style = MarkdownStyle {
196 base_text_style: text_style,
197 syntax: cx.theme().syntax().clone(),
198 selection_background_color: cx.theme().players().local().selection,
199 code_block_overflow_x_scroll: true,
200 table_overflow_x_scroll: true,
201 code_block: StyleRefinement {
202 margin: EdgesRefinement {
203 top: Some(Length::Definite(rems(0.).into())),
204 left: Some(Length::Definite(rems(0.).into())),
205 right: Some(Length::Definite(rems(0.).into())),
206 bottom: Some(Length::Definite(rems(0.5).into())),
207 },
208 padding: EdgesRefinement {
209 top: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(Pixels(8.)))),
210 left: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(Pixels(8.)))),
211 right: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(Pixels(8.)))),
212 bottom: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(Pixels(8.)))),
213 },
214 background: Some(colors.editor_background.into()),
215 border_color: Some(colors.border_variant),
216 border_widths: EdgesRefinement {
217 top: Some(AbsoluteLength::Pixels(Pixels(1.))),
218 left: Some(AbsoluteLength::Pixels(Pixels(1.))),
219 right: Some(AbsoluteLength::Pixels(Pixels(1.))),
220 bottom: Some(AbsoluteLength::Pixels(Pixels(1.))),
221 },
222 text: Some(TextStyleRefinement {
223 font_family: Some(theme_settings.buffer_font.family.clone()),
224 font_fallbacks: theme_settings.buffer_font.fallbacks.clone(),
225 font_features: Some(theme_settings.buffer_font.features.clone()),
226 font_size: Some(buffer_font_size.into()),
227 ..Default::default()
228 }),
229 ..Default::default()
230 },
231 inline_code: TextStyleRefinement {
232 font_family: Some(theme_settings.buffer_font.family.clone()),
233 font_fallbacks: theme_settings.buffer_font.fallbacks.clone(),
234 font_features: Some(theme_settings.buffer_font.features.clone()),
235 font_size: Some(buffer_font_size.into()),
236 background_color: Some(colors.editor_foreground.opacity(0.1)),
237 ..Default::default()
238 },
239 link: TextStyleRefinement {
240 background_color: Some(colors.editor_foreground.opacity(0.025)),
241 underline: Some(UnderlineStyle {
242 color: Some(colors.text_accent.opacity(0.5)),
243 thickness: px(1.),
244 ..Default::default()
245 }),
246 ..Default::default()
247 },
248 link_callback: Some(Rc::new(move |url, cx| {
249 if MentionLink::is_valid(url) {
250 let colors = cx.theme().colors();
251 Some(TextStyleRefinement {
252 background_color: Some(colors.element_background),
253 ..Default::default()
254 })
255 } else {
256 None
257 }
258 })),
259 ..Default::default()
260 };
261
262 cx.new(|cx| {
263 Markdown::new(text, markdown_style, Some(language_registry), None, cx).open_url(
264 move |text, window, cx| {
265 open_markdown_link(text, workspace.clone(), window, cx);
266 },
267 )
268 })
269}
270
271fn open_markdown_link(
272 text: SharedString,
273 workspace: WeakEntity<Workspace>,
274 window: &mut Window,
275 cx: &mut App,
276) {
277 let Some(workspace) = workspace.upgrade() else {
278 cx.open_url(&text);
279 return;
280 };
281
282 match MentionLink::try_parse(&text, &workspace, cx) {
283 Some(MentionLink::File(path, entry)) => workspace.update(cx, |workspace, cx| {
284 if entry.is_dir() {
285 workspace.project().update(cx, |_, cx| {
286 cx.emit(project::Event::RevealInProjectPanel(entry.id));
287 })
288 } else {
289 workspace
290 .open_path(path, None, true, window, cx)
291 .detach_and_log_err(cx);
292 }
293 }),
294 Some(MentionLink::Symbol(path, symbol_name)) => {
295 let open_task = workspace.update(cx, |workspace, cx| {
296 workspace.open_path(path, None, true, window, cx)
297 });
298 window
299 .spawn(cx, async move |cx| {
300 let active_editor = open_task
301 .await?
302 .downcast::<Editor>()
303 .context("Item is not an editor")?;
304 active_editor.update_in(cx, |editor, window, cx| {
305 let symbol_range = editor
306 .buffer()
307 .read(cx)
308 .snapshot(cx)
309 .outline(None)
310 .and_then(|outline| {
311 outline
312 .find_most_similar(&symbol_name)
313 .map(|(_, item)| item.range.clone())
314 })
315 .context("Could not find matching symbol")?;
316
317 editor.change_selections(Some(Autoscroll::center()), window, cx, |s| {
318 s.select_anchor_ranges([symbol_range.start..symbol_range.start])
319 });
320 anyhow::Ok(())
321 })
322 })
323 .detach_and_log_err(cx);
324 }
325 Some(MentionLink::Thread(thread_id)) => workspace.update(cx, |workspace, cx| {
326 if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
327 panel.update(cx, |panel, cx| {
328 panel
329 .open_thread(&thread_id, window, cx)
330 .detach_and_log_err(cx)
331 });
332 }
333 }),
334 Some(MentionLink::Fetch(url)) => cx.open_url(&url),
335 None => cx.open_url(&text),
336 }
337}
338
339struct EditMessageState {
340 editor: Entity<Editor>,
341}
342
343impl ActiveThread {
344 pub fn new(
345 thread: Entity<Thread>,
346 thread_store: Entity<ThreadStore>,
347 language_registry: Arc<LanguageRegistry>,
348 context_store: Entity<ContextStore>,
349 workspace: WeakEntity<Workspace>,
350 window: &mut Window,
351 cx: &mut Context<Self>,
352 ) -> Self {
353 let subscriptions = vec![
354 cx.observe(&thread, |_, _, cx| cx.notify()),
355 cx.subscribe_in(&thread, window, Self::handle_thread_event),
356 ];
357
358 let list_state = ListState::new(0, ListAlignment::Bottom, px(2048.), {
359 let this = cx.entity().downgrade();
360 move |ix, window: &mut Window, cx: &mut App| {
361 this.update(cx, |this, cx| this.render_message(ix, window, cx))
362 .unwrap()
363 }
364 });
365
366 let mut this = Self {
367 language_registry,
368 thread_store,
369 thread: thread.clone(),
370 context_store,
371 workspace,
372 save_thread_task: None,
373 messages: Vec::new(),
374 rendered_messages_by_id: HashMap::default(),
375 rendered_tool_use_labels: HashMap::default(),
376 expanded_tool_uses: HashMap::default(),
377 expanded_thinking_segments: HashMap::default(),
378 list_state: list_state.clone(),
379 scrollbar_state: ScrollbarState::new(list_state),
380 editing_message: None,
381 last_error: None,
382 notifications: Vec::new(),
383 _subscriptions: subscriptions,
384 notification_subscriptions: HashMap::default(),
385 feedback_message_editor: None,
386 };
387
388 for message in thread.read(cx).messages().cloned().collect::<Vec<_>>() {
389 this.push_message(&message.id, &message.segments, window, cx);
390
391 for tool_use in thread.read(cx).tool_uses_for_message(message.id, cx) {
392 this.render_tool_use_label_markdown(
393 tool_use.id.clone(),
394 tool_use.ui_text.clone(),
395 window,
396 cx,
397 );
398 }
399 }
400
401 this
402 }
403
404 pub fn thread(&self) -> &Entity<Thread> {
405 &self.thread
406 }
407
408 pub fn is_empty(&self) -> bool {
409 self.messages.is_empty()
410 }
411
412 pub fn summary(&self, cx: &App) -> Option<SharedString> {
413 self.thread.read(cx).summary()
414 }
415
416 pub fn summary_or_default(&self, cx: &App) -> SharedString {
417 self.thread.read(cx).summary_or_default()
418 }
419
420 pub fn cancel_last_completion(&mut self, cx: &mut App) -> bool {
421 self.last_error.take();
422 self.thread
423 .update(cx, |thread, cx| thread.cancel_last_completion(cx))
424 }
425
426 pub fn last_error(&self) -> Option<ThreadError> {
427 self.last_error.clone()
428 }
429
430 pub fn clear_last_error(&mut self) {
431 self.last_error.take();
432 }
433
434 fn push_message(
435 &mut self,
436 id: &MessageId,
437 segments: &[MessageSegment],
438 window: &mut Window,
439 cx: &mut Context<Self>,
440 ) {
441 let old_len = self.messages.len();
442 self.messages.push(*id);
443 self.list_state.splice(old_len..old_len, 1);
444
445 let rendered_message = RenderedMessage::from_segments(
446 segments,
447 self.language_registry.clone(),
448 self.workspace.clone(),
449 window,
450 cx,
451 );
452 self.rendered_messages_by_id.insert(*id, rendered_message);
453 }
454
455 fn edited_message(
456 &mut self,
457 id: &MessageId,
458 segments: &[MessageSegment],
459 window: &mut Window,
460 cx: &mut Context<Self>,
461 ) {
462 let Some(index) = self.messages.iter().position(|message_id| message_id == id) else {
463 return;
464 };
465 self.list_state.splice(index..index + 1, 1);
466 let rendered_message = RenderedMessage::from_segments(
467 segments,
468 self.language_registry.clone(),
469 self.workspace.clone(),
470 window,
471 cx,
472 );
473 self.rendered_messages_by_id.insert(*id, rendered_message);
474 }
475
476 fn deleted_message(&mut self, id: &MessageId) {
477 let Some(index) = self.messages.iter().position(|message_id| message_id == id) else {
478 return;
479 };
480 self.messages.remove(index);
481 self.list_state.splice(index..index + 1, 0);
482 self.rendered_messages_by_id.remove(id);
483 }
484
485 fn render_tool_use_label_markdown(
486 &mut self,
487 tool_use_id: LanguageModelToolUseId,
488 tool_label: impl Into<SharedString>,
489 window: &mut Window,
490 cx: &mut Context<Self>,
491 ) {
492 self.rendered_tool_use_labels.insert(
493 tool_use_id,
494 render_markdown(
495 tool_label.into(),
496 self.language_registry.clone(),
497 self.workspace.clone(),
498 window,
499 cx,
500 ),
501 );
502 }
503
504 fn handle_thread_event(
505 &mut self,
506 _thread: &Entity<Thread>,
507 event: &ThreadEvent,
508 window: &mut Window,
509 cx: &mut Context<Self>,
510 ) {
511 match event {
512 ThreadEvent::ShowError(error) => {
513 self.last_error = Some(error.clone());
514 }
515 ThreadEvent::StreamedCompletion
516 | ThreadEvent::SummaryGenerated
517 | ThreadEvent::SummaryChanged => {
518 self.save_thread(cx);
519 }
520 ThreadEvent::DoneStreaming => {
521 let thread = self.thread.read(cx);
522
523 if !thread.is_generating() {
524 self.show_notification(
525 if thread.used_tools_since_last_user_message() {
526 "Finished running tools"
527 } else {
528 "New message"
529 },
530 IconName::ZedAssistant,
531 window,
532 cx,
533 );
534 }
535 }
536 ThreadEvent::ToolConfirmationNeeded => {
537 self.show_notification("Waiting for tool confirmation", IconName::Info, window, cx);
538 }
539 ThreadEvent::StreamedAssistantText(message_id, text) => {
540 if let Some(rendered_message) = self.rendered_messages_by_id.get_mut(&message_id) {
541 rendered_message.append_text(text, self.workspace.clone(), window, cx);
542 }
543 }
544 ThreadEvent::StreamedAssistantThinking(message_id, text) => {
545 if let Some(rendered_message) = self.rendered_messages_by_id.get_mut(&message_id) {
546 rendered_message.append_thinking(text, self.workspace.clone(), window, cx);
547 }
548 }
549 ThreadEvent::MessageAdded(message_id) => {
550 if let Some(message_segments) = self
551 .thread
552 .read(cx)
553 .message(*message_id)
554 .map(|message| message.segments.clone())
555 {
556 self.push_message(message_id, &message_segments, window, cx);
557 }
558
559 self.save_thread(cx);
560 cx.notify();
561 }
562 ThreadEvent::MessageEdited(message_id) => {
563 if let Some(message_segments) = self
564 .thread
565 .read(cx)
566 .message(*message_id)
567 .map(|message| message.segments.clone())
568 {
569 self.edited_message(message_id, &message_segments, window, cx);
570 }
571
572 self.save_thread(cx);
573 cx.notify();
574 }
575 ThreadEvent::MessageDeleted(message_id) => {
576 self.deleted_message(message_id);
577 self.save_thread(cx);
578 cx.notify();
579 }
580 ThreadEvent::UsePendingTools => {
581 let tool_uses = self
582 .thread
583 .update(cx, |thread, cx| thread.use_pending_tools(cx));
584
585 for tool_use in tool_uses {
586 self.render_tool_use_label_markdown(
587 tool_use.id.clone(),
588 tool_use.ui_text.clone(),
589 window,
590 cx,
591 );
592 }
593 }
594 ThreadEvent::ToolFinished {
595 pending_tool_use,
596 canceled,
597 ..
598 } => {
599 let canceled = *canceled;
600 if let Some(tool_use) = pending_tool_use {
601 self.render_tool_use_label_markdown(
602 tool_use.id.clone(),
603 SharedString::from(tool_use.ui_text.clone()),
604 window,
605 cx,
606 );
607 }
608
609 if self.thread.read(cx).all_tools_finished() {
610 let model_registry = LanguageModelRegistry::read_global(cx);
611 if let Some(ConfiguredModel { model, .. }) = model_registry.default_model() {
612 self.thread.update(cx, |thread, cx| {
613 thread.attach_tool_results(cx);
614 if !canceled {
615 thread.send_to_model(model, RequestKind::Chat, cx);
616 }
617 });
618 }
619 }
620 }
621 ThreadEvent::CheckpointChanged => cx.notify(),
622 }
623 }
624
625 fn show_notification(
626 &mut self,
627 caption: impl Into<SharedString>,
628 icon: IconName,
629 window: &mut Window,
630 cx: &mut Context<ActiveThread>,
631 ) {
632 if window.is_window_active() || !self.notifications.is_empty() {
633 return;
634 }
635
636 let title = self
637 .thread
638 .read(cx)
639 .summary()
640 .unwrap_or("Agent Panel".into());
641
642 match AssistantSettings::get_global(cx).notify_when_agent_waiting {
643 NotifyWhenAgentWaiting::PrimaryScreen => {
644 if let Some(primary) = cx.primary_display() {
645 self.pop_up(icon, caption.into(), title.clone(), window, primary, cx);
646 }
647 }
648 NotifyWhenAgentWaiting::AllScreens => {
649 let caption = caption.into();
650 for screen in cx.displays() {
651 self.pop_up(icon, caption.clone(), title.clone(), window, screen, cx);
652 }
653 }
654 NotifyWhenAgentWaiting::Never => {
655 // Don't show anything
656 }
657 }
658 }
659
660 fn pop_up(
661 &mut self,
662 icon: IconName,
663 caption: SharedString,
664 title: SharedString,
665 window: &mut Window,
666 screen: Rc<dyn PlatformDisplay>,
667 cx: &mut Context<'_, ActiveThread>,
668 ) {
669 let options = AgentNotification::window_options(screen, cx);
670
671 if let Some(screen_window) = cx
672 .open_window(options, |_, cx| {
673 cx.new(|_| AgentNotification::new(title.clone(), caption.clone(), icon))
674 })
675 .log_err()
676 {
677 if let Some(pop_up) = screen_window.entity(cx).log_err() {
678 self.notification_subscriptions
679 .entry(screen_window)
680 .or_insert_with(Vec::new)
681 .push(cx.subscribe_in(&pop_up, window, {
682 |this, _, event, window, cx| match event {
683 AgentNotificationEvent::Accepted => {
684 let handle = window.window_handle();
685 cx.activate(true); // Switch back to the Zed application
686
687 let workspace_handle = this.workspace.clone();
688
689 // If there are multiple Zed windows, activate the correct one.
690 cx.defer(move |cx| {
691 handle
692 .update(cx, |_view, window, _cx| {
693 window.activate_window();
694
695 if let Some(workspace) = workspace_handle.upgrade() {
696 workspace.update(_cx, |workspace, cx| {
697 workspace
698 .focus_panel::<AssistantPanel>(window, cx);
699 });
700 }
701 })
702 .log_err();
703 });
704
705 this.dismiss_notifications(cx);
706 }
707 AgentNotificationEvent::Dismissed => {
708 this.dismiss_notifications(cx);
709 }
710 }
711 }));
712
713 self.notifications.push(screen_window);
714
715 // If the user manually refocuses the original window, dismiss the popup.
716 self.notification_subscriptions
717 .entry(screen_window)
718 .or_insert_with(Vec::new)
719 .push({
720 let pop_up_weak = pop_up.downgrade();
721
722 cx.observe_window_activation(window, move |_, window, cx| {
723 if window.is_window_active() {
724 if let Some(pop_up) = pop_up_weak.upgrade() {
725 pop_up.update(cx, |_, cx| {
726 cx.emit(AgentNotificationEvent::Dismissed);
727 });
728 }
729 }
730 })
731 });
732 }
733 }
734 }
735
736 /// Spawns a task to save the active thread.
737 ///
738 /// Only one task to save the thread will be in flight at a time.
739 fn save_thread(&mut self, cx: &mut Context<Self>) {
740 let thread = self.thread.clone();
741 self.save_thread_task = Some(cx.spawn(async move |this, cx| {
742 let task = this
743 .update(cx, |this, cx| {
744 this.thread_store
745 .update(cx, |thread_store, cx| thread_store.save_thread(&thread, cx))
746 })
747 .ok();
748
749 if let Some(task) = task {
750 task.await.log_err();
751 }
752 }));
753 }
754
755 fn start_editing_message(
756 &mut self,
757 message_id: MessageId,
758 message_segments: &[MessageSegment],
759 window: &mut Window,
760 cx: &mut Context<Self>,
761 ) {
762 // User message should always consist of a single text segment,
763 // therefore we can skip returning early if it's not a text segment.
764 let Some(MessageSegment::Text(message_text)) = message_segments.first() else {
765 return;
766 };
767
768 let buffer = cx.new(|cx| {
769 MultiBuffer::singleton(cx.new(|cx| Buffer::local(message_text.clone(), cx)), cx)
770 });
771 let editor = cx.new(|cx| {
772 let mut editor = Editor::new(
773 editor::EditorMode::AutoHeight { max_lines: 8 },
774 buffer,
775 None,
776 window,
777 cx,
778 );
779 editor.focus_handle(cx).focus(window);
780 editor.move_to_end(&editor::actions::MoveToEnd, window, cx);
781 editor
782 });
783 self.editing_message = Some((
784 message_id,
785 EditMessageState {
786 editor: editor.clone(),
787 },
788 ));
789 cx.notify();
790 }
791
792 fn cancel_editing_message(&mut self, _: &menu::Cancel, _: &mut Window, cx: &mut Context<Self>) {
793 self.editing_message.take();
794 cx.notify();
795 }
796
797 fn confirm_editing_message(
798 &mut self,
799 _: &menu::Confirm,
800 _: &mut Window,
801 cx: &mut Context<Self>,
802 ) {
803 let Some((message_id, state)) = self.editing_message.take() else {
804 return;
805 };
806 let edited_text = state.editor.read(cx).text(cx);
807 self.thread.update(cx, |thread, cx| {
808 thread.edit_message(
809 message_id,
810 Role::User,
811 vec![MessageSegment::Text(edited_text)],
812 cx,
813 );
814 for message_id in self.messages_after(message_id) {
815 thread.delete_message(*message_id, cx);
816 }
817 });
818
819 let Some(model) = LanguageModelRegistry::read_global(cx).default_model() else {
820 return;
821 };
822
823 if model.provider.must_accept_terms(cx) {
824 cx.notify();
825 return;
826 }
827
828 self.thread.update(cx, |thread, cx| {
829 thread.send_to_model(model.model, RequestKind::Chat, cx)
830 });
831 cx.notify();
832 }
833
834 fn messages_after(&self, message_id: MessageId) -> &[MessageId] {
835 self.messages
836 .iter()
837 .position(|id| *id == message_id)
838 .map(|index| &self.messages[index + 1..])
839 .unwrap_or(&[])
840 }
841
842 fn handle_cancel_click(&mut self, _: &ClickEvent, window: &mut Window, cx: &mut Context<Self>) {
843 self.cancel_editing_message(&menu::Cancel, window, cx);
844 }
845
846 fn handle_regenerate_click(
847 &mut self,
848 _: &ClickEvent,
849 window: &mut Window,
850 cx: &mut Context<Self>,
851 ) {
852 self.confirm_editing_message(&menu::Confirm, window, cx);
853 }
854
855 fn handle_feedback_click(
856 &mut self,
857 feedback: ThreadFeedback,
858 window: &mut Window,
859 cx: &mut Context<Self>,
860 ) {
861 match feedback {
862 ThreadFeedback::Positive => {
863 let report = self
864 .thread
865 .update(cx, |thread, cx| thread.report_feedback(feedback, cx));
866
867 let this = cx.entity().downgrade();
868 cx.spawn(async move |_, cx| {
869 report.await?;
870 this.update(cx, |_this, cx| cx.notify())
871 })
872 .detach_and_log_err(cx);
873 }
874 ThreadFeedback::Negative => {
875 self.handle_show_feedback_comments(window, cx);
876 }
877 }
878 }
879
880 fn handle_show_feedback_comments(&mut self, window: &mut Window, cx: &mut Context<Self>) {
881 if self.feedback_message_editor.is_some() {
882 return;
883 }
884
885 let buffer = cx.new(|cx| {
886 let empty_string = String::new();
887 MultiBuffer::singleton(cx.new(|cx| Buffer::local(empty_string, cx)), cx)
888 });
889
890 let editor = cx.new(|cx| {
891 let mut editor = Editor::new(
892 editor::EditorMode::AutoHeight { max_lines: 4 },
893 buffer,
894 None,
895 window,
896 cx,
897 );
898 editor.set_placeholder_text(
899 "What went wrong? Share your feedback so we can improve.",
900 cx,
901 );
902 editor
903 });
904
905 editor.read(cx).focus_handle(cx).focus(window);
906 self.feedback_message_editor = Some(editor);
907 cx.notify();
908 }
909
910 fn submit_feedback_message(&mut self, cx: &mut Context<Self>) {
911 let Some(editor) = self.feedback_message_editor.clone() else {
912 return;
913 };
914
915 let report_task = self.thread.update(cx, |thread, cx| {
916 thread.report_feedback(ThreadFeedback::Negative, cx)
917 });
918
919 let comments = editor.read(cx).text(cx);
920 if !comments.is_empty() {
921 let thread_id = self.thread.read(cx).id().clone();
922
923 telemetry::event!("Assistant Thread Feedback Comments", thread_id, comments);
924 }
925
926 self.feedback_message_editor = None;
927
928 let this = cx.entity().downgrade();
929 cx.spawn(async move |_, cx| {
930 report_task.await?;
931 this.update(cx, |_this, cx| cx.notify())
932 })
933 .detach_and_log_err(cx);
934 }
935
936 fn render_message(&self, ix: usize, window: &mut Window, cx: &mut Context<Self>) -> AnyElement {
937 let message_id = self.messages[ix];
938 let Some(message) = self.thread.read(cx).message(message_id) else {
939 return Empty.into_any();
940 };
941
942 let Some(rendered_message) = self.rendered_messages_by_id.get(&message_id) else {
943 return Empty.into_any();
944 };
945
946 let context_store = self.context_store.clone();
947 let workspace = self.workspace.clone();
948
949 let thread = self.thread.read(cx);
950 // Get all the data we need from thread before we start using it in closures
951 let checkpoint = thread.checkpoint_for_message(message_id);
952 let context = thread.context_for_message(message_id).collect::<Vec<_>>();
953 let tool_uses = thread.tool_uses_for_message(message_id, cx);
954 let has_tool_uses = !tool_uses.is_empty();
955
956 // Don't render user messages that are just there for returning tool results.
957 if message.role == Role::User && thread.message_has_tool_results(message_id) {
958 return Empty.into_any();
959 }
960
961 let allow_editing_message = message.role == Role::User;
962
963 let edit_message_editor = self
964 .editing_message
965 .as_ref()
966 .filter(|(id, _)| *id == message_id)
967 .map(|(_, state)| state.editor.clone());
968
969 let first_message = ix == 0;
970 let show_feedback = ix == self.messages.len() - 1 && message.role != Role::User;
971
972 let colors = cx.theme().colors();
973 let active_color = colors.element_active;
974 let editor_bg_color = colors.editor_background;
975 let bg_user_message_header = editor_bg_color.blend(active_color.opacity(0.25));
976
977 let feedback_container = h_flex().pt_2().pb_4().px_4().gap_1().justify_between();
978 let feedback_items = match self.thread.read(cx).feedback() {
979 Some(feedback) => feedback_container
980 .child(
981 Label::new(match feedback {
982 ThreadFeedback::Positive => "Thanks for your feedback!",
983 ThreadFeedback::Negative => {
984 "We appreciate your feedback and will use it to improve."
985 }
986 })
987 .color(Color::Muted)
988 .size(LabelSize::XSmall),
989 )
990 .child(
991 h_flex()
992 .gap_1()
993 .child(
994 IconButton::new("feedback-thumbs-up", IconName::ThumbsUp)
995 .icon_size(IconSize::XSmall)
996 .icon_color(match feedback {
997 ThreadFeedback::Positive => Color::Accent,
998 ThreadFeedback::Negative => Color::Ignored,
999 })
1000 .shape(ui::IconButtonShape::Square)
1001 .tooltip(Tooltip::text("Helpful Response"))
1002 .on_click(cx.listener(move |this, _, window, cx| {
1003 this.handle_feedback_click(
1004 ThreadFeedback::Positive,
1005 window,
1006 cx,
1007 );
1008 })),
1009 )
1010 .child(
1011 IconButton::new("feedback-thumbs-down", IconName::ThumbsDown)
1012 .icon_size(IconSize::XSmall)
1013 .icon_color(match feedback {
1014 ThreadFeedback::Positive => Color::Ignored,
1015 ThreadFeedback::Negative => Color::Accent,
1016 })
1017 .shape(ui::IconButtonShape::Square)
1018 .tooltip(Tooltip::text("Not Helpful"))
1019 .on_click(cx.listener(move |this, _, window, cx| {
1020 this.handle_feedback_click(
1021 ThreadFeedback::Negative,
1022 window,
1023 cx,
1024 );
1025 })),
1026 ),
1027 )
1028 .into_any_element(),
1029 None => feedback_container
1030 .child(
1031 Label::new(
1032 "Rating the thread sends all of your current conversation to the Zed team.",
1033 )
1034 .color(Color::Muted)
1035 .size(LabelSize::XSmall),
1036 )
1037 .child(
1038 h_flex()
1039 .gap_1()
1040 .child(
1041 IconButton::new("feedback-thumbs-up", IconName::ThumbsUp)
1042 .icon_size(IconSize::XSmall)
1043 .icon_color(Color::Ignored)
1044 .shape(ui::IconButtonShape::Square)
1045 .tooltip(Tooltip::text("Helpful Response"))
1046 .on_click(cx.listener(move |this, _, window, cx| {
1047 this.handle_feedback_click(
1048 ThreadFeedback::Positive,
1049 window,
1050 cx,
1051 );
1052 })),
1053 )
1054 .child(
1055 IconButton::new("feedback-thumbs-down", IconName::ThumbsDown)
1056 .icon_size(IconSize::XSmall)
1057 .icon_color(Color::Ignored)
1058 .shape(ui::IconButtonShape::Square)
1059 .tooltip(Tooltip::text("Not Helpful"))
1060 .on_click(cx.listener(move |this, _, window, cx| {
1061 this.handle_feedback_click(
1062 ThreadFeedback::Negative,
1063 window,
1064 cx,
1065 );
1066 })),
1067 ),
1068 )
1069 .into_any_element(),
1070 };
1071
1072 let message_is_empty = message.should_display_content();
1073 let has_content = !message_is_empty || !context.is_empty();
1074
1075 let message_content =
1076 has_content.then(|| {
1077 v_flex()
1078 .gap_1p5()
1079 .when(!message_is_empty, |parent| {
1080 parent.child(
1081 if let Some(edit_message_editor) = edit_message_editor.clone() {
1082 div()
1083 .key_context("EditMessageEditor")
1084 .on_action(cx.listener(Self::cancel_editing_message))
1085 .on_action(cx.listener(Self::confirm_editing_message))
1086 .min_h_6()
1087 .child(edit_message_editor)
1088 .into_any()
1089 } else {
1090 div()
1091 .min_h_6()
1092 .text_ui(cx)
1093 .child(self.render_message_content(
1094 message_id,
1095 rendered_message,
1096 has_tool_uses,
1097 cx,
1098 ))
1099 .into_any()
1100 },
1101 )
1102 })
1103 .when(!context.is_empty(), |parent| {
1104 parent.child(h_flex().flex_wrap().gap_1().children(
1105 context.into_iter().map(|context| {
1106 let context_id = context.id();
1107 ContextPill::added(
1108 AddedContext::new(context, cx),
1109 false,
1110 false,
1111 None,
1112 )
1113 .on_click(Rc::new(cx.listener({
1114 let workspace = workspace.clone();
1115 let context_store = context_store.clone();
1116 move |_, _, window, cx| {
1117 if let Some(workspace) = workspace.upgrade() {
1118 open_context(
1119 context_id,
1120 context_store.clone(),
1121 workspace,
1122 window,
1123 cx,
1124 );
1125 cx.notify();
1126 }
1127 }
1128 })))
1129 }),
1130 ))
1131 })
1132 });
1133
1134 let styled_message = match message.role {
1135 Role::User => v_flex()
1136 .id(("message-container", ix))
1137 .map(|this| {
1138 if first_message {
1139 this.pt_2()
1140 } else {
1141 this.pt_4()
1142 }
1143 })
1144 .pb_4()
1145 .pl_2()
1146 .pr_2p5()
1147 .child(
1148 v_flex()
1149 .bg(colors.editor_background)
1150 .rounded_lg()
1151 .border_1()
1152 .border_color(colors.border)
1153 .shadow_md()
1154 .child(
1155 h_flex()
1156 .py_1()
1157 .pl_2()
1158 .pr_1()
1159 .bg(bg_user_message_header)
1160 .border_b_1()
1161 .border_color(colors.border)
1162 .justify_between()
1163 .rounded_t_md()
1164 .child(
1165 h_flex()
1166 .gap_1p5()
1167 .child(
1168 Icon::new(IconName::PersonCircle)
1169 .size(IconSize::XSmall)
1170 .color(Color::Muted),
1171 )
1172 .child(
1173 Label::new("You")
1174 .size(LabelSize::Small)
1175 .color(Color::Muted),
1176 ),
1177 )
1178 .child(
1179 h_flex()
1180 .gap_1()
1181 .when_some(
1182 edit_message_editor.clone(),
1183 |this, edit_message_editor| {
1184 let focus_handle =
1185 edit_message_editor.focus_handle(cx);
1186 this.child(
1187 Button::new("cancel-edit-message", "Cancel")
1188 .label_size(LabelSize::Small)
1189 .key_binding(
1190 KeyBinding::for_action_in(
1191 &menu::Cancel,
1192 &focus_handle,
1193 window,
1194 cx,
1195 )
1196 .map(|kb| kb.size(rems_from_px(12.))),
1197 )
1198 .on_click(
1199 cx.listener(Self::handle_cancel_click),
1200 ),
1201 )
1202 .child(
1203 Button::new(
1204 "confirm-edit-message",
1205 "Regenerate",
1206 )
1207 .label_size(LabelSize::Small)
1208 .key_binding(
1209 KeyBinding::for_action_in(
1210 &menu::Confirm,
1211 &focus_handle,
1212 window,
1213 cx,
1214 )
1215 .map(|kb| kb.size(rems_from_px(12.))),
1216 )
1217 .on_click(
1218 cx.listener(Self::handle_regenerate_click),
1219 ),
1220 )
1221 },
1222 )
1223 .when(
1224 edit_message_editor.is_none() && allow_editing_message,
1225 |this| {
1226 this.child(
1227 Button::new("edit-message", "Edit")
1228 .label_size(LabelSize::Small)
1229 .on_click(cx.listener({
1230 let message_segments =
1231 message.segments.clone();
1232 move |this, _, window, cx| {
1233 this.start_editing_message(
1234 message_id,
1235 &message_segments,
1236 window,
1237 cx,
1238 );
1239 }
1240 })),
1241 )
1242 },
1243 ),
1244 ),
1245 )
1246 .child(div().p_2().children(message_content)),
1247 ),
1248 Role::Assistant => v_flex()
1249 .id(("message-container", ix))
1250 .ml_2()
1251 .pl_2()
1252 .pr_4()
1253 .border_l_1()
1254 .border_color(cx.theme().colors().border_variant)
1255 .children(message_content)
1256 .gap_2p5()
1257 .pb_2p5()
1258 .when(!tool_uses.is_empty(), |parent| {
1259 parent.child(
1260 v_flex().children(
1261 tool_uses
1262 .into_iter()
1263 .map(|tool_use| self.render_tool_use(tool_use, cx)),
1264 ),
1265 )
1266 }),
1267 Role::System => div().id(("message-container", ix)).py_1().px_2().child(
1268 v_flex()
1269 .bg(colors.editor_background)
1270 .rounded_sm()
1271 .child(div().p_4().children(message_content)),
1272 ),
1273 };
1274
1275 v_flex()
1276 .w_full()
1277 .when(first_message, |parent| {
1278 parent.child(self.render_rules_item(cx))
1279 })
1280 .when_some(checkpoint, |parent, checkpoint| {
1281 let mut is_pending = false;
1282 let mut error = None;
1283 if let Some(last_restore_checkpoint) =
1284 self.thread.read(cx).last_restore_checkpoint()
1285 {
1286 if last_restore_checkpoint.message_id() == message_id {
1287 match last_restore_checkpoint {
1288 LastRestoreCheckpoint::Pending { .. } => is_pending = true,
1289 LastRestoreCheckpoint::Error { error: err, .. } => {
1290 error = Some(err.clone());
1291 }
1292 }
1293 }
1294 }
1295
1296 let restore_checkpoint_button =
1297 Button::new(("restore-checkpoint", ix), "Restore Checkpoint")
1298 .icon(if error.is_some() {
1299 IconName::XCircle
1300 } else {
1301 IconName::Undo
1302 })
1303 .icon_size(IconSize::XSmall)
1304 .icon_position(IconPosition::Start)
1305 .icon_color(if error.is_some() {
1306 Some(Color::Error)
1307 } else {
1308 None
1309 })
1310 .label_size(LabelSize::XSmall)
1311 .disabled(is_pending)
1312 .on_click(cx.listener(move |this, _, _window, cx| {
1313 this.thread.update(cx, |thread, cx| {
1314 thread
1315 .restore_checkpoint(checkpoint.clone(), cx)
1316 .detach_and_log_err(cx);
1317 });
1318 }));
1319
1320 let restore_checkpoint_button = if is_pending {
1321 restore_checkpoint_button
1322 .with_animation(
1323 ("pulsating-restore-checkpoint-button", ix),
1324 Animation::new(Duration::from_secs(2))
1325 .repeat()
1326 .with_easing(pulsating_between(0.6, 1.)),
1327 |label, delta| label.alpha(delta),
1328 )
1329 .into_any_element()
1330 } else if let Some(error) = error {
1331 restore_checkpoint_button
1332 .tooltip(Tooltip::text(error.to_string()))
1333 .into_any_element()
1334 } else {
1335 restore_checkpoint_button.into_any_element()
1336 };
1337
1338 parent.child(
1339 h_flex()
1340 .pt_2p5()
1341 .px_2p5()
1342 .w_full()
1343 .gap_1()
1344 .child(ui::Divider::horizontal())
1345 .child(restore_checkpoint_button)
1346 .child(ui::Divider::horizontal()),
1347 )
1348 })
1349 .child(styled_message)
1350 .when(
1351 show_feedback && !self.thread.read(cx).is_generating(),
1352 |parent| {
1353 parent.child(feedback_items).when_some(
1354 self.feedback_message_editor.clone(),
1355 |parent, feedback_editor| {
1356 let focus_handle = feedback_editor.focus_handle(cx);
1357 parent.child(
1358 v_flex()
1359 .key_context("AgentFeedbackMessageEditor")
1360 .on_action(cx.listener(|this, _: &menu::Cancel, _, cx| {
1361 this.feedback_message_editor = None;
1362 cx.notify();
1363 }))
1364 .on_action(cx.listener(|this, _: &menu::Confirm, _, cx| {
1365 this.submit_feedback_message(cx);
1366 cx.notify();
1367 }))
1368 .on_action(cx.listener(Self::confirm_editing_message))
1369 .mx_4()
1370 .mb_3()
1371 .p_2()
1372 .rounded_md()
1373 .border_1()
1374 .border_color(cx.theme().colors().border)
1375 .bg(cx.theme().colors().editor_background)
1376 .child(feedback_editor)
1377 .child(
1378 h_flex()
1379 .gap_1()
1380 .justify_end()
1381 .child(
1382 Button::new("dismiss-feedback-message", "Cancel")
1383 .label_size(LabelSize::Small)
1384 .key_binding(
1385 KeyBinding::for_action_in(
1386 &menu::Cancel,
1387 &focus_handle,
1388 window,
1389 cx,
1390 )
1391 .map(|kb| kb.size(rems_from_px(10.))),
1392 )
1393 .on_click(cx.listener(|this, _, _, cx| {
1394 this.feedback_message_editor = None;
1395 cx.notify();
1396 })),
1397 )
1398 .child(
1399 Button::new(
1400 "submit-feedback-message",
1401 "Share Feedback",
1402 )
1403 .style(ButtonStyle::Tinted(ui::TintColor::Accent))
1404 .label_size(LabelSize::Small)
1405 .key_binding(
1406 KeyBinding::for_action_in(
1407 &menu::Confirm,
1408 &focus_handle,
1409 window,
1410 cx,
1411 )
1412 .map(|kb| kb.size(rems_from_px(10.))),
1413 )
1414 .on_click(cx.listener(|this, _, _, cx| {
1415 this.submit_feedback_message(cx);
1416 cx.notify();
1417 })),
1418 ),
1419 ),
1420 )
1421 },
1422 )
1423 },
1424 )
1425 .into_any()
1426 }
1427
1428 fn render_message_content(
1429 &self,
1430 message_id: MessageId,
1431 rendered_message: &RenderedMessage,
1432 has_tool_uses: bool,
1433 cx: &Context<Self>,
1434 ) -> impl IntoElement {
1435 let is_last_message = self.messages.last() == Some(&message_id);
1436 let is_generating = self.thread.read(cx).is_generating();
1437 let pending_thinking_segment_index = if is_generating && is_last_message && !has_tool_uses {
1438 rendered_message
1439 .segments
1440 .iter()
1441 .enumerate()
1442 .next_back()
1443 .filter(|(_, segment)| matches!(segment, RenderedMessageSegment::Thinking { .. }))
1444 .map(|(index, _)| index)
1445 } else {
1446 None
1447 };
1448
1449 div()
1450 .text_ui(cx)
1451 .gap_2()
1452 .children(
1453 rendered_message.segments.iter().enumerate().map(
1454 |(index, segment)| match segment {
1455 RenderedMessageSegment::Thinking {
1456 content,
1457 scroll_handle,
1458 } => self
1459 .render_message_thinking_segment(
1460 message_id,
1461 index,
1462 content.clone(),
1463 &scroll_handle,
1464 Some(index) == pending_thinking_segment_index,
1465 cx,
1466 )
1467 .into_any_element(),
1468 RenderedMessageSegment::Text(markdown) => {
1469 div().child(markdown.clone()).into_any_element()
1470 }
1471 },
1472 ),
1473 )
1474 }
1475
1476 fn tool_card_border_color(&self, cx: &Context<Self>) -> Hsla {
1477 cx.theme().colors().border.opacity(0.5)
1478 }
1479
1480 fn tool_card_header_bg(&self, cx: &Context<Self>) -> Hsla {
1481 cx.theme()
1482 .colors()
1483 .element_background
1484 .blend(cx.theme().colors().editor_foreground.opacity(0.025))
1485 }
1486
1487 fn render_message_thinking_segment(
1488 &self,
1489 message_id: MessageId,
1490 ix: usize,
1491 markdown: Entity<Markdown>,
1492 scroll_handle: &ScrollHandle,
1493 pending: bool,
1494 cx: &Context<Self>,
1495 ) -> impl IntoElement {
1496 let is_open = self
1497 .expanded_thinking_segments
1498 .get(&(message_id, ix))
1499 .copied()
1500 .unwrap_or_default();
1501
1502 let editor_bg = cx.theme().colors().editor_background;
1503
1504 div().pt_0p5().pb_2().child(
1505 v_flex()
1506 .rounded_lg()
1507 .border_1()
1508 .border_color(self.tool_card_border_color(cx))
1509 .child(
1510 h_flex()
1511 .group("disclosure-header")
1512 .justify_between()
1513 .py_1()
1514 .px_2()
1515 .bg(self.tool_card_header_bg(cx))
1516 .map(|this| {
1517 if pending || is_open {
1518 this.rounded_t_md()
1519 .border_b_1()
1520 .border_color(self.tool_card_border_color(cx))
1521 } else {
1522 this.rounded_md()
1523 }
1524 })
1525 .child(
1526 h_flex()
1527 .gap_1p5()
1528 .child(
1529 Icon::new(IconName::Brain)
1530 .size(IconSize::XSmall)
1531 .color(Color::Muted),
1532 )
1533 .child({
1534 if pending {
1535 Label::new("Thinking…")
1536 .size(LabelSize::Small)
1537 .buffer_font(cx)
1538 .with_animation(
1539 "pulsating-label",
1540 Animation::new(Duration::from_secs(2))
1541 .repeat()
1542 .with_easing(pulsating_between(0.4, 0.8)),
1543 |label, delta| label.alpha(delta),
1544 )
1545 .into_any_element()
1546 } else {
1547 Label::new("Thought Process")
1548 .size(LabelSize::Small)
1549 .buffer_font(cx)
1550 .into_any_element()
1551 }
1552 }),
1553 )
1554 .child(
1555 h_flex()
1556 .gap_1()
1557 .child(
1558 div().visible_on_hover("disclosure-header").child(
1559 Disclosure::new("thinking-disclosure", is_open)
1560 .opened_icon(IconName::ChevronUp)
1561 .closed_icon(IconName::ChevronDown)
1562 .on_click(cx.listener({
1563 move |this, _event, _window, _cx| {
1564 let is_open = this
1565 .expanded_thinking_segments
1566 .entry((message_id, ix))
1567 .or_insert(false);
1568
1569 *is_open = !*is_open;
1570 }
1571 })),
1572 ),
1573 )
1574 .child({
1575 let (icon_name, color, animated) = if pending {
1576 (IconName::ArrowCircle, Color::Accent, true)
1577 } else {
1578 (IconName::Check, Color::Success, false)
1579 };
1580
1581 let icon =
1582 Icon::new(icon_name).color(color).size(IconSize::Small);
1583
1584 if animated {
1585 icon.with_animation(
1586 "arrow-circle",
1587 Animation::new(Duration::from_secs(2)).repeat(),
1588 |icon, delta| {
1589 icon.transform(Transformation::rotate(percentage(
1590 delta,
1591 )))
1592 },
1593 )
1594 .into_any_element()
1595 } else {
1596 icon.into_any_element()
1597 }
1598 }),
1599 ),
1600 )
1601 .when(pending && !is_open, |this| {
1602 let gradient_overlay = div()
1603 .rounded_b_lg()
1604 .h_20()
1605 .absolute()
1606 .w_full()
1607 .bottom_0()
1608 .left_0()
1609 .bg(linear_gradient(
1610 180.,
1611 linear_color_stop(editor_bg, 1.),
1612 linear_color_stop(editor_bg.opacity(0.2), 0.),
1613 ));
1614
1615 this.child(
1616 div()
1617 .relative()
1618 .bg(editor_bg)
1619 .rounded_b_lg()
1620 .child(
1621 div()
1622 .id(("thinking-content", ix))
1623 .p_2()
1624 .h_20()
1625 .track_scroll(scroll_handle)
1626 .text_ui_sm(cx)
1627 .child(markdown.clone())
1628 .overflow_hidden(),
1629 )
1630 .child(gradient_overlay),
1631 )
1632 })
1633 .when(is_open, |this| {
1634 this.child(
1635 div()
1636 .id(("thinking-content", ix))
1637 .h_full()
1638 .p_2()
1639 .rounded_b_lg()
1640 .bg(editor_bg)
1641 .text_ui_sm(cx)
1642 .child(markdown.clone()),
1643 )
1644 }),
1645 )
1646 }
1647
1648 fn render_tool_use(
1649 &self,
1650 tool_use: ToolUse,
1651 cx: &mut Context<Self>,
1652 ) -> impl IntoElement + use<> {
1653 let is_open = self
1654 .expanded_tool_uses
1655 .get(&tool_use.id)
1656 .copied()
1657 .unwrap_or_default();
1658
1659 let is_status_finished = matches!(&tool_use.status, ToolUseStatus::Finished(_));
1660
1661 let fs = self
1662 .workspace
1663 .upgrade()
1664 .map(|workspace| workspace.read(cx).app_state().fs.clone());
1665 let needs_confirmation = matches!(&tool_use.status, ToolUseStatus::NeedsConfirmation);
1666
1667 let status_icons = div().child(match &tool_use.status {
1668 ToolUseStatus::Pending | ToolUseStatus::NeedsConfirmation => {
1669 let icon = Icon::new(IconName::Warning)
1670 .color(Color::Warning)
1671 .size(IconSize::Small);
1672 icon.into_any_element()
1673 }
1674 ToolUseStatus::Running => {
1675 let icon = Icon::new(IconName::ArrowCircle)
1676 .color(Color::Accent)
1677 .size(IconSize::Small);
1678 icon.with_animation(
1679 "arrow-circle",
1680 Animation::new(Duration::from_secs(2)).repeat(),
1681 |icon, delta| icon.transform(Transformation::rotate(percentage(delta))),
1682 )
1683 .into_any_element()
1684 }
1685 ToolUseStatus::Finished(_) => div().w_0().into_any_element(),
1686 ToolUseStatus::Error(_) => {
1687 let icon = Icon::new(IconName::Close)
1688 .color(Color::Error)
1689 .size(IconSize::Small);
1690 icon.into_any_element()
1691 }
1692 });
1693
1694 let content_container = || v_flex().py_1().gap_0p5().px_2p5();
1695 let results_content = v_flex()
1696 .gap_1()
1697 .child(
1698 content_container()
1699 .child(
1700 Label::new("Input")
1701 .size(LabelSize::XSmall)
1702 .color(Color::Muted)
1703 .buffer_font(cx),
1704 )
1705 .child(
1706 Label::new(
1707 serde_json::to_string_pretty(&tool_use.input).unwrap_or_default(),
1708 )
1709 .size(LabelSize::Small)
1710 .buffer_font(cx),
1711 ),
1712 )
1713 .map(|container| match tool_use.status {
1714 ToolUseStatus::Finished(output) => container.child(
1715 content_container()
1716 .border_t_1()
1717 .border_color(self.tool_card_border_color(cx))
1718 .child(
1719 Label::new("Result")
1720 .size(LabelSize::XSmall)
1721 .color(Color::Muted)
1722 .buffer_font(cx),
1723 )
1724 .child(Label::new(output).size(LabelSize::Small).buffer_font(cx)),
1725 ),
1726 ToolUseStatus::Running => container.child(
1727 content_container().child(
1728 h_flex()
1729 .gap_1()
1730 .pb_1()
1731 .border_t_1()
1732 .border_color(self.tool_card_border_color(cx))
1733 .child(
1734 Icon::new(IconName::ArrowCircle)
1735 .size(IconSize::Small)
1736 .color(Color::Accent)
1737 .with_animation(
1738 "arrow-circle",
1739 Animation::new(Duration::from_secs(2)).repeat(),
1740 |icon, delta| {
1741 icon.transform(Transformation::rotate(percentage(
1742 delta,
1743 )))
1744 },
1745 ),
1746 )
1747 .child(
1748 Label::new("Running…")
1749 .size(LabelSize::XSmall)
1750 .color(Color::Muted)
1751 .buffer_font(cx),
1752 ),
1753 ),
1754 ),
1755 ToolUseStatus::Error(err) => container.child(
1756 content_container()
1757 .border_t_1()
1758 .border_color(self.tool_card_border_color(cx))
1759 .child(
1760 Label::new("Error")
1761 .size(LabelSize::XSmall)
1762 .color(Color::Muted)
1763 .buffer_font(cx),
1764 )
1765 .child(Label::new(err).size(LabelSize::Small).buffer_font(cx)),
1766 ),
1767 ToolUseStatus::Pending => container,
1768 ToolUseStatus::NeedsConfirmation => container.child(
1769 content_container()
1770 .border_t_1()
1771 .border_color(self.tool_card_border_color(cx))
1772 .child(
1773 Label::new("Asking Permission")
1774 .size(LabelSize::Small)
1775 .color(Color::Muted)
1776 .buffer_font(cx),
1777 ),
1778 ),
1779 });
1780
1781 let gradient_overlay = |color: Hsla| {
1782 div()
1783 .h_full()
1784 .absolute()
1785 .w_8()
1786 .bottom_0()
1787 .map(|element| {
1788 if is_status_finished {
1789 element.right_7()
1790 } else {
1791 element.right(px(46.))
1792 }
1793 })
1794 .bg(linear_gradient(
1795 90.,
1796 linear_color_stop(color, 1.),
1797 linear_color_stop(color.opacity(0.2), 0.),
1798 ))
1799 };
1800
1801 div().map(|element| {
1802 if !tool_use.needs_confirmation {
1803 element.child(
1804 v_flex()
1805 .child(
1806 h_flex()
1807 .group("disclosure-header")
1808 .relative()
1809 .gap_1p5()
1810 .justify_between()
1811 .opacity(0.8)
1812 .hover(|style| style.opacity(1.))
1813 .when(!is_status_finished, |this| this.pr_2())
1814 .child(
1815 h_flex()
1816 .id("tool-label-container")
1817 .gap_1p5()
1818 .max_w_full()
1819 .overflow_x_scroll()
1820 .child(
1821 Icon::new(tool_use.icon)
1822 .size(IconSize::XSmall)
1823 .color(Color::Muted),
1824 )
1825 .child(
1826 h_flex().pr_8().text_ui_sm(cx).children(
1827 self.rendered_tool_use_labels
1828 .get(&tool_use.id)
1829 .cloned(),
1830 ),
1831 ),
1832 )
1833 .child(
1834 h_flex()
1835 .gap_1()
1836 .child(
1837 div().visible_on_hover("disclosure-header").child(
1838 Disclosure::new("tool-use-disclosure", is_open)
1839 .opened_icon(IconName::ChevronUp)
1840 .closed_icon(IconName::ChevronDown)
1841 .on_click(cx.listener({
1842 let tool_use_id = tool_use.id.clone();
1843 move |this, _event, _window, _cx| {
1844 let is_open = this
1845 .expanded_tool_uses
1846 .entry(tool_use_id.clone())
1847 .or_insert(false);
1848
1849 *is_open = !*is_open;
1850 }
1851 })),
1852 ),
1853 )
1854 .child(status_icons),
1855 )
1856 .child(gradient_overlay(cx.theme().colors().panel_background)),
1857 )
1858 .map(|parent| {
1859 if !is_open {
1860 return parent;
1861 }
1862
1863 parent.child(
1864 v_flex()
1865 .mt_1()
1866 .border_1()
1867 .border_color(self.tool_card_border_color(cx))
1868 .bg(cx.theme().colors().editor_background)
1869 .rounded_lg()
1870 .child(results_content),
1871 )
1872 }),
1873 )
1874 } else {
1875 v_flex()
1876 .rounded_lg()
1877 .border_1()
1878 .border_color(self.tool_card_border_color(cx))
1879 .overflow_hidden()
1880 .child(
1881 h_flex()
1882 .group("disclosure-header")
1883 .relative()
1884 .justify_between()
1885 .py_1()
1886 .map(|element| {
1887 if is_status_finished {
1888 element.pl_2().pr_0p5()
1889 } else {
1890 element.px_2()
1891 }
1892 })
1893 .bg(self.tool_card_header_bg(cx))
1894 .map(|element| {
1895 if is_open {
1896 element.border_b_1().rounded_t_md()
1897 } else if needs_confirmation {
1898 element.rounded_t_md()
1899 } else {
1900 element.rounded_md()
1901 }
1902 })
1903 .border_color(self.tool_card_border_color(cx))
1904 .child(
1905 h_flex()
1906 .id("tool-label-container")
1907 .gap_1p5()
1908 .max_w_full()
1909 .overflow_x_scroll()
1910 .child(
1911 Icon::new(tool_use.icon)
1912 .size(IconSize::XSmall)
1913 .color(Color::Muted),
1914 )
1915 .child(
1916 h_flex().pr_8().text_ui_sm(cx).children(
1917 self.rendered_tool_use_labels
1918 .get(&tool_use.id)
1919 .cloned(),
1920 ),
1921 ),
1922 )
1923 .child(
1924 h_flex()
1925 .gap_1()
1926 .child(
1927 div().visible_on_hover("disclosure-header").child(
1928 Disclosure::new("tool-use-disclosure", is_open)
1929 .opened_icon(IconName::ChevronUp)
1930 .closed_icon(IconName::ChevronDown)
1931 .on_click(cx.listener({
1932 let tool_use_id = tool_use.id.clone();
1933 move |this, _event, _window, _cx| {
1934 let is_open = this
1935 .expanded_tool_uses
1936 .entry(tool_use_id.clone())
1937 .or_insert(false);
1938
1939 *is_open = !*is_open;
1940 }
1941 })),
1942 ),
1943 )
1944 .child(status_icons),
1945 )
1946 .child(gradient_overlay(self.tool_card_header_bg(cx))),
1947 )
1948 .map(|parent| {
1949 if !is_open {
1950 return parent;
1951 }
1952
1953 parent.child(
1954 v_flex()
1955 .bg(cx.theme().colors().editor_background)
1956 .map(|element| {
1957 if needs_confirmation {
1958 element.rounded_none()
1959 } else {
1960 element.rounded_b_lg()
1961 }
1962 })
1963 .child(results_content),
1964 )
1965 })
1966 .when(needs_confirmation, |this| {
1967 this.child(
1968 h_flex()
1969 .py_1()
1970 .pl_2()
1971 .pr_1()
1972 .gap_1()
1973 .justify_between()
1974 .bg(cx.theme().colors().editor_background)
1975 .border_t_1()
1976 .border_color(self.tool_card_border_color(cx))
1977 .rounded_b_lg()
1978 .child(Label::new("Action Confirmation").color(Color::Muted).size(LabelSize::Small))
1979 .child(
1980 h_flex()
1981 .gap_0p5()
1982 .child({
1983 let tool_id = tool_use.id.clone();
1984 Button::new(
1985 "always-allow-tool-action",
1986 "Always Allow",
1987 )
1988 .label_size(LabelSize::Small)
1989 .icon(IconName::CheckDouble)
1990 .icon_position(IconPosition::Start)
1991 .icon_size(IconSize::Small)
1992 .icon_color(Color::Success)
1993 .tooltip(move |window, cx| {
1994 Tooltip::with_meta(
1995 "Never ask for permission",
1996 None,
1997 "Restore the original behavior in your Agent Panel settings",
1998 window,
1999 cx,
2000 )
2001 })
2002 .on_click(cx.listener(
2003 move |this, event, window, cx| {
2004 if let Some(fs) = fs.clone() {
2005 update_settings_file::<AssistantSettings>(
2006 fs.clone(),
2007 cx,
2008 |settings, _| {
2009 settings.set_always_allow_tool_actions(true);
2010 },
2011 );
2012 }
2013 this.handle_allow_tool(
2014 tool_id.clone(),
2015 event,
2016 window,
2017 cx,
2018 )
2019 },
2020 ))
2021 })
2022 .child(ui::Divider::vertical())
2023 .child({
2024 let tool_id = tool_use.id.clone();
2025 Button::new("allow-tool-action", "Allow")
2026 .label_size(LabelSize::Small)
2027 .icon(IconName::Check)
2028 .icon_position(IconPosition::Start)
2029 .icon_size(IconSize::Small)
2030 .icon_color(Color::Success)
2031 .on_click(cx.listener(
2032 move |this, event, window, cx| {
2033 this.handle_allow_tool(
2034 tool_id.clone(),
2035 event,
2036 window,
2037 cx,
2038 )
2039 },
2040 ))
2041 })
2042 .child({
2043 let tool_id = tool_use.id.clone();
2044 let tool_name: Arc<str> = tool_use.name.into();
2045 Button::new("deny-tool", "Deny")
2046 .label_size(LabelSize::Small)
2047 .icon(IconName::Close)
2048 .icon_position(IconPosition::Start)
2049 .icon_size(IconSize::Small)
2050 .icon_color(Color::Error)
2051 .on_click(cx.listener(
2052 move |this, event, window, cx| {
2053 this.handle_deny_tool(
2054 tool_id.clone(),
2055 tool_name.clone(),
2056 event,
2057 window,
2058 cx,
2059 )
2060 },
2061 ))
2062 }),
2063 ),
2064 )
2065 })
2066 }
2067 })
2068 }
2069
2070 fn render_rules_item(&self, cx: &Context<Self>) -> AnyElement {
2071 let Some(system_prompt_context) = self.thread.read(cx).system_prompt_context().as_ref()
2072 else {
2073 return div().into_any();
2074 };
2075
2076 let rules_files = system_prompt_context
2077 .worktrees
2078 .iter()
2079 .filter_map(|worktree| worktree.rules_file.as_ref())
2080 .collect::<Vec<_>>();
2081
2082 let label_text = match rules_files.as_slice() {
2083 &[] => return div().into_any(),
2084 &[rules_file] => {
2085 format!("Using {:?} file", rules_file.rel_path)
2086 }
2087 rules_files => {
2088 format!("Using {} rules files", rules_files.len())
2089 }
2090 };
2091
2092 div()
2093 .pt_1()
2094 .px_2p5()
2095 .child(
2096 h_flex()
2097 .w_full()
2098 .gap_0p5()
2099 .child(
2100 h_flex()
2101 .gap_1p5()
2102 .child(
2103 Icon::new(IconName::File)
2104 .size(IconSize::XSmall)
2105 .color(Color::Disabled),
2106 )
2107 .child(
2108 Label::new(label_text)
2109 .size(LabelSize::XSmall)
2110 .color(Color::Muted)
2111 .buffer_font(cx),
2112 ),
2113 )
2114 .child(
2115 IconButton::new("open-rule", IconName::ArrowUpRightAlt)
2116 .shape(ui::IconButtonShape::Square)
2117 .icon_size(IconSize::XSmall)
2118 .icon_color(Color::Ignored)
2119 .on_click(cx.listener(Self::handle_open_rules))
2120 .tooltip(Tooltip::text("View Rules")),
2121 ),
2122 )
2123 .into_any()
2124 }
2125
2126 fn handle_allow_tool(
2127 &mut self,
2128 tool_use_id: LanguageModelToolUseId,
2129 _: &ClickEvent,
2130 _window: &mut Window,
2131 cx: &mut Context<Self>,
2132 ) {
2133 if let Some(PendingToolUseStatus::NeedsConfirmation(c)) = self
2134 .thread
2135 .read(cx)
2136 .pending_tool(&tool_use_id)
2137 .map(|tool_use| tool_use.status.clone())
2138 {
2139 self.thread.update(cx, |thread, cx| {
2140 thread.run_tool(
2141 c.tool_use_id.clone(),
2142 c.ui_text.clone(),
2143 c.input.clone(),
2144 &c.messages,
2145 c.tool.clone(),
2146 cx,
2147 );
2148 });
2149 }
2150 }
2151
2152 fn handle_deny_tool(
2153 &mut self,
2154 tool_use_id: LanguageModelToolUseId,
2155 tool_name: Arc<str>,
2156 _: &ClickEvent,
2157 _window: &mut Window,
2158 cx: &mut Context<Self>,
2159 ) {
2160 self.thread.update(cx, |thread, cx| {
2161 thread.deny_tool_use(tool_use_id, tool_name, cx);
2162 });
2163 }
2164
2165 fn handle_open_rules(&mut self, _: &ClickEvent, window: &mut Window, cx: &mut Context<Self>) {
2166 let Some(system_prompt_context) = self.thread.read(cx).system_prompt_context().as_ref()
2167 else {
2168 return;
2169 };
2170
2171 let abs_paths = system_prompt_context
2172 .worktrees
2173 .iter()
2174 .flat_map(|worktree| worktree.rules_file.as_ref())
2175 .map(|rules_file| rules_file.abs_path.to_path_buf())
2176 .collect::<Vec<_>>();
2177
2178 if let Ok(task) = self.workspace.update(cx, move |workspace, cx| {
2179 // TODO: Open a multibuffer instead? In some cases this doesn't make the set of rules
2180 // files clear. For example, if rules file 1 is already open but rules file 2 is not,
2181 // this would open and focus rules file 2 in a tab that is not next to rules file 1.
2182 workspace.open_paths(abs_paths, OpenOptions::default(), None, window, cx)
2183 }) {
2184 task.detach();
2185 }
2186 }
2187
2188 fn dismiss_notifications(&mut self, cx: &mut Context<ActiveThread>) {
2189 for window in self.notifications.drain(..) {
2190 window
2191 .update(cx, |_, window, _| {
2192 window.remove_window();
2193 })
2194 .ok();
2195
2196 self.notification_subscriptions.remove(&window);
2197 }
2198 }
2199
2200 fn render_vertical_scrollbar(&self, cx: &mut Context<Self>) -> Stateful<Div> {
2201 div()
2202 .occlude()
2203 .id("active-thread-scrollbar")
2204 .on_mouse_move(cx.listener(|_, _, _, cx| {
2205 cx.notify();
2206 cx.stop_propagation()
2207 }))
2208 .on_hover(|_, _, cx| {
2209 cx.stop_propagation();
2210 })
2211 .on_any_mouse_down(|_, _, cx| {
2212 cx.stop_propagation();
2213 })
2214 .on_mouse_up(
2215 MouseButton::Left,
2216 cx.listener(|_, _, _, cx| {
2217 cx.stop_propagation();
2218 }),
2219 )
2220 .on_scroll_wheel(cx.listener(|_, _, _, cx| {
2221 cx.notify();
2222 }))
2223 .h_full()
2224 .absolute()
2225 .right_1()
2226 .top_1()
2227 .bottom_0()
2228 .w(px(12.))
2229 .cursor_default()
2230 .children(Scrollbar::vertical(self.scrollbar_state.clone()))
2231 }
2232}
2233
2234impl Render for ActiveThread {
2235 fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
2236 v_flex()
2237 .size_full()
2238 .relative()
2239 .child(list(self.list_state.clone()).flex_grow())
2240 .child(self.render_vertical_scrollbar(cx))
2241 }
2242}
2243
2244pub(crate) fn open_context(
2245 id: ContextId,
2246 context_store: Entity<ContextStore>,
2247 workspace: Entity<Workspace>,
2248 window: &mut Window,
2249 cx: &mut App,
2250) {
2251 let Some(context) = context_store.read(cx).context_for_id(id) else {
2252 return;
2253 };
2254
2255 match context {
2256 AssistantContext::File(file_context) => {
2257 if let Some(project_path) = file_context.context_buffer.buffer.read(cx).project_path(cx)
2258 {
2259 workspace.update(cx, |workspace, cx| {
2260 workspace
2261 .open_path(project_path, None, true, window, cx)
2262 .detach_and_log_err(cx);
2263 });
2264 }
2265 }
2266 AssistantContext::Directory(directory_context) => {
2267 let path = directory_context.project_path.clone();
2268 workspace.update(cx, |workspace, cx| {
2269 workspace.project().update(cx, |project, cx| {
2270 if let Some(entry) = project.entry_for_path(&path, cx) {
2271 cx.emit(project::Event::RevealInProjectPanel(entry.id));
2272 }
2273 })
2274 })
2275 }
2276 AssistantContext::Symbol(symbol_context) => {
2277 if let Some(project_path) = symbol_context
2278 .context_symbol
2279 .buffer
2280 .read(cx)
2281 .project_path(cx)
2282 {
2283 let snapshot = symbol_context.context_symbol.buffer.read(cx).snapshot();
2284 let target_position = symbol_context
2285 .context_symbol
2286 .id
2287 .range
2288 .start
2289 .to_point(&snapshot);
2290
2291 let open_task = workspace.update(cx, |workspace, cx| {
2292 workspace.open_path(project_path, None, true, window, cx)
2293 });
2294 window
2295 .spawn(cx, async move |cx| {
2296 if let Some(active_editor) = open_task
2297 .await
2298 .log_err()
2299 .and_then(|item| item.downcast::<Editor>())
2300 {
2301 active_editor
2302 .downgrade()
2303 .update_in(cx, |editor, window, cx| {
2304 editor.go_to_singleton_buffer_point(
2305 target_position,
2306 window,
2307 cx,
2308 );
2309 })
2310 .log_err();
2311 }
2312 })
2313 .detach();
2314 }
2315 }
2316 AssistantContext::FetchedUrl(fetched_url_context) => {
2317 cx.open_url(&fetched_url_context.url);
2318 }
2319 AssistantContext::Thread(thread_context) => {
2320 let thread_id = thread_context.thread.read(cx).id().clone();
2321 workspace.update(cx, |workspace, cx| {
2322 if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
2323 panel.update(cx, |panel, cx| {
2324 panel
2325 .open_thread(&thread_id, window, cx)
2326 .detach_and_log_err(cx)
2327 });
2328 }
2329 })
2330 }
2331 }
2332}