1use crate::thread::{
2 LastRestoreCheckpoint, MessageId, MessageSegment, RequestKind, Thread, ThreadError,
3 ThreadEvent, ThreadFeedback,
4};
5use crate::thread_store::ThreadStore;
6use crate::tool_use::{PendingToolUseStatus, ToolUse, ToolUseStatus};
7use crate::ui::{ContextPill, ToolReadyPopUp, ToolReadyPopupEvent};
8
9use assistant_settings::AssistantSettings;
10use collections::HashMap;
11use editor::{Editor, MultiBuffer};
12use gpui::{
13 linear_color_stop, linear_gradient, list, percentage, pulsating_between, AbsoluteLength,
14 Animation, AnimationExt, AnyElement, App, ClickEvent, DefiniteLength, EdgesRefinement, Empty,
15 Entity, Focusable, Length, ListAlignment, ListOffset, ListState, ScrollHandle, StyleRefinement,
16 Subscription, Task, TextStyleRefinement, Transformation, UnderlineStyle, WeakEntity,
17 WindowHandle,
18};
19use language::{Buffer, LanguageRegistry};
20use language_model::{LanguageModelRegistry, LanguageModelToolUseId, Role};
21use markdown::{Markdown, MarkdownStyle};
22use settings::Settings as _;
23use std::sync::Arc;
24use std::time::Duration;
25use theme::ThemeSettings;
26use ui::{prelude::*, Disclosure, IconButton, KeyBinding, Tooltip};
27use util::ResultExt as _;
28use workspace::{OpenOptions, Workspace};
29
30use crate::context_store::{refresh_context_store_text, ContextStore};
31
32pub struct ActiveThread {
33 language_registry: Arc<LanguageRegistry>,
34 thread_store: Entity<ThreadStore>,
35 thread: Entity<Thread>,
36 context_store: Entity<ContextStore>,
37 workspace: WeakEntity<Workspace>,
38 save_thread_task: Option<Task<()>>,
39 messages: Vec<MessageId>,
40 list_state: ListState,
41 rendered_messages_by_id: HashMap<MessageId, RenderedMessage>,
42 rendered_tool_use_labels: HashMap<LanguageModelToolUseId, Entity<Markdown>>,
43 editing_message: Option<(MessageId, EditMessageState)>,
44 expanded_tool_uses: HashMap<LanguageModelToolUseId, bool>,
45 expanded_thinking_segments: HashMap<(MessageId, usize), bool>,
46 last_error: Option<ThreadError>,
47 pop_ups: Vec<WindowHandle<ToolReadyPopUp>>,
48 _subscriptions: Vec<Subscription>,
49}
50
51struct RenderedMessage {
52 language_registry: Arc<LanguageRegistry>,
53 segments: Vec<RenderedMessageSegment>,
54}
55
56impl RenderedMessage {
57 fn from_segments(
58 segments: &[MessageSegment],
59 language_registry: Arc<LanguageRegistry>,
60 window: &Window,
61 cx: &mut App,
62 ) -> Self {
63 let mut this = Self {
64 language_registry,
65 segments: Vec::with_capacity(segments.len()),
66 };
67 for segment in segments {
68 this.push_segment(segment, window, cx);
69 }
70 this
71 }
72
73 fn append_thinking(&mut self, text: &String, window: &Window, cx: &mut App) {
74 if let Some(RenderedMessageSegment::Thinking {
75 content,
76 scroll_handle,
77 }) = self.segments.last_mut()
78 {
79 content.update(cx, |markdown, cx| {
80 markdown.append(text, cx);
81 });
82 scroll_handle.scroll_to_bottom();
83 } else {
84 self.segments.push(RenderedMessageSegment::Thinking {
85 content: render_markdown(text.into(), self.language_registry.clone(), window, cx),
86 scroll_handle: ScrollHandle::default(),
87 });
88 }
89 }
90
91 fn append_text(&mut self, text: &String, window: &Window, cx: &mut App) {
92 if let Some(RenderedMessageSegment::Text(markdown)) = self.segments.last_mut() {
93 markdown.update(cx, |markdown, cx| markdown.append(text, cx));
94 } else {
95 self.segments
96 .push(RenderedMessageSegment::Text(render_markdown(
97 SharedString::from(text),
98 self.language_registry.clone(),
99 window,
100 cx,
101 )));
102 }
103 }
104
105 fn push_segment(&mut self, segment: &MessageSegment, window: &Window, cx: &mut App) {
106 let rendered_segment = match segment {
107 MessageSegment::Thinking(text) => RenderedMessageSegment::Thinking {
108 content: render_markdown(text.into(), self.language_registry.clone(), window, cx),
109 scroll_handle: ScrollHandle::default(),
110 },
111 MessageSegment::Text(text) => RenderedMessageSegment::Text(render_markdown(
112 text.into(),
113 self.language_registry.clone(),
114 window,
115 cx,
116 )),
117 };
118 self.segments.push(rendered_segment);
119 }
120}
121
122enum RenderedMessageSegment {
123 Thinking {
124 content: Entity<Markdown>,
125 scroll_handle: ScrollHandle,
126 },
127 Text(Entity<Markdown>),
128}
129
130fn render_markdown(
131 text: SharedString,
132 language_registry: Arc<LanguageRegistry>,
133 window: &Window,
134 cx: &mut App,
135) -> Entity<Markdown> {
136 let theme_settings = ThemeSettings::get_global(cx);
137 let colors = cx.theme().colors();
138 let ui_font_size = TextSize::Default.rems(cx);
139 let buffer_font_size = TextSize::Small.rems(cx);
140 let mut text_style = window.text_style();
141
142 text_style.refine(&TextStyleRefinement {
143 font_family: Some(theme_settings.ui_font.family.clone()),
144 font_fallbacks: theme_settings.ui_font.fallbacks.clone(),
145 font_features: Some(theme_settings.ui_font.features.clone()),
146 font_size: Some(ui_font_size.into()),
147 color: Some(cx.theme().colors().text),
148 ..Default::default()
149 });
150
151 let markdown_style = MarkdownStyle {
152 base_text_style: text_style,
153 syntax: cx.theme().syntax().clone(),
154 selection_background_color: cx.theme().players().local().selection,
155 code_block_overflow_x_scroll: true,
156 table_overflow_x_scroll: true,
157 code_block: StyleRefinement {
158 margin: EdgesRefinement {
159 top: Some(Length::Definite(rems(0.).into())),
160 left: Some(Length::Definite(rems(0.).into())),
161 right: Some(Length::Definite(rems(0.).into())),
162 bottom: Some(Length::Definite(rems(0.5).into())),
163 },
164 padding: EdgesRefinement {
165 top: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(Pixels(8.)))),
166 left: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(Pixels(8.)))),
167 right: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(Pixels(8.)))),
168 bottom: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(Pixels(8.)))),
169 },
170 background: Some(colors.editor_background.into()),
171 border_color: Some(colors.border_variant),
172 border_widths: EdgesRefinement {
173 top: Some(AbsoluteLength::Pixels(Pixels(1.))),
174 left: Some(AbsoluteLength::Pixels(Pixels(1.))),
175 right: Some(AbsoluteLength::Pixels(Pixels(1.))),
176 bottom: Some(AbsoluteLength::Pixels(Pixels(1.))),
177 },
178 text: Some(TextStyleRefinement {
179 font_family: Some(theme_settings.buffer_font.family.clone()),
180 font_fallbacks: theme_settings.buffer_font.fallbacks.clone(),
181 font_features: Some(theme_settings.buffer_font.features.clone()),
182 font_size: Some(buffer_font_size.into()),
183 ..Default::default()
184 }),
185 ..Default::default()
186 },
187 inline_code: TextStyleRefinement {
188 font_family: Some(theme_settings.buffer_font.family.clone()),
189 font_fallbacks: theme_settings.buffer_font.fallbacks.clone(),
190 font_features: Some(theme_settings.buffer_font.features.clone()),
191 font_size: Some(buffer_font_size.into()),
192 background_color: Some(colors.editor_foreground.opacity(0.1)),
193 ..Default::default()
194 },
195 link: TextStyleRefinement {
196 background_color: Some(colors.editor_foreground.opacity(0.025)),
197 underline: Some(UnderlineStyle {
198 color: Some(colors.text_accent.opacity(0.5)),
199 thickness: px(1.),
200 ..Default::default()
201 }),
202 ..Default::default()
203 },
204 ..Default::default()
205 };
206
207 cx.new(|cx| Markdown::new(text, markdown_style, Some(language_registry), None, cx))
208}
209
210struct EditMessageState {
211 editor: Entity<Editor>,
212}
213
214impl ActiveThread {
215 pub fn new(
216 thread: Entity<Thread>,
217 thread_store: Entity<ThreadStore>,
218 language_registry: Arc<LanguageRegistry>,
219 context_store: Entity<ContextStore>,
220 workspace: WeakEntity<Workspace>,
221 window: &mut Window,
222 cx: &mut Context<Self>,
223 ) -> Self {
224 let subscriptions = vec![
225 cx.observe(&thread, |_, _, cx| cx.notify()),
226 cx.subscribe_in(&thread, window, Self::handle_thread_event),
227 ];
228
229 let mut this = Self {
230 language_registry,
231 thread_store,
232 thread: thread.clone(),
233 context_store,
234 workspace,
235 save_thread_task: None,
236 messages: Vec::new(),
237 rendered_messages_by_id: HashMap::default(),
238 rendered_tool_use_labels: HashMap::default(),
239 expanded_tool_uses: HashMap::default(),
240 expanded_thinking_segments: HashMap::default(),
241 list_state: ListState::new(0, ListAlignment::Bottom, px(1024.), {
242 let this = cx.entity().downgrade();
243 move |ix, window: &mut Window, cx: &mut App| {
244 this.update(cx, |this, cx| this.render_message(ix, window, cx))
245 .unwrap()
246 }
247 }),
248 editing_message: None,
249 last_error: None,
250 pop_ups: Vec::new(),
251 _subscriptions: subscriptions,
252 };
253
254 for message in thread.read(cx).messages().cloned().collect::<Vec<_>>() {
255 this.push_message(&message.id, &message.segments, window, cx);
256
257 for tool_use in thread.read(cx).tool_uses_for_message(message.id, cx) {
258 this.render_tool_use_label_markdown(
259 tool_use.id.clone(),
260 tool_use.ui_text.clone(),
261 window,
262 cx,
263 );
264 }
265 }
266
267 this
268 }
269
270 pub fn thread(&self) -> &Entity<Thread> {
271 &self.thread
272 }
273
274 pub fn is_empty(&self) -> bool {
275 self.messages.is_empty()
276 }
277
278 pub fn summary(&self, cx: &App) -> Option<SharedString> {
279 self.thread.read(cx).summary()
280 }
281
282 pub fn summary_or_default(&self, cx: &App) -> SharedString {
283 self.thread.read(cx).summary_or_default()
284 }
285
286 pub fn cancel_last_completion(&mut self, cx: &mut App) -> bool {
287 self.last_error.take();
288 self.thread
289 .update(cx, |thread, cx| thread.cancel_last_completion(cx))
290 }
291
292 pub fn last_error(&self) -> Option<ThreadError> {
293 self.last_error.clone()
294 }
295
296 pub fn clear_last_error(&mut self) {
297 self.last_error.take();
298 }
299
300 fn push_message(
301 &mut self,
302 id: &MessageId,
303 segments: &[MessageSegment],
304 window: &mut Window,
305 cx: &mut Context<Self>,
306 ) {
307 let old_len = self.messages.len();
308 self.messages.push(*id);
309 self.list_state.splice(old_len..old_len, 1);
310
311 let rendered_message =
312 RenderedMessage::from_segments(segments, self.language_registry.clone(), window, cx);
313 self.rendered_messages_by_id.insert(*id, rendered_message);
314 self.list_state.scroll_to(ListOffset {
315 item_ix: old_len,
316 offset_in_item: Pixels(0.0),
317 });
318 }
319
320 fn edited_message(
321 &mut self,
322 id: &MessageId,
323 segments: &[MessageSegment],
324 window: &mut Window,
325 cx: &mut Context<Self>,
326 ) {
327 let Some(index) = self.messages.iter().position(|message_id| message_id == id) else {
328 return;
329 };
330 self.list_state.splice(index..index + 1, 1);
331 let rendered_message =
332 RenderedMessage::from_segments(segments, self.language_registry.clone(), window, cx);
333 self.rendered_messages_by_id.insert(*id, rendered_message);
334 }
335
336 fn deleted_message(&mut self, id: &MessageId) {
337 let Some(index) = self.messages.iter().position(|message_id| message_id == id) else {
338 return;
339 };
340 self.messages.remove(index);
341 self.list_state.splice(index..index + 1, 0);
342 self.rendered_messages_by_id.remove(id);
343 }
344
345 fn render_tool_use_label_markdown(
346 &mut self,
347 tool_use_id: LanguageModelToolUseId,
348 tool_label: impl Into<SharedString>,
349 window: &mut Window,
350 cx: &mut Context<Self>,
351 ) {
352 self.rendered_tool_use_labels.insert(
353 tool_use_id,
354 render_markdown(
355 tool_label.into(),
356 self.language_registry.clone(),
357 window,
358 cx,
359 ),
360 );
361 }
362
363 fn handle_thread_event(
364 &mut self,
365 _thread: &Entity<Thread>,
366 event: &ThreadEvent,
367 window: &mut Window,
368 cx: &mut Context<Self>,
369 ) {
370 match event {
371 ThreadEvent::ShowError(error) => {
372 self.last_error = Some(error.clone());
373 }
374 ThreadEvent::StreamedCompletion | ThreadEvent::SummaryChanged => {
375 self.save_thread(cx);
376 }
377 ThreadEvent::DoneStreaming => {
378 if !self.thread().read(cx).is_generating() {
379 self.show_notification("Your changes have been applied.", window, cx);
380 }
381 }
382 ThreadEvent::ToolConfirmationNeeded => {
383 self.show_notification("There's a tool confirmation needed.", window, cx);
384 }
385 ThreadEvent::StreamedAssistantText(message_id, text) => {
386 if let Some(rendered_message) = self.rendered_messages_by_id.get_mut(&message_id) {
387 rendered_message.append_text(text, window, cx);
388 }
389 }
390 ThreadEvent::StreamedAssistantThinking(message_id, text) => {
391 if let Some(rendered_message) = self.rendered_messages_by_id.get_mut(&message_id) {
392 rendered_message.append_thinking(text, window, cx);
393 }
394 }
395 ThreadEvent::MessageAdded(message_id) => {
396 if let Some(message_segments) = self
397 .thread
398 .read(cx)
399 .message(*message_id)
400 .map(|message| message.segments.clone())
401 {
402 self.push_message(message_id, &message_segments, window, cx);
403 }
404
405 self.save_thread(cx);
406 cx.notify();
407 }
408 ThreadEvent::MessageEdited(message_id) => {
409 if let Some(message_segments) = self
410 .thread
411 .read(cx)
412 .message(*message_id)
413 .map(|message| message.segments.clone())
414 {
415 self.edited_message(message_id, &message_segments, window, cx);
416 }
417
418 self.save_thread(cx);
419 cx.notify();
420 }
421 ThreadEvent::MessageDeleted(message_id) => {
422 self.deleted_message(message_id);
423 self.save_thread(cx);
424 cx.notify();
425 }
426 ThreadEvent::UsePendingTools => {
427 let tool_uses = self
428 .thread
429 .update(cx, |thread, cx| thread.use_pending_tools(cx));
430
431 for tool_use in tool_uses {
432 self.render_tool_use_label_markdown(
433 tool_use.id.clone(),
434 tool_use.ui_text.clone(),
435 window,
436 cx,
437 );
438 }
439 }
440 ThreadEvent::ToolFinished {
441 pending_tool_use,
442 canceled,
443 ..
444 } => {
445 let canceled = *canceled;
446 if let Some(tool_use) = pending_tool_use {
447 self.render_tool_use_label_markdown(
448 tool_use.id.clone(),
449 SharedString::from(tool_use.ui_text.clone()),
450 window,
451 cx,
452 );
453 }
454
455 if self.thread.read(cx).all_tools_finished() {
456 let pending_refresh_buffers = self.thread.update(cx, |thread, cx| {
457 thread.action_log().update(cx, |action_log, _cx| {
458 action_log.take_stale_buffers_in_context()
459 })
460 });
461
462 let context_update_task = if !pending_refresh_buffers.is_empty() {
463 let refresh_task = refresh_context_store_text(
464 self.context_store.clone(),
465 &pending_refresh_buffers,
466 cx,
467 );
468
469 cx.spawn(async move |this, cx| {
470 let updated_context_ids = refresh_task.await;
471
472 this.update(cx, |this, cx| {
473 this.context_store.read_with(cx, |context_store, cx| {
474 context_store
475 .context()
476 .iter()
477 .filter(|context| {
478 updated_context_ids.contains(&context.id())
479 })
480 .flat_map(|context| context.snapshot(cx))
481 .collect()
482 })
483 })
484 })
485 } else {
486 Task::ready(anyhow::Ok(Vec::new()))
487 };
488
489 let model_registry = LanguageModelRegistry::read_global(cx);
490 if let Some(model) = model_registry.active_model() {
491 cx.spawn(async move |this, cx| {
492 let updated_context = context_update_task.await?;
493
494 this.update(cx, |this, cx| {
495 this.thread.update(cx, |thread, cx| {
496 thread.attach_tool_results(updated_context, cx);
497 if !canceled {
498 thread.send_to_model(model, RequestKind::Chat, cx);
499 }
500 });
501 })
502 })
503 .detach();
504 }
505 }
506 }
507 ThreadEvent::CheckpointChanged => cx.notify(),
508 }
509 }
510
511 fn show_notification(
512 &mut self,
513 caption: impl Into<SharedString>,
514 window: &mut Window,
515 cx: &mut Context<'_, ActiveThread>,
516 ) {
517 if !window.is_window_active()
518 && self.pop_ups.is_empty()
519 && AssistantSettings::get_global(cx).notify_when_agent_waiting
520 {
521 let caption = caption.into();
522
523 for screen in cx.displays() {
524 let options = ToolReadyPopUp::window_options(screen, cx);
525
526 if let Some(screen_window) = cx
527 .open_window(options, |_, cx| {
528 cx.new(|_| ToolReadyPopUp::new(caption.clone()))
529 })
530 .log_err()
531 {
532 if let Some(pop_up) = screen_window.entity(cx).log_err() {
533 cx.subscribe_in(&pop_up, window, {
534 |this, _, event, window, cx| match event {
535 ToolReadyPopupEvent::Accepted => {
536 let handle = window.window_handle();
537 cx.activate(true); // Switch back to the Zed application
538
539 // If there are multiple Zed windows, activate the correct one.
540 cx.defer(move |cx| {
541 handle
542 .update(cx, |_view, window, _cx| {
543 window.activate_window();
544 })
545 .log_err();
546 });
547
548 this.dismiss_notifications(cx);
549 }
550 ToolReadyPopupEvent::Dismissed => {
551 this.dismiss_notifications(cx);
552 }
553 }
554 })
555 .detach();
556
557 self.pop_ups.push(screen_window);
558 }
559 }
560 }
561 }
562 }
563
564 /// Spawns a task to save the active thread.
565 ///
566 /// Only one task to save the thread will be in flight at a time.
567 fn save_thread(&mut self, cx: &mut Context<Self>) {
568 let thread = self.thread.clone();
569 self.save_thread_task = Some(cx.spawn(async move |this, cx| {
570 let task = this
571 .update(cx, |this, cx| {
572 this.thread_store
573 .update(cx, |thread_store, cx| thread_store.save_thread(&thread, cx))
574 })
575 .ok();
576
577 if let Some(task) = task {
578 task.await.log_err();
579 }
580 }));
581 }
582
583 fn start_editing_message(
584 &mut self,
585 message_id: MessageId,
586 message_segments: &[MessageSegment],
587 window: &mut Window,
588 cx: &mut Context<Self>,
589 ) {
590 // User message should always consist of a single text segment,
591 // therefore we can skip returning early if it's not a text segment.
592 let Some(MessageSegment::Text(message_text)) = message_segments.first() else {
593 return;
594 };
595
596 let buffer = cx.new(|cx| {
597 MultiBuffer::singleton(cx.new(|cx| Buffer::local(message_text.clone(), cx)), cx)
598 });
599 let editor = cx.new(|cx| {
600 let mut editor = Editor::new(
601 editor::EditorMode::AutoHeight { max_lines: 8 },
602 buffer,
603 None,
604 window,
605 cx,
606 );
607 editor.focus_handle(cx).focus(window);
608 editor.move_to_end(&editor::actions::MoveToEnd, window, cx);
609 editor
610 });
611 self.editing_message = Some((
612 message_id,
613 EditMessageState {
614 editor: editor.clone(),
615 },
616 ));
617 cx.notify();
618 }
619
620 fn cancel_editing_message(&mut self, _: &menu::Cancel, _: &mut Window, cx: &mut Context<Self>) {
621 self.editing_message.take();
622 cx.notify();
623 }
624
625 fn confirm_editing_message(
626 &mut self,
627 _: &menu::Confirm,
628 _: &mut Window,
629 cx: &mut Context<Self>,
630 ) {
631 let Some((message_id, state)) = self.editing_message.take() else {
632 return;
633 };
634 let edited_text = state.editor.read(cx).text(cx);
635 self.thread.update(cx, |thread, cx| {
636 thread.edit_message(
637 message_id,
638 Role::User,
639 vec![MessageSegment::Text(edited_text)],
640 cx,
641 );
642 for message_id in self.messages_after(message_id) {
643 thread.delete_message(*message_id, cx);
644 }
645 });
646
647 let provider = LanguageModelRegistry::read_global(cx).active_provider();
648 if provider
649 .as_ref()
650 .map_or(false, |provider| provider.must_accept_terms(cx))
651 {
652 cx.notify();
653 return;
654 }
655 let model_registry = LanguageModelRegistry::read_global(cx);
656 let Some(model) = model_registry.active_model() else {
657 return;
658 };
659
660 self.thread.update(cx, |thread, cx| {
661 thread.send_to_model(model, RequestKind::Chat, cx)
662 });
663 cx.notify();
664 }
665
666 fn last_user_message(&self, cx: &Context<Self>) -> Option<MessageId> {
667 self.messages
668 .iter()
669 .rev()
670 .find(|message_id| {
671 self.thread
672 .read(cx)
673 .message(**message_id)
674 .map_or(false, |message| message.role == Role::User)
675 })
676 .cloned()
677 }
678
679 fn messages_after(&self, message_id: MessageId) -> &[MessageId] {
680 self.messages
681 .iter()
682 .position(|id| *id == message_id)
683 .map(|index| &self.messages[index + 1..])
684 .unwrap_or(&[])
685 }
686
687 fn handle_cancel_click(&mut self, _: &ClickEvent, window: &mut Window, cx: &mut Context<Self>) {
688 self.cancel_editing_message(&menu::Cancel, window, cx);
689 }
690
691 fn handle_regenerate_click(
692 &mut self,
693 _: &ClickEvent,
694 window: &mut Window,
695 cx: &mut Context<Self>,
696 ) {
697 self.confirm_editing_message(&menu::Confirm, window, cx);
698 }
699
700 fn handle_feedback_click(
701 &mut self,
702 feedback: ThreadFeedback,
703 _window: &mut Window,
704 cx: &mut Context<Self>,
705 ) {
706 let report = self
707 .thread
708 .update(cx, |thread, cx| thread.report_feedback(feedback, cx));
709
710 let this = cx.entity().downgrade();
711 cx.spawn(async move |_, cx| {
712 report.await?;
713 this.update(cx, |_this, cx| cx.notify())
714 })
715 .detach_and_log_err(cx);
716 }
717
718 fn render_message(&self, ix: usize, window: &mut Window, cx: &mut Context<Self>) -> AnyElement {
719 let message_id = self.messages[ix];
720 let Some(message) = self.thread.read(cx).message(message_id) else {
721 return Empty.into_any();
722 };
723
724 let Some(rendered_message) = self.rendered_messages_by_id.get(&message_id) else {
725 return Empty.into_any();
726 };
727
728 let thread = self.thread.read(cx);
729 // Get all the data we need from thread before we start using it in closures
730 let checkpoint = thread.checkpoint_for_message(message_id);
731 let context = thread.context_for_message(message_id);
732 let tool_uses = thread.tool_uses_for_message(message_id, cx);
733
734 // Don't render user messages that are just there for returning tool results.
735 if message.role == Role::User && thread.message_has_tool_results(message_id) {
736 return Empty.into_any();
737 }
738
739 let allow_editing_message =
740 message.role == Role::User && self.last_user_message(cx) == Some(message_id);
741
742 let edit_message_editor = self
743 .editing_message
744 .as_ref()
745 .filter(|(id, _)| *id == message_id)
746 .map(|(_, state)| state.editor.clone());
747
748 let first_message = ix == 0;
749 let is_last_message = ix == self.messages.len() - 1;
750
751 let colors = cx.theme().colors();
752 let active_color = colors.element_active;
753 let editor_bg_color = colors.editor_background;
754 let bg_user_message_header = editor_bg_color.blend(active_color.opacity(0.25));
755
756 let feedback_container = h_flex().pt_2().pb_4().px_4().gap_1().justify_between();
757 let feedback_items = match self.thread.read(cx).feedback() {
758 Some(feedback) => feedback_container
759 .child(
760 Label::new(match feedback {
761 ThreadFeedback::Positive => "Thanks for your feedback!",
762 ThreadFeedback::Negative => {
763 "We appreciate your feedback and will use it to improve."
764 }
765 })
766 .color(Color::Muted)
767 .size(LabelSize::XSmall),
768 )
769 .child(
770 h_flex()
771 .gap_1()
772 .child(
773 IconButton::new("feedback-thumbs-up", IconName::ThumbsUp)
774 .icon_size(IconSize::XSmall)
775 .icon_color(match feedback {
776 ThreadFeedback::Positive => Color::Accent,
777 ThreadFeedback::Negative => Color::Ignored,
778 })
779 .shape(ui::IconButtonShape::Square)
780 .tooltip(Tooltip::text("Helpful Response"))
781 .on_click(cx.listener(move |this, _, window, cx| {
782 this.handle_feedback_click(
783 ThreadFeedback::Positive,
784 window,
785 cx,
786 );
787 })),
788 )
789 .child(
790 IconButton::new("feedback-thumbs-down", IconName::ThumbsDown)
791 .icon_size(IconSize::XSmall)
792 .icon_color(match feedback {
793 ThreadFeedback::Positive => Color::Ignored,
794 ThreadFeedback::Negative => Color::Accent,
795 })
796 .shape(ui::IconButtonShape::Square)
797 .tooltip(Tooltip::text("Not Helpful"))
798 .on_click(cx.listener(move |this, _, window, cx| {
799 this.handle_feedback_click(
800 ThreadFeedback::Negative,
801 window,
802 cx,
803 );
804 })),
805 ),
806 )
807 .into_any_element(),
808 None => feedback_container
809 .child(
810 Label::new(
811 "Rating the thread sends all of your current conversation to the Zed team.",
812 )
813 .color(Color::Muted)
814 .size(LabelSize::XSmall),
815 )
816 .child(
817 h_flex()
818 .gap_1()
819 .child(
820 IconButton::new("feedback-thumbs-up", IconName::ThumbsUp)
821 .icon_size(IconSize::XSmall)
822 .icon_color(Color::Ignored)
823 .shape(ui::IconButtonShape::Square)
824 .tooltip(Tooltip::text("Helpful Response"))
825 .on_click(cx.listener(move |this, _, window, cx| {
826 this.handle_feedback_click(
827 ThreadFeedback::Positive,
828 window,
829 cx,
830 );
831 })),
832 )
833 .child(
834 IconButton::new("feedback-thumbs-down", IconName::ThumbsDown)
835 .icon_size(IconSize::XSmall)
836 .icon_color(Color::Ignored)
837 .shape(ui::IconButtonShape::Square)
838 .tooltip(Tooltip::text("Not Helpful"))
839 .on_click(cx.listener(move |this, _, window, cx| {
840 this.handle_feedback_click(
841 ThreadFeedback::Negative,
842 window,
843 cx,
844 );
845 })),
846 ),
847 )
848 .into_any_element(),
849 };
850
851 let message_content = v_flex()
852 .gap_1p5()
853 .child(
854 if let Some(edit_message_editor) = edit_message_editor.clone() {
855 div()
856 .key_context("EditMessageEditor")
857 .on_action(cx.listener(Self::cancel_editing_message))
858 .on_action(cx.listener(Self::confirm_editing_message))
859 .min_h_6()
860 .child(edit_message_editor)
861 } else {
862 div()
863 .min_h_6()
864 .text_ui(cx)
865 .child(self.render_message_content(message_id, rendered_message, cx))
866 },
867 )
868 .when_some(context, |parent, context| {
869 if !context.is_empty() {
870 parent.child(
871 h_flex().flex_wrap().gap_1().children(
872 context
873 .into_iter()
874 .map(|context| ContextPill::added(context, false, false, None)),
875 ),
876 )
877 } else {
878 parent
879 }
880 });
881
882 let styled_message = match message.role {
883 Role::User => v_flex()
884 .id(("message-container", ix))
885 .map(|this| {
886 if first_message {
887 this.pt_2()
888 } else {
889 this.pt_4()
890 }
891 })
892 .pb_4()
893 .pl_2()
894 .pr_2p5()
895 .child(
896 v_flex()
897 .bg(colors.editor_background)
898 .rounded_lg()
899 .border_1()
900 .border_color(colors.border)
901 .shadow_md()
902 .child(
903 h_flex()
904 .py_1()
905 .pl_2()
906 .pr_1()
907 .bg(bg_user_message_header)
908 .border_b_1()
909 .border_color(colors.border)
910 .justify_between()
911 .rounded_t_md()
912 .child(
913 h_flex()
914 .gap_1p5()
915 .child(
916 Icon::new(IconName::PersonCircle)
917 .size(IconSize::XSmall)
918 .color(Color::Muted),
919 )
920 .child(
921 Label::new("You")
922 .size(LabelSize::Small)
923 .color(Color::Muted),
924 ),
925 )
926 .child(
927 h_flex()
928 // DL: To double-check whether we want to fully remove
929 // the editing feature from meassages. Checkpoint sort of
930 // solve the same problem.
931 .invisible()
932 .gap_1()
933 .when_some(
934 edit_message_editor.clone(),
935 |this, edit_message_editor| {
936 let focus_handle =
937 edit_message_editor.focus_handle(cx);
938 this.child(
939 Button::new("cancel-edit-message", "Cancel")
940 .label_size(LabelSize::Small)
941 .key_binding(
942 KeyBinding::for_action_in(
943 &menu::Cancel,
944 &focus_handle,
945 window,
946 cx,
947 )
948 .map(|kb| kb.size(rems_from_px(12.))),
949 )
950 .on_click(
951 cx.listener(Self::handle_cancel_click),
952 ),
953 )
954 .child(
955 Button::new(
956 "confirm-edit-message",
957 "Regenerate",
958 )
959 .label_size(LabelSize::Small)
960 .key_binding(
961 KeyBinding::for_action_in(
962 &menu::Confirm,
963 &focus_handle,
964 window,
965 cx,
966 )
967 .map(|kb| kb.size(rems_from_px(12.))),
968 )
969 .on_click(
970 cx.listener(Self::handle_regenerate_click),
971 ),
972 )
973 },
974 )
975 .when(
976 edit_message_editor.is_none() && allow_editing_message,
977 |this| {
978 this.child(
979 Button::new("edit-message", "Edit")
980 .label_size(LabelSize::Small)
981 .on_click(cx.listener({
982 let message_segments =
983 message.segments.clone();
984 move |this, _, window, cx| {
985 this.start_editing_message(
986 message_id,
987 &message_segments,
988 window,
989 cx,
990 );
991 }
992 })),
993 )
994 },
995 ),
996 ),
997 )
998 .child(div().p_2().child(message_content)),
999 ),
1000 Role::Assistant => v_flex()
1001 .id(("message-container", ix))
1002 .ml_2()
1003 .pl_2()
1004 .pr_4()
1005 .border_l_1()
1006 .border_color(cx.theme().colors().border_variant)
1007 .child(message_content)
1008 .when(!tool_uses.is_empty(), |parent| {
1009 parent.child(
1010 v_flex().children(
1011 tool_uses
1012 .into_iter()
1013 .map(|tool_use| self.render_tool_use(tool_use, cx)),
1014 ),
1015 )
1016 }),
1017 Role::System => div().id(("message-container", ix)).py_1().px_2().child(
1018 v_flex()
1019 .bg(colors.editor_background)
1020 .rounded_sm()
1021 .child(div().p_4().child(message_content)),
1022 ),
1023 };
1024
1025 v_flex()
1026 .w_full()
1027 .when(first_message, |parent| {
1028 parent.child(self.render_rules_item(cx))
1029 })
1030 .when_some(checkpoint, |parent, checkpoint| {
1031 let mut is_pending = false;
1032 let mut error = None;
1033 if let Some(last_restore_checkpoint) =
1034 self.thread.read(cx).last_restore_checkpoint()
1035 {
1036 if last_restore_checkpoint.message_id() == message_id {
1037 match last_restore_checkpoint {
1038 LastRestoreCheckpoint::Pending { .. } => is_pending = true,
1039 LastRestoreCheckpoint::Error { error: err, .. } => {
1040 error = Some(err.clone());
1041 }
1042 }
1043 }
1044 }
1045
1046 let restore_checkpoint_button =
1047 Button::new(("restore-checkpoint", ix), "Restore Checkpoint")
1048 .icon(if error.is_some() {
1049 IconName::XCircle
1050 } else {
1051 IconName::Undo
1052 })
1053 .icon_size(IconSize::XSmall)
1054 .icon_position(IconPosition::Start)
1055 .icon_color(if error.is_some() {
1056 Some(Color::Error)
1057 } else {
1058 None
1059 })
1060 .label_size(LabelSize::XSmall)
1061 .disabled(is_pending)
1062 .on_click(cx.listener(move |this, _, _window, cx| {
1063 this.thread.update(cx, |thread, cx| {
1064 thread
1065 .restore_checkpoint(checkpoint.clone(), cx)
1066 .detach_and_log_err(cx);
1067 });
1068 }));
1069
1070 let restore_checkpoint_button = if is_pending {
1071 restore_checkpoint_button
1072 .with_animation(
1073 ("pulsating-restore-checkpoint-button", ix),
1074 Animation::new(Duration::from_secs(2))
1075 .repeat()
1076 .with_easing(pulsating_between(0.6, 1.)),
1077 |label, delta| label.alpha(delta),
1078 )
1079 .into_any_element()
1080 } else if let Some(error) = error {
1081 restore_checkpoint_button
1082 .tooltip(Tooltip::text(error.to_string()))
1083 .into_any_element()
1084 } else {
1085 restore_checkpoint_button.into_any_element()
1086 };
1087
1088 parent.child(
1089 h_flex()
1090 .pt_2p5()
1091 .px_2p5()
1092 .w_full()
1093 .gap_1()
1094 .child(ui::Divider::horizontal())
1095 .child(restore_checkpoint_button)
1096 .child(ui::Divider::horizontal()),
1097 )
1098 })
1099 .child(styled_message)
1100 .when(
1101 is_last_message && !self.thread.read(cx).is_generating(),
1102 |parent| parent.child(feedback_items),
1103 )
1104 .into_any()
1105 }
1106
1107 fn render_message_content(
1108 &self,
1109 message_id: MessageId,
1110 rendered_message: &RenderedMessage,
1111 cx: &Context<Self>,
1112 ) -> impl IntoElement {
1113 let pending_thinking_segment_index = rendered_message
1114 .segments
1115 .iter()
1116 .enumerate()
1117 .last()
1118 .filter(|(_, segment)| matches!(segment, RenderedMessageSegment::Thinking { .. }))
1119 .map(|(index, _)| index);
1120
1121 div()
1122 .text_ui(cx)
1123 .gap_2()
1124 .children(
1125 rendered_message.segments.iter().enumerate().map(
1126 |(index, segment)| match segment {
1127 RenderedMessageSegment::Thinking {
1128 content,
1129 scroll_handle,
1130 } => self
1131 .render_message_thinking_segment(
1132 message_id,
1133 index,
1134 content.clone(),
1135 &scroll_handle,
1136 Some(index) == pending_thinking_segment_index,
1137 cx,
1138 )
1139 .into_any_element(),
1140 RenderedMessageSegment::Text(markdown) => {
1141 div().child(markdown.clone()).into_any_element()
1142 }
1143 },
1144 ),
1145 )
1146 }
1147
1148 fn render_message_thinking_segment(
1149 &self,
1150 message_id: MessageId,
1151 ix: usize,
1152 markdown: Entity<Markdown>,
1153 scroll_handle: &ScrollHandle,
1154 pending: bool,
1155 cx: &Context<Self>,
1156 ) -> impl IntoElement {
1157 let is_open = self
1158 .expanded_thinking_segments
1159 .get(&(message_id, ix))
1160 .copied()
1161 .unwrap_or_default();
1162
1163 let lighter_border = cx.theme().colors().border.opacity(0.5);
1164 let editor_bg = cx.theme().colors().editor_background;
1165
1166 div().py_2().child(
1167 v_flex()
1168 .rounded_lg()
1169 .border_1()
1170 .border_color(lighter_border)
1171 .child(
1172 h_flex()
1173 .group("disclosure-header")
1174 .justify_between()
1175 .py_1()
1176 .px_2()
1177 .bg(cx.theme().colors().editor_foreground.opacity(0.025))
1178 .map(|this| {
1179 if pending || is_open {
1180 this.rounded_t_md()
1181 .border_b_1()
1182 .border_color(lighter_border)
1183 } else {
1184 this.rounded_md()
1185 }
1186 })
1187 .child(
1188 h_flex()
1189 .gap_1p5()
1190 .child(
1191 Icon::new(IconName::Brain)
1192 .size(IconSize::XSmall)
1193 .color(Color::Muted),
1194 )
1195 .child({
1196 if pending {
1197 Label::new("Thinking…")
1198 .size(LabelSize::Small)
1199 .buffer_font(cx)
1200 .with_animation(
1201 "pulsating-label",
1202 Animation::new(Duration::from_secs(2))
1203 .repeat()
1204 .with_easing(pulsating_between(0.4, 0.8)),
1205 |label, delta| label.alpha(delta),
1206 )
1207 .into_any_element()
1208 } else {
1209 Label::new("Thought Process")
1210 .size(LabelSize::Small)
1211 .buffer_font(cx)
1212 .into_any_element()
1213 }
1214 }),
1215 )
1216 .child(
1217 h_flex()
1218 .gap_1()
1219 .child(
1220 div().visible_on_hover("disclosure-header").child(
1221 Disclosure::new("thinking-disclosure", is_open)
1222 .opened_icon(IconName::ChevronUp)
1223 .closed_icon(IconName::ChevronDown)
1224 .on_click(cx.listener({
1225 move |this, _event, _window, _cx| {
1226 let is_open = this
1227 .expanded_thinking_segments
1228 .entry((message_id, ix))
1229 .or_insert(false);
1230
1231 *is_open = !*is_open;
1232 }
1233 })),
1234 ),
1235 )
1236 .child({
1237 let (icon_name, color, animated) = if pending {
1238 (IconName::ArrowCircle, Color::Accent, true)
1239 } else {
1240 (IconName::Check, Color::Success, false)
1241 };
1242
1243 let icon =
1244 Icon::new(icon_name).color(color).size(IconSize::Small);
1245
1246 if animated {
1247 icon.with_animation(
1248 "arrow-circle",
1249 Animation::new(Duration::from_secs(2)).repeat(),
1250 |icon, delta| {
1251 icon.transform(Transformation::rotate(percentage(
1252 delta,
1253 )))
1254 },
1255 )
1256 .into_any_element()
1257 } else {
1258 icon.into_any_element()
1259 }
1260 }),
1261 ),
1262 )
1263 .when(pending && !is_open, |this| {
1264 let gradient_overlay = div()
1265 .rounded_b_lg()
1266 .h_20()
1267 .absolute()
1268 .w_full()
1269 .bottom_0()
1270 .left_0()
1271 .bg(linear_gradient(
1272 180.,
1273 linear_color_stop(editor_bg, 1.),
1274 linear_color_stop(editor_bg.opacity(0.2), 0.),
1275 ));
1276
1277 this.child(
1278 div()
1279 .relative()
1280 .bg(editor_bg)
1281 .rounded_b_lg()
1282 .child(
1283 div()
1284 .id(("thinking-content", ix))
1285 .p_2()
1286 .h_20()
1287 .track_scroll(scroll_handle)
1288 .text_ui_sm(cx)
1289 .child(markdown.clone())
1290 .overflow_hidden(),
1291 )
1292 .child(gradient_overlay),
1293 )
1294 })
1295 .when(is_open, |this| {
1296 this.child(
1297 div()
1298 .id(("thinking-content", ix))
1299 .h_full()
1300 .p_2()
1301 .rounded_b_lg()
1302 .bg(editor_bg)
1303 .text_ui_sm(cx)
1304 .child(markdown.clone()),
1305 )
1306 }),
1307 )
1308 }
1309
1310 fn render_tool_use(&self, tool_use: ToolUse, cx: &mut Context<Self>) -> impl IntoElement {
1311 let is_open = self
1312 .expanded_tool_uses
1313 .get(&tool_use.id)
1314 .copied()
1315 .unwrap_or_default();
1316
1317 let lighter_border = cx.theme().colors().border.opacity(0.5);
1318
1319 div().py_2().child(
1320 v_flex()
1321 .rounded_lg()
1322 .border_1()
1323 .border_color(lighter_border)
1324 .overflow_hidden()
1325 .child(
1326 h_flex()
1327 .group("disclosure-header")
1328 .justify_between()
1329 .py_1()
1330 .px_2()
1331 .bg(cx.theme().colors().editor_foreground.opacity(0.025))
1332 .map(|element| {
1333 if is_open {
1334 element.border_b_1().rounded_t_md()
1335 } else {
1336 element.rounded_md()
1337 }
1338 })
1339 .border_color(lighter_border)
1340 .child(
1341 h_flex()
1342 .gap_1p5()
1343 .child(
1344 Icon::new(tool_use.icon)
1345 .size(IconSize::XSmall)
1346 .color(Color::Muted),
1347 )
1348 .child(
1349 div()
1350 .text_ui_sm(cx)
1351 .children(
1352 self.rendered_tool_use_labels
1353 .get(&tool_use.id)
1354 .cloned(),
1355 )
1356 .truncate(),
1357 ),
1358 )
1359 .child(
1360 h_flex()
1361 .gap_1()
1362 .child(
1363 div().visible_on_hover("disclosure-header").child(
1364 Disclosure::new("tool-use-disclosure", is_open)
1365 .opened_icon(IconName::ChevronUp)
1366 .closed_icon(IconName::ChevronDown)
1367 .on_click(cx.listener({
1368 let tool_use_id = tool_use.id.clone();
1369 move |this, _event, _window, _cx| {
1370 let is_open = this
1371 .expanded_tool_uses
1372 .entry(tool_use_id.clone())
1373 .or_insert(false);
1374
1375 *is_open = !*is_open;
1376 }
1377 })),
1378 ),
1379 )
1380 .child({
1381 let (icon_name, color, animated) = match &tool_use.status {
1382 ToolUseStatus::Pending
1383 | ToolUseStatus::NeedsConfirmation => {
1384 (IconName::Warning, Color::Warning, false)
1385 }
1386 ToolUseStatus::Running => {
1387 (IconName::ArrowCircle, Color::Accent, true)
1388 }
1389 ToolUseStatus::Finished(_) => {
1390 (IconName::Check, Color::Success, false)
1391 }
1392 ToolUseStatus::Error(_) => {
1393 (IconName::Close, Color::Error, false)
1394 }
1395 };
1396
1397 let icon =
1398 Icon::new(icon_name).color(color).size(IconSize::Small);
1399
1400 if animated {
1401 icon.with_animation(
1402 "arrow-circle",
1403 Animation::new(Duration::from_secs(2)).repeat(),
1404 |icon, delta| {
1405 icon.transform(Transformation::rotate(percentage(
1406 delta,
1407 )))
1408 },
1409 )
1410 .into_any_element()
1411 } else {
1412 icon.into_any_element()
1413 }
1414 }),
1415 ),
1416 )
1417 .map(|parent| {
1418 if !is_open {
1419 return parent;
1420 }
1421
1422 let content_container = || v_flex().py_1().gap_0p5().px_2p5();
1423
1424 parent.child(
1425 v_flex()
1426 .gap_1()
1427 .bg(cx.theme().colors().editor_background)
1428 .rounded_b_lg()
1429 .child(
1430 content_container()
1431 .border_b_1()
1432 .border_color(lighter_border)
1433 .child(
1434 Label::new("Input")
1435 .size(LabelSize::XSmall)
1436 .color(Color::Muted)
1437 .buffer_font(cx),
1438 )
1439 .child(
1440 Label::new(
1441 serde_json::to_string_pretty(&tool_use.input)
1442 .unwrap_or_default(),
1443 )
1444 .size(LabelSize::Small)
1445 .buffer_font(cx),
1446 ),
1447 )
1448 .map(|container| match tool_use.status {
1449 ToolUseStatus::Finished(output) => container.child(
1450 content_container()
1451 .child(
1452 Label::new("Result")
1453 .size(LabelSize::XSmall)
1454 .color(Color::Muted)
1455 .buffer_font(cx),
1456 )
1457 .child(
1458 Label::new(output)
1459 .size(LabelSize::Small)
1460 .buffer_font(cx),
1461 ),
1462 ),
1463 ToolUseStatus::Running => container.child(
1464 content_container().child(
1465 h_flex()
1466 .gap_1()
1467 .pb_1()
1468 .child(
1469 Icon::new(IconName::ArrowCircle)
1470 .size(IconSize::Small)
1471 .color(Color::Accent)
1472 .with_animation(
1473 "arrow-circle",
1474 Animation::new(Duration::from_secs(2))
1475 .repeat(),
1476 |icon, delta| {
1477 icon.transform(Transformation::rotate(
1478 percentage(delta),
1479 ))
1480 },
1481 ),
1482 )
1483 .child(
1484 Label::new("Running…")
1485 .size(LabelSize::XSmall)
1486 .color(Color::Muted)
1487 .buffer_font(cx),
1488 ),
1489 ),
1490 ),
1491 ToolUseStatus::Error(err) => container.child(
1492 content_container()
1493 .child(
1494 Label::new("Error")
1495 .size(LabelSize::XSmall)
1496 .color(Color::Muted)
1497 .buffer_font(cx),
1498 )
1499 .child(
1500 Label::new(err).size(LabelSize::Small).buffer_font(cx),
1501 ),
1502 ),
1503 ToolUseStatus::Pending => container,
1504 ToolUseStatus::NeedsConfirmation => container.child(
1505 content_container().child(
1506 Label::new("Asking Permission")
1507 .size(LabelSize::Small)
1508 .color(Color::Muted)
1509 .buffer_font(cx),
1510 ),
1511 ),
1512 }),
1513 )
1514 }),
1515 )
1516 }
1517
1518 fn render_rules_item(&self, cx: &Context<Self>) -> AnyElement {
1519 let Some(system_prompt_context) = self.thread.read(cx).system_prompt_context().as_ref()
1520 else {
1521 return div().into_any();
1522 };
1523
1524 let rules_files = system_prompt_context
1525 .worktrees
1526 .iter()
1527 .filter_map(|worktree| worktree.rules_file.as_ref())
1528 .collect::<Vec<_>>();
1529
1530 let label_text = match rules_files.as_slice() {
1531 &[] => return div().into_any(),
1532 &[rules_file] => {
1533 format!("Using {:?} file", rules_file.rel_path)
1534 }
1535 rules_files => {
1536 format!("Using {} rules files", rules_files.len())
1537 }
1538 };
1539
1540 div()
1541 .pt_1()
1542 .px_2p5()
1543 .child(
1544 h_flex()
1545 .w_full()
1546 .gap_0p5()
1547 .child(
1548 h_flex()
1549 .gap_1p5()
1550 .child(
1551 Icon::new(IconName::File)
1552 .size(IconSize::XSmall)
1553 .color(Color::Disabled),
1554 )
1555 .child(
1556 Label::new(label_text)
1557 .size(LabelSize::XSmall)
1558 .color(Color::Muted)
1559 .buffer_font(cx),
1560 ),
1561 )
1562 .child(
1563 IconButton::new("open-rule", IconName::ArrowUpRightAlt)
1564 .shape(ui::IconButtonShape::Square)
1565 .icon_size(IconSize::XSmall)
1566 .icon_color(Color::Ignored)
1567 .on_click(cx.listener(Self::handle_open_rules))
1568 .tooltip(Tooltip::text("View Rules")),
1569 ),
1570 )
1571 .into_any()
1572 }
1573
1574 fn handle_allow_tool(
1575 &mut self,
1576 tool_use_id: LanguageModelToolUseId,
1577 _: &ClickEvent,
1578 _window: &mut Window,
1579 cx: &mut Context<Self>,
1580 ) {
1581 if let Some(PendingToolUseStatus::NeedsConfirmation(c)) = self
1582 .thread
1583 .read(cx)
1584 .pending_tool(&tool_use_id)
1585 .map(|tool_use| tool_use.status.clone())
1586 {
1587 self.thread.update(cx, |thread, cx| {
1588 thread.run_tool(
1589 c.tool_use_id.clone(),
1590 c.ui_text.clone(),
1591 c.input.clone(),
1592 &c.messages,
1593 c.tool.clone(),
1594 cx,
1595 );
1596 });
1597 }
1598 }
1599
1600 fn handle_deny_tool(
1601 &mut self,
1602 tool_use_id: LanguageModelToolUseId,
1603 _: &ClickEvent,
1604 _window: &mut Window,
1605 cx: &mut Context<Self>,
1606 ) {
1607 self.thread.update(cx, |thread, cx| {
1608 thread.deny_tool_use(tool_use_id, cx);
1609 });
1610 }
1611
1612 fn handle_open_rules(&mut self, _: &ClickEvent, window: &mut Window, cx: &mut Context<Self>) {
1613 let Some(system_prompt_context) = self.thread.read(cx).system_prompt_context().as_ref()
1614 else {
1615 return;
1616 };
1617
1618 let abs_paths = system_prompt_context
1619 .worktrees
1620 .iter()
1621 .flat_map(|worktree| worktree.rules_file.as_ref())
1622 .map(|rules_file| rules_file.abs_path.to_path_buf())
1623 .collect::<Vec<_>>();
1624
1625 if let Ok(task) = self.workspace.update(cx, move |workspace, cx| {
1626 // TODO: Open a multibuffer instead? In some cases this doesn't make the set of rules
1627 // files clear. For example, if rules file 1 is already open but rules file 2 is not,
1628 // this would open and focus rules file 2 in a tab that is not next to rules file 1.
1629 workspace.open_paths(abs_paths, OpenOptions::default(), None, window, cx)
1630 }) {
1631 task.detach();
1632 }
1633 }
1634
1635 fn render_confirmations<'a>(
1636 &'a mut self,
1637 cx: &'a mut Context<Self>,
1638 ) -> impl Iterator<Item = AnyElement> + 'a {
1639 let thread = self.thread.read(cx);
1640
1641 thread
1642 .tools_needing_confirmation()
1643 .map(|tool| {
1644 div()
1645 .m_3()
1646 .p_2()
1647 .bg(cx.theme().colors().editor_background)
1648 .border_1()
1649 .border_color(cx.theme().colors().border)
1650 .rounded_lg()
1651 .child(
1652 v_flex()
1653 .gap_1()
1654 .child(
1655 v_flex()
1656 .gap_0p5()
1657 .child(
1658 Label::new("The agent wants to run this action:")
1659 .color(Color::Muted),
1660 )
1661 .child(div().p_3().child(Label::new(&tool.ui_text))),
1662 )
1663 .child(
1664 h_flex()
1665 .gap_1()
1666 .child({
1667 let tool_id = tool.id.clone();
1668 Button::new("allow-tool-action", "Allow").on_click(
1669 cx.listener(move |this, event, window, cx| {
1670 this.handle_allow_tool(
1671 tool_id.clone(),
1672 event,
1673 window,
1674 cx,
1675 )
1676 }),
1677 )
1678 })
1679 .child({
1680 let tool_id = tool.id.clone();
1681 Button::new("deny-tool", "Deny").on_click(cx.listener(
1682 move |this, event, window, cx| {
1683 this.handle_deny_tool(
1684 tool_id.clone(),
1685 event,
1686 window,
1687 cx,
1688 )
1689 },
1690 ))
1691 }),
1692 )
1693 .child(
1694 Label::new("Note: A future release will introduce a way to remember your answers to these. In the meantime, you can avoid these prompts by adding \"assistant\": { \"always_allow_tool_actions\": true } to your settings.json.")
1695 .color(Color::Muted)
1696 .size(LabelSize::Small),
1697 ),
1698 )
1699 .into_any()
1700 })
1701 }
1702
1703 fn dismiss_notifications(&mut self, cx: &mut Context<'_, ActiveThread>) {
1704 for window in self.pop_ups.drain(..) {
1705 window
1706 .update(cx, |_, window, _| {
1707 window.remove_window();
1708 })
1709 .ok();
1710 }
1711 }
1712}
1713
1714impl Render for ActiveThread {
1715 fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
1716 v_flex()
1717 .size_full()
1718 .child(list(self.list_state.clone()).flex_grow())
1719 .children(self.render_confirmations(cx))
1720 }
1721}