1use crate::{
2 assistant_settings::{AssistantDockPosition, AssistantSettings, ZedDotDevModel},
3 codegen::{self, Codegen, CodegenKind},
4 embedded_scope::EmbeddedScope,
5 prompts::generate_content_prompt,
6 Assist, CompletionProvider, CycleMessageRole, InlineAssist, LanguageModel,
7 LanguageModelRequest, LanguageModelRequestMessage, MessageId, MessageMetadata, MessageStatus,
8 NewConversation, QuoteSelection, ResetKey, Role, SavedConversation, SavedConversationMetadata,
9 SavedMessage, Split, ToggleFocus, ToggleIncludeConversation,
10};
11use anyhow::{anyhow, Result};
12use chrono::{DateTime, Local};
13use collections::{hash_map, HashMap, HashSet, VecDeque};
14use editor::{
15 actions::{MoveDown, MoveUp},
16 display_map::{
17 BlockContext, BlockDisposition, BlockId, BlockProperties, BlockStyle, ToDisplayPoint,
18 },
19 scroll::{Autoscroll, AutoscrollStrategy},
20 Anchor, Editor, EditorElement, EditorEvent, EditorStyle, MultiBuffer, MultiBufferSnapshot,
21 ToOffset as _, ToPoint,
22};
23use file_icons::FileIcons;
24use fs::Fs;
25use futures::StreamExt;
26use gpui::{
27 canvas, div, point, relative, rems, uniform_list, Action, AnyElement, AnyView, AppContext,
28 AsyncAppContext, AsyncWindowContext, AvailableSpace, ClipboardItem, Context, EventEmitter,
29 FocusHandle, FocusableView, FontStyle, FontWeight, HighlightStyle, InteractiveElement,
30 IntoElement, Model, ModelContext, ParentElement, Pixels, Render, SharedString,
31 StatefulInteractiveElement, Styled, Subscription, Task, TextStyle, UniformListScrollHandle,
32 View, ViewContext, VisualContext, WeakModel, WeakView, WhiteSpace, WindowContext,
33};
34use language::{language_settings::SoftWrap, Buffer, LanguageRegistry, ToOffset as _};
35use parking_lot::Mutex;
36use project::Project;
37use search::{buffer_search::DivRegistrar, BufferSearchBar};
38use settings::Settings;
39use std::{cmp, fmt::Write, iter, ops::Range, path::PathBuf, sync::Arc, time::Duration};
40use telemetry_events::AssistantKind;
41use theme::ThemeSettings;
42use ui::{
43 prelude::*,
44 utils::{DateTimeType, FormatDistance},
45 ButtonLike, Tab, TabBar, Tooltip,
46};
47use util::{paths::CONVERSATIONS_DIR, post_inc, ResultExt, TryFutureExt};
48use uuid::Uuid;
49use workspace::notifications::NotificationId;
50use workspace::{
51 dock::{DockPosition, Panel, PanelEvent},
52 searchable::Direction,
53 Event as WorkspaceEvent, Save, Toast, ToggleZoom, Toolbar, Workspace,
54};
55
56pub fn init(cx: &mut AppContext) {
57 cx.observe_new_views(
58 |workspace: &mut Workspace, _cx: &mut ViewContext<Workspace>| {
59 workspace
60 .register_action(|workspace, _: &ToggleFocus, cx| {
61 let settings = AssistantSettings::get_global(cx);
62 if !settings.enabled {
63 return;
64 }
65
66 workspace.toggle_panel_focus::<AssistantPanel>(cx);
67 })
68 .register_action(AssistantPanel::inline_assist)
69 .register_action(AssistantPanel::cancel_last_inline_assist)
70 .register_action(ConversationEditor::quote_selection);
71 },
72 )
73 .detach();
74}
75
76pub struct AssistantPanel {
77 workspace: WeakView<Workspace>,
78 width: Option<Pixels>,
79 height: Option<Pixels>,
80 active_conversation_editor: Option<ActiveConversationEditor>,
81 show_saved_conversations: bool,
82 saved_conversations: Vec<SavedConversationMetadata>,
83 saved_conversations_scroll_handle: UniformListScrollHandle,
84 zoomed: bool,
85 focus_handle: FocusHandle,
86 toolbar: View<Toolbar>,
87 languages: Arc<LanguageRegistry>,
88 fs: Arc<dyn Fs>,
89 _subscriptions: Vec<Subscription>,
90 next_inline_assist_id: usize,
91 pending_inline_assists: HashMap<usize, PendingInlineAssist>,
92 pending_inline_assist_ids_by_editor: HashMap<WeakView<Editor>, Vec<usize>>,
93 include_conversation_in_next_inline_assist: bool,
94 inline_prompt_history: VecDeque<String>,
95 _watch_saved_conversations: Task<Result<()>>,
96 model: LanguageModel,
97 authentication_prompt: Option<AnyView>,
98}
99
100struct ActiveConversationEditor {
101 editor: View<ConversationEditor>,
102 _subscriptions: Vec<Subscription>,
103}
104
105impl AssistantPanel {
106 const INLINE_PROMPT_HISTORY_MAX_LEN: usize = 20;
107
108 pub fn load(
109 workspace: WeakView<Workspace>,
110 cx: AsyncWindowContext,
111 ) -> Task<Result<View<Self>>> {
112 cx.spawn(|mut cx| async move {
113 let fs = workspace.update(&mut cx, |workspace, _| workspace.app_state().fs.clone())?;
114 let saved_conversations = SavedConversationMetadata::list(fs.clone())
115 .await
116 .log_err()
117 .unwrap_or_default();
118
119 // TODO: deserialize state.
120 let workspace_handle = workspace.clone();
121 workspace.update(&mut cx, |workspace, cx| {
122 cx.new_view::<Self>(|cx| {
123 const CONVERSATION_WATCH_DURATION: Duration = Duration::from_millis(100);
124 let _watch_saved_conversations = cx.spawn(move |this, mut cx| async move {
125 let mut events = fs
126 .watch(&CONVERSATIONS_DIR, CONVERSATION_WATCH_DURATION)
127 .await;
128 while events.next().await.is_some() {
129 let saved_conversations = SavedConversationMetadata::list(fs.clone())
130 .await
131 .log_err()
132 .unwrap_or_default();
133 this.update(&mut cx, |this, cx| {
134 this.saved_conversations = saved_conversations;
135 cx.notify();
136 })
137 .ok();
138 }
139
140 anyhow::Ok(())
141 });
142
143 let toolbar = cx.new_view(|cx| {
144 let mut toolbar = Toolbar::new();
145 toolbar.set_can_navigate(false, cx);
146 toolbar.add_item(cx.new_view(BufferSearchBar::new), cx);
147 toolbar
148 });
149
150 let focus_handle = cx.focus_handle();
151 let subscriptions = vec![
152 cx.on_focus_in(&focus_handle, Self::focus_in),
153 cx.on_focus_out(&focus_handle, Self::focus_out),
154 cx.observe_global::<CompletionProvider>({
155 let mut prev_settings_version =
156 CompletionProvider::global(cx).settings_version();
157 move |this, cx| {
158 this.completion_provider_changed(prev_settings_version, cx);
159 prev_settings_version =
160 CompletionProvider::global(cx).settings_version();
161 }
162 }),
163 ];
164 let model = CompletionProvider::global(cx).default_model();
165
166 cx.observe_global::<FileIcons>(|_, cx| {
167 cx.notify();
168 })
169 .detach();
170
171 Self {
172 workspace: workspace_handle,
173 active_conversation_editor: None,
174 show_saved_conversations: false,
175 saved_conversations,
176 saved_conversations_scroll_handle: Default::default(),
177 zoomed: false,
178 focus_handle,
179 toolbar,
180 languages: workspace.app_state().languages.clone(),
181 fs: workspace.app_state().fs.clone(),
182 width: None,
183 height: None,
184 _subscriptions: subscriptions,
185 next_inline_assist_id: 0,
186 pending_inline_assists: Default::default(),
187 pending_inline_assist_ids_by_editor: Default::default(),
188 include_conversation_in_next_inline_assist: false,
189 inline_prompt_history: Default::default(),
190 _watch_saved_conversations,
191 model,
192 authentication_prompt: None,
193 }
194 })
195 })
196 })
197 }
198
199 fn focus_in(&mut self, cx: &mut ViewContext<Self>) {
200 self.toolbar
201 .update(cx, |toolbar, cx| toolbar.focus_changed(true, cx));
202 cx.notify();
203 if self.focus_handle.is_focused(cx) {
204 if let Some(editor) = self.active_conversation_editor() {
205 cx.focus_view(editor);
206 }
207 }
208 }
209
210 fn focus_out(&mut self, cx: &mut ViewContext<Self>) {
211 self.toolbar
212 .update(cx, |toolbar, cx| toolbar.focus_changed(false, cx));
213 cx.notify();
214 }
215
216 fn completion_provider_changed(
217 &mut self,
218 prev_settings_version: usize,
219 cx: &mut ViewContext<Self>,
220 ) {
221 if self.is_authenticated(cx) {
222 self.authentication_prompt = None;
223
224 let model = CompletionProvider::global(cx).default_model();
225 self.set_model(model, cx);
226
227 if self.active_conversation_editor().is_none() {
228 self.new_conversation(cx);
229 }
230 } else if self.authentication_prompt.is_none()
231 || prev_settings_version != CompletionProvider::global(cx).settings_version()
232 {
233 self.authentication_prompt =
234 Some(cx.update_global::<CompletionProvider, _>(|provider, cx| {
235 provider.authentication_prompt(cx)
236 }));
237 }
238 }
239
240 pub fn inline_assist(
241 workspace: &mut Workspace,
242 _: &InlineAssist,
243 cx: &mut ViewContext<Workspace>,
244 ) {
245 let settings = AssistantSettings::get_global(cx);
246 if !settings.enabled {
247 return;
248 }
249
250 let Some(assistant) = workspace.panel::<AssistantPanel>(cx) else {
251 return;
252 };
253 let active_editor = if let Some(active_editor) = workspace
254 .active_item(cx)
255 .and_then(|item| item.act_as::<Editor>(cx))
256 {
257 active_editor
258 } else {
259 return;
260 };
261 let project = workspace.project().clone();
262
263 if assistant.update(cx, |assistant, cx| assistant.is_authenticated(cx)) {
264 assistant.update(cx, |assistant, cx| {
265 assistant.new_inline_assist(&active_editor, cx, &project)
266 });
267 } else {
268 let assistant = assistant.downgrade();
269 cx.spawn(|workspace, mut cx| async move {
270 assistant
271 .update(&mut cx, |assistant, cx| assistant.authenticate(cx))?
272 .await?;
273 if assistant.update(&mut cx, |assistant, cx| assistant.is_authenticated(cx))? {
274 assistant.update(&mut cx, |assistant, cx| {
275 assistant.new_inline_assist(&active_editor, cx, &project)
276 })?;
277 } else {
278 workspace.update(&mut cx, |workspace, cx| {
279 workspace.focus_panel::<AssistantPanel>(cx)
280 })?;
281 }
282
283 anyhow::Ok(())
284 })
285 .detach_and_log_err(cx)
286 }
287 }
288
289 fn new_inline_assist(
290 &mut self,
291 editor: &View<Editor>,
292 cx: &mut ViewContext<Self>,
293 project: &Model<Project>,
294 ) {
295 let selection = editor.read(cx).selections.newest_anchor().clone();
296 if selection.start.excerpt_id != selection.end.excerpt_id {
297 return;
298 }
299 let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
300
301 // Extend the selection to the start and the end of the line.
302 let mut point_selection = selection.map(|selection| selection.to_point(&snapshot));
303 if point_selection.end > point_selection.start {
304 point_selection.start.column = 0;
305 // If the selection ends at the start of the line, we don't want to include it.
306 if point_selection.end.column == 0 {
307 point_selection.end.row -= 1;
308 }
309 point_selection.end.column = snapshot.line_len(point_selection.end.row);
310 }
311
312 let codegen_kind = if point_selection.start == point_selection.end {
313 CodegenKind::Generate {
314 position: snapshot.anchor_after(point_selection.start),
315 }
316 } else {
317 CodegenKind::Transform {
318 range: snapshot.anchor_before(point_selection.start)
319 ..snapshot.anchor_after(point_selection.end),
320 }
321 };
322
323 let inline_assist_id = post_inc(&mut self.next_inline_assist_id);
324
325 let codegen =
326 cx.new_model(|cx| Codegen::new(editor.read(cx).buffer().clone(), codegen_kind, cx));
327
328 let measurements = Arc::new(Mutex::new(BlockMeasurements::default()));
329 let inline_assistant = cx.new_view(|cx| {
330 InlineAssistant::new(
331 inline_assist_id,
332 measurements.clone(),
333 self.include_conversation_in_next_inline_assist,
334 self.inline_prompt_history.clone(),
335 codegen.clone(),
336 self.workspace.clone(),
337 cx,
338 )
339 });
340 let block_id = editor.update(cx, |editor, cx| {
341 editor.change_selections(None, cx, |selections| {
342 selections.select_anchor_ranges([selection.head()..selection.head()])
343 });
344 editor.insert_blocks(
345 [BlockProperties {
346 style: BlockStyle::Flex,
347 position: snapshot.anchor_before(point_selection.head()),
348 height: 2,
349 render: Box::new({
350 let inline_assistant = inline_assistant.clone();
351 move |cx: &mut BlockContext| {
352 *measurements.lock() = BlockMeasurements {
353 anchor_x: cx.anchor_x,
354 gutter_width: cx.gutter_dimensions.width,
355 };
356 inline_assistant.clone().into_any_element()
357 }
358 }),
359 disposition: if selection.reversed {
360 BlockDisposition::Above
361 } else {
362 BlockDisposition::Below
363 },
364 }],
365 Some(Autoscroll::Strategy(AutoscrollStrategy::Newest)),
366 cx,
367 )[0]
368 });
369
370 self.pending_inline_assists.insert(
371 inline_assist_id,
372 PendingInlineAssist {
373 editor: editor.downgrade(),
374 inline_assistant: Some((block_id, inline_assistant.clone())),
375 codegen: codegen.clone(),
376 project: project.downgrade(),
377 _subscriptions: vec![
378 cx.subscribe(&inline_assistant, Self::handle_inline_assistant_event),
379 cx.subscribe(editor, {
380 let inline_assistant = inline_assistant.downgrade();
381 move |_, editor, event, cx| {
382 if let Some(inline_assistant) = inline_assistant.upgrade() {
383 if let EditorEvent::SelectionsChanged { local } = event {
384 if *local
385 && inline_assistant.focus_handle(cx).contains_focused(cx)
386 {
387 cx.focus_view(&editor);
388 }
389 }
390 }
391 }
392 }),
393 cx.observe(&codegen, {
394 let editor = editor.downgrade();
395 move |this, _, cx| {
396 if let Some(editor) = editor.upgrade() {
397 this.update_highlights_for_editor(&editor, cx);
398 }
399 }
400 }),
401 cx.subscribe(&codegen, move |this, codegen, event, cx| match event {
402 codegen::Event::Undone => {
403 this.finish_inline_assist(inline_assist_id, false, cx)
404 }
405 codegen::Event::Finished => {
406 let pending_assist = if let Some(pending_assist) =
407 this.pending_inline_assists.get(&inline_assist_id)
408 {
409 pending_assist
410 } else {
411 return;
412 };
413
414 let error = codegen
415 .read(cx)
416 .error()
417 .map(|error| format!("Inline assistant error: {}", error));
418 if let Some(error) = error {
419 if pending_assist.inline_assistant.is_none() {
420 if let Some(workspace) = this.workspace.upgrade() {
421 workspace.update(cx, |workspace, cx| {
422 struct InlineAssistantError;
423
424 let id =
425 NotificationId::identified::<InlineAssistantError>(
426 inline_assist_id,
427 );
428
429 workspace.show_toast(Toast::new(id, error), cx);
430 })
431 }
432
433 this.finish_inline_assist(inline_assist_id, false, cx);
434 }
435 } else {
436 this.finish_inline_assist(inline_assist_id, false, cx);
437 }
438 }
439 }),
440 ],
441 },
442 );
443 self.pending_inline_assist_ids_by_editor
444 .entry(editor.downgrade())
445 .or_default()
446 .push(inline_assist_id);
447 self.update_highlights_for_editor(editor, cx);
448 }
449
450 fn handle_inline_assistant_event(
451 &mut self,
452 inline_assistant: View<InlineAssistant>,
453 event: &InlineAssistantEvent,
454 cx: &mut ViewContext<Self>,
455 ) {
456 let assist_id = inline_assistant.read(cx).id;
457 match event {
458 InlineAssistantEvent::Confirmed {
459 prompt,
460 include_conversation,
461 } => {
462 self.confirm_inline_assist(assist_id, prompt, *include_conversation, cx);
463 }
464 InlineAssistantEvent::Canceled => {
465 self.finish_inline_assist(assist_id, true, cx);
466 }
467 InlineAssistantEvent::Dismissed => {
468 self.hide_inline_assist(assist_id, cx);
469 }
470 InlineAssistantEvent::IncludeConversationToggled {
471 include_conversation,
472 } => {
473 self.include_conversation_in_next_inline_assist = *include_conversation;
474 }
475 }
476 }
477
478 fn cancel_last_inline_assist(
479 workspace: &mut Workspace,
480 _: &editor::actions::Cancel,
481 cx: &mut ViewContext<Workspace>,
482 ) {
483 if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
484 if let Some(editor) = workspace
485 .active_item(cx)
486 .and_then(|item| item.downcast::<Editor>())
487 {
488 let handled = panel.update(cx, |panel, cx| {
489 if let Some(assist_id) = panel
490 .pending_inline_assist_ids_by_editor
491 .get(&editor.downgrade())
492 .and_then(|assist_ids| assist_ids.last().copied())
493 {
494 panel.finish_inline_assist(assist_id, true, cx);
495 true
496 } else {
497 false
498 }
499 });
500 if handled {
501 return;
502 }
503 }
504 }
505
506 cx.propagate();
507 }
508
509 fn finish_inline_assist(&mut self, assist_id: usize, undo: bool, cx: &mut ViewContext<Self>) {
510 self.hide_inline_assist(assist_id, cx);
511
512 if let Some(pending_assist) = self.pending_inline_assists.remove(&assist_id) {
513 if let hash_map::Entry::Occupied(mut entry) = self
514 .pending_inline_assist_ids_by_editor
515 .entry(pending_assist.editor.clone())
516 {
517 entry.get_mut().retain(|id| *id != assist_id);
518 if entry.get().is_empty() {
519 entry.remove();
520 }
521 }
522
523 if let Some(editor) = pending_assist.editor.upgrade() {
524 self.update_highlights_for_editor(&editor, cx);
525
526 if undo {
527 pending_assist
528 .codegen
529 .update(cx, |codegen, cx| codegen.undo(cx));
530 }
531 }
532 }
533 }
534
535 fn hide_inline_assist(&mut self, assist_id: usize, cx: &mut ViewContext<Self>) {
536 if let Some(pending_assist) = self.pending_inline_assists.get_mut(&assist_id) {
537 if let Some(editor) = pending_assist.editor.upgrade() {
538 if let Some((block_id, inline_assistant)) = pending_assist.inline_assistant.take() {
539 editor.update(cx, |editor, cx| {
540 editor.remove_blocks(HashSet::from_iter([block_id]), None, cx);
541 if inline_assistant.focus_handle(cx).contains_focused(cx) {
542 editor.focus(cx);
543 }
544 });
545 }
546 }
547 }
548 }
549
550 fn confirm_inline_assist(
551 &mut self,
552 inline_assist_id: usize,
553 user_prompt: &str,
554 include_conversation: bool,
555 cx: &mut ViewContext<Self>,
556 ) {
557 let conversation = if include_conversation {
558 self.active_conversation_editor()
559 .map(|editor| editor.read(cx).conversation.clone())
560 } else {
561 None
562 };
563
564 let pending_assist =
565 if let Some(pending_assist) = self.pending_inline_assists.get_mut(&inline_assist_id) {
566 pending_assist
567 } else {
568 return;
569 };
570
571 let editor = if let Some(editor) = pending_assist.editor.upgrade() {
572 editor
573 } else {
574 return;
575 };
576
577 let project = pending_assist.project.clone();
578
579 let project_name = project.upgrade().map(|project| {
580 project
581 .read(cx)
582 .worktree_root_names(cx)
583 .collect::<Vec<&str>>()
584 .join("/")
585 });
586
587 self.inline_prompt_history
588 .retain(|prompt| prompt != user_prompt);
589 self.inline_prompt_history.push_back(user_prompt.into());
590 if self.inline_prompt_history.len() > Self::INLINE_PROMPT_HISTORY_MAX_LEN {
591 self.inline_prompt_history.pop_front();
592 }
593
594 let codegen = pending_assist.codegen.clone();
595 let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
596 let range = codegen.read(cx).range();
597 let start = snapshot.point_to_buffer_offset(range.start);
598 let end = snapshot.point_to_buffer_offset(range.end);
599 let (buffer, range) = if let Some((start, end)) = start.zip(end) {
600 let (start_buffer, start_buffer_offset) = start;
601 let (end_buffer, end_buffer_offset) = end;
602 if start_buffer.remote_id() == end_buffer.remote_id() {
603 (start_buffer.clone(), start_buffer_offset..end_buffer_offset)
604 } else {
605 self.finish_inline_assist(inline_assist_id, false, cx);
606 return;
607 }
608 } else {
609 self.finish_inline_assist(inline_assist_id, false, cx);
610 return;
611 };
612
613 let language = buffer.language_at(range.start);
614 let language_name = if let Some(language) = language.as_ref() {
615 if Arc::ptr_eq(language, &language::PLAIN_TEXT) {
616 None
617 } else {
618 Some(language.name())
619 }
620 } else {
621 None
622 };
623
624 // Higher Temperature increases the randomness of model outputs.
625 // If Markdown or No Language is Known, increase the randomness for more creative output
626 // If Code, decrease temperature to get more deterministic outputs
627 let temperature = if let Some(language) = language_name.clone() {
628 if language.as_ref() == "Markdown" {
629 1.0
630 } else {
631 0.5
632 }
633 } else {
634 1.0
635 };
636
637 let user_prompt = user_prompt.to_string();
638
639 let prompt = cx.background_executor().spawn(async move {
640 let language_name = language_name.as_deref();
641 generate_content_prompt(user_prompt, language_name, buffer, range, project_name)
642 });
643
644 let mut messages = Vec::new();
645 if let Some(conversation) = conversation {
646 let conversation = conversation.read(cx);
647 let buffer = conversation.buffer.read(cx);
648 messages.extend(
649 conversation
650 .messages(cx)
651 .map(|message| message.to_open_ai_message(buffer)),
652 );
653 }
654 let model = self.model.clone();
655
656 cx.spawn(|_, mut cx| async move {
657 // I Don't know if we want to return a ? here.
658 let prompt = prompt.await?;
659
660 messages.push(LanguageModelRequestMessage {
661 role: Role::User,
662 content: prompt,
663 });
664
665 let request = LanguageModelRequest {
666 model,
667 messages,
668 stop: vec!["|END|>".to_string()],
669 temperature,
670 };
671
672 codegen.update(&mut cx, |codegen, cx| codegen.start(request, cx))?;
673 anyhow::Ok(())
674 })
675 .detach();
676 }
677
678 fn update_highlights_for_editor(&self, editor: &View<Editor>, cx: &mut ViewContext<Self>) {
679 let mut background_ranges = Vec::new();
680 let mut foreground_ranges = Vec::new();
681 let empty_inline_assist_ids = Vec::new();
682 let inline_assist_ids = self
683 .pending_inline_assist_ids_by_editor
684 .get(&editor.downgrade())
685 .unwrap_or(&empty_inline_assist_ids);
686
687 for inline_assist_id in inline_assist_ids {
688 if let Some(pending_assist) = self.pending_inline_assists.get(inline_assist_id) {
689 let codegen = pending_assist.codegen.read(cx);
690 background_ranges.push(codegen.range());
691 foreground_ranges.extend(codegen.last_equal_ranges().iter().cloned());
692 }
693 }
694
695 let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
696 merge_ranges(&mut background_ranges, &snapshot);
697 merge_ranges(&mut foreground_ranges, &snapshot);
698 editor.update(cx, |editor, cx| {
699 if background_ranges.is_empty() {
700 editor.clear_background_highlights::<PendingInlineAssist>(cx);
701 } else {
702 editor.highlight_background::<PendingInlineAssist>(
703 &background_ranges,
704 |theme| theme.editor_active_line_background, // TODO use the appropriate color
705 cx,
706 );
707 }
708
709 if foreground_ranges.is_empty() {
710 editor.clear_highlights::<PendingInlineAssist>(cx);
711 } else {
712 editor.highlight_text::<PendingInlineAssist>(
713 foreground_ranges,
714 HighlightStyle {
715 fade_out: Some(0.6),
716 ..Default::default()
717 },
718 cx,
719 );
720 }
721 });
722 }
723
724 fn new_conversation(&mut self, cx: &mut ViewContext<Self>) -> Option<View<ConversationEditor>> {
725 let workspace = self.workspace.upgrade()?;
726
727 let editor = cx.new_view(|cx| {
728 ConversationEditor::new(
729 self.model.clone(),
730 self.languages.clone(),
731 self.fs.clone(),
732 workspace,
733 cx,
734 )
735 });
736 self.show_conversation(editor.clone(), cx);
737 Some(editor)
738 }
739
740 fn show_conversation(
741 &mut self,
742 conversation_editor: View<ConversationEditor>,
743 cx: &mut ViewContext<Self>,
744 ) {
745 let mut subscriptions = Vec::new();
746 subscriptions
747 .push(cx.subscribe(&conversation_editor, Self::handle_conversation_editor_event));
748
749 let conversation = conversation_editor.read(cx).conversation.clone();
750 subscriptions.push(cx.observe(&conversation, |_, _, cx| cx.notify()));
751
752 let editor = conversation_editor.read(cx).editor.clone();
753 self.toolbar.update(cx, |toolbar, cx| {
754 toolbar.set_active_item(Some(&editor), cx);
755 });
756 if self.focus_handle.contains_focused(cx) {
757 cx.focus_view(&editor);
758 }
759 self.active_conversation_editor = Some(ActiveConversationEditor {
760 editor: conversation_editor,
761 _subscriptions: subscriptions,
762 });
763 self.show_saved_conversations = false;
764
765 cx.notify();
766 }
767
768 fn cycle_model(&mut self, cx: &mut ViewContext<Self>) {
769 let next_model = match &self.model {
770 LanguageModel::OpenAi(model) => LanguageModel::OpenAi(match &model {
771 open_ai::Model::ThreePointFiveTurbo => open_ai::Model::Four,
772 open_ai::Model::Four => open_ai::Model::FourTurbo,
773 open_ai::Model::FourTurbo => open_ai::Model::ThreePointFiveTurbo,
774 }),
775 LanguageModel::ZedDotDev(model) => LanguageModel::ZedDotDev(match &model {
776 ZedDotDevModel::Gpt3Point5Turbo => ZedDotDevModel::Gpt4,
777 ZedDotDevModel::Gpt4 => ZedDotDevModel::Gpt4Turbo,
778 ZedDotDevModel::Gpt4Turbo => ZedDotDevModel::Claude3Opus,
779 ZedDotDevModel::Claude3Opus => ZedDotDevModel::Claude3Sonnet,
780 ZedDotDevModel::Claude3Sonnet => ZedDotDevModel::Claude3Haiku,
781 ZedDotDevModel::Claude3Haiku => {
782 match CompletionProvider::global(cx).default_model() {
783 LanguageModel::ZedDotDev(custom) => custom,
784 _ => ZedDotDevModel::Gpt3Point5Turbo,
785 }
786 }
787 ZedDotDevModel::Custom(_) => ZedDotDevModel::Gpt3Point5Turbo,
788 }),
789 };
790
791 self.set_model(next_model, cx);
792 }
793
794 fn set_model(&mut self, model: LanguageModel, cx: &mut ViewContext<Self>) {
795 self.model = model.clone();
796 if let Some(editor) = self.active_conversation_editor() {
797 editor.update(cx, |active_conversation, cx| {
798 active_conversation
799 .conversation
800 .update(cx, |conversation, cx| {
801 conversation.set_model(model, cx);
802 })
803 })
804 }
805 cx.notify();
806 }
807
808 fn handle_conversation_editor_event(
809 &mut self,
810 _: View<ConversationEditor>,
811 event: &ConversationEditorEvent,
812 cx: &mut ViewContext<Self>,
813 ) {
814 match event {
815 ConversationEditorEvent::TabContentChanged => cx.notify(),
816 }
817 }
818
819 fn toggle_zoom(&mut self, _: &workspace::ToggleZoom, cx: &mut ViewContext<Self>) {
820 if self.zoomed {
821 cx.emit(PanelEvent::ZoomOut)
822 } else {
823 cx.emit(PanelEvent::ZoomIn)
824 }
825 }
826
827 fn deploy(&mut self, action: &search::buffer_search::Deploy, cx: &mut ViewContext<Self>) {
828 let mut propagate = true;
829 if let Some(search_bar) = self.toolbar.read(cx).item_of_type::<BufferSearchBar>() {
830 search_bar.update(cx, |search_bar, cx| {
831 if search_bar.show(cx) {
832 search_bar.search_suggested(cx);
833 if action.focus {
834 let focus_handle = search_bar.focus_handle(cx);
835 search_bar.select_query(cx);
836 cx.focus(&focus_handle);
837 }
838 propagate = false
839 }
840 });
841 }
842 if propagate {
843 cx.propagate();
844 }
845 }
846
847 fn handle_editor_cancel(&mut self, _: &editor::actions::Cancel, cx: &mut ViewContext<Self>) {
848 if let Some(search_bar) = self.toolbar.read(cx).item_of_type::<BufferSearchBar>() {
849 if !search_bar.read(cx).is_dismissed() {
850 search_bar.update(cx, |search_bar, cx| {
851 search_bar.dismiss(&Default::default(), cx)
852 });
853 return;
854 }
855 }
856 cx.propagate();
857 }
858
859 fn select_next_match(&mut self, _: &search::SelectNextMatch, cx: &mut ViewContext<Self>) {
860 if let Some(search_bar) = self.toolbar.read(cx).item_of_type::<BufferSearchBar>() {
861 search_bar.update(cx, |bar, cx| bar.select_match(Direction::Next, 1, cx));
862 }
863 }
864
865 fn select_prev_match(&mut self, _: &search::SelectPrevMatch, cx: &mut ViewContext<Self>) {
866 if let Some(search_bar) = self.toolbar.read(cx).item_of_type::<BufferSearchBar>() {
867 search_bar.update(cx, |bar, cx| bar.select_match(Direction::Prev, 1, cx));
868 }
869 }
870
871 fn reset_credentials(&mut self, _: &ResetKey, cx: &mut ViewContext<Self>) {
872 CompletionProvider::global(cx)
873 .reset_credentials(cx)
874 .detach_and_log_err(cx);
875 }
876
877 fn active_conversation_editor(&self) -> Option<&View<ConversationEditor>> {
878 Some(&self.active_conversation_editor.as_ref()?.editor)
879 }
880
881 fn render_hamburger_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
882 IconButton::new("hamburger_button", IconName::Menu)
883 .on_click(cx.listener(|this, _event, cx| {
884 this.show_saved_conversations = !this.show_saved_conversations;
885 cx.notify();
886 }))
887 .tooltip(|cx| Tooltip::text("Conversation History", cx))
888 }
889
890 fn render_editor_tools(&self, cx: &mut ViewContext<Self>) -> Vec<AnyElement> {
891 if self.active_conversation_editor().is_some() {
892 vec![
893 Self::render_split_button(cx).into_any_element(),
894 Self::render_quote_button(cx).into_any_element(),
895 Self::render_assist_button(cx).into_any_element(),
896 ]
897 } else {
898 Default::default()
899 }
900 }
901
902 fn render_split_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
903 IconButton::new("split_button", IconName::Snip)
904 .on_click(cx.listener(|this, _event, cx| {
905 if let Some(active_editor) = this.active_conversation_editor() {
906 active_editor.update(cx, |editor, cx| editor.split(&Default::default(), cx));
907 }
908 }))
909 .icon_size(IconSize::Small)
910 .tooltip(|cx| Tooltip::for_action("Split Message", &Split, cx))
911 }
912
913 fn render_assist_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
914 IconButton::new("assist_button", IconName::MagicWand)
915 .on_click(cx.listener(|this, _event, cx| {
916 if let Some(active_editor) = this.active_conversation_editor() {
917 active_editor.update(cx, |editor, cx| editor.assist(&Default::default(), cx));
918 }
919 }))
920 .icon_size(IconSize::Small)
921 .tooltip(|cx| Tooltip::for_action("Assist", &Assist, cx))
922 }
923
924 fn render_quote_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
925 IconButton::new("quote_button", IconName::Quote)
926 .on_click(cx.listener(|this, _event, cx| {
927 if let Some(workspace) = this.workspace.upgrade() {
928 cx.window_context().defer(move |cx| {
929 workspace.update(cx, |workspace, cx| {
930 ConversationEditor::quote_selection(workspace, &Default::default(), cx)
931 });
932 });
933 }
934 }))
935 .icon_size(IconSize::Small)
936 .tooltip(|cx| Tooltip::for_action("Quote Selection", &QuoteSelection, cx))
937 }
938
939 fn render_plus_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
940 IconButton::new("plus_button", IconName::Plus)
941 .on_click(cx.listener(|this, _event, cx| {
942 this.new_conversation(cx);
943 }))
944 .icon_size(IconSize::Small)
945 .tooltip(|cx| Tooltip::for_action("New Conversation", &NewConversation, cx))
946 }
947
948 fn render_zoom_button(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
949 let zoomed = self.zoomed;
950 IconButton::new("zoom_button", IconName::Maximize)
951 .on_click(cx.listener(|this, _event, cx| {
952 this.toggle_zoom(&ToggleZoom, cx);
953 }))
954 .selected(zoomed)
955 .selected_icon(IconName::Minimize)
956 .icon_size(IconSize::Small)
957 .tooltip(move |cx| {
958 Tooltip::for_action(if zoomed { "Zoom Out" } else { "Zoom In" }, &ToggleZoom, cx)
959 })
960 }
961
962 fn render_saved_conversation(
963 &mut self,
964 index: usize,
965 cx: &mut ViewContext<Self>,
966 ) -> impl IntoElement {
967 let conversation = &self.saved_conversations[index];
968 let path = conversation.path.clone();
969
970 ButtonLike::new(index)
971 .on_click(cx.listener(move |this, _, cx| {
972 this.open_conversation(path.clone(), cx)
973 .detach_and_log_err(cx)
974 }))
975 .full_width()
976 .child(
977 div()
978 .flex()
979 .w_full()
980 .gap_2()
981 .child(
982 Label::new(conversation.mtime.format("%F %I:%M%p").to_string())
983 .color(Color::Muted)
984 .size(LabelSize::Small),
985 )
986 .child(Label::new(conversation.title.clone()).size(LabelSize::Small)),
987 )
988 }
989
990 fn open_conversation(&mut self, path: PathBuf, cx: &mut ViewContext<Self>) -> Task<Result<()>> {
991 cx.focus(&self.focus_handle);
992
993 let fs = self.fs.clone();
994 let workspace = self.workspace.clone();
995 let languages = self.languages.clone();
996 cx.spawn(|this, mut cx| async move {
997 let saved_conversation = SavedConversation::load(&path, fs.as_ref()).await?;
998 let model = this.update(&mut cx, |this, _| this.model.clone())?;
999 let conversation = Conversation::deserialize(
1000 saved_conversation,
1001 model,
1002 path.clone(),
1003 languages,
1004 &mut cx,
1005 )
1006 .await?;
1007
1008 this.update(&mut cx, |this, cx| {
1009 let workspace = workspace
1010 .upgrade()
1011 .ok_or_else(|| anyhow!("workspace dropped"))?;
1012 let editor = cx.new_view(|cx| {
1013 ConversationEditor::for_conversation(conversation, fs, workspace, cx)
1014 });
1015 this.show_conversation(editor, cx);
1016 anyhow::Ok(())
1017 })??;
1018 Ok(())
1019 })
1020 }
1021
1022 fn is_authenticated(&mut self, cx: &mut ViewContext<Self>) -> bool {
1023 CompletionProvider::global(cx).is_authenticated()
1024 }
1025
1026 fn authenticate(&mut self, cx: &mut ViewContext<Self>) -> Task<Result<()>> {
1027 cx.update_global::<CompletionProvider, _>(|provider, cx| provider.authenticate(cx))
1028 }
1029
1030 fn render_signed_in(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
1031 let header = TabBar::new("assistant_header")
1032 .start_child(
1033 h_flex().gap_1().child(Self::render_hamburger_button(cx)), // .children(title),
1034 )
1035 .children(self.active_conversation_editor().map(|editor| {
1036 h_flex()
1037 .h(rems(Tab::CONTAINER_HEIGHT_IN_REMS))
1038 .flex_1()
1039 .px_2()
1040 .child(Label::new(editor.read(cx).title(cx)).into_element())
1041 }))
1042 .when(self.focus_handle.contains_focused(cx), |this| {
1043 this.end_child(
1044 h_flex()
1045 .gap_2()
1046 .when(self.active_conversation_editor().is_some(), |this| {
1047 this.child(h_flex().gap_1().children(self.render_editor_tools(cx)))
1048 .child(
1049 ui::Divider::vertical()
1050 .inset()
1051 .color(ui::DividerColor::Border),
1052 )
1053 })
1054 .child(
1055 h_flex()
1056 .gap_1()
1057 .child(Self::render_plus_button(cx))
1058 .child(self.render_zoom_button(cx)),
1059 ),
1060 )
1061 });
1062
1063 let contents = if self.active_conversation_editor().is_some() {
1064 let mut registrar = DivRegistrar::new(
1065 |panel, cx| panel.toolbar.read(cx).item_of_type::<BufferSearchBar>(),
1066 cx,
1067 );
1068 BufferSearchBar::register(&mut registrar);
1069 registrar.into_div()
1070 } else {
1071 div()
1072 };
1073 v_flex()
1074 .key_context("AssistantPanel")
1075 .size_full()
1076 .on_action(cx.listener(|this, _: &workspace::NewFile, cx| {
1077 this.new_conversation(cx);
1078 }))
1079 .on_action(cx.listener(AssistantPanel::toggle_zoom))
1080 .on_action(cx.listener(AssistantPanel::deploy))
1081 .on_action(cx.listener(AssistantPanel::select_next_match))
1082 .on_action(cx.listener(AssistantPanel::select_prev_match))
1083 .on_action(cx.listener(AssistantPanel::handle_editor_cancel))
1084 .on_action(cx.listener(AssistantPanel::reset_credentials))
1085 .track_focus(&self.focus_handle)
1086 .child(header)
1087 .children(if self.toolbar.read(cx).hidden() {
1088 None
1089 } else {
1090 Some(self.toolbar.clone())
1091 })
1092 .child(contents.flex_1().child(
1093 if self.show_saved_conversations || self.active_conversation_editor().is_none() {
1094 let view = cx.view().clone();
1095 let scroll_handle = self.saved_conversations_scroll_handle.clone();
1096 let conversation_count = self.saved_conversations.len();
1097 canvas(
1098 move |bounds, cx| {
1099 let mut saved_conversations = uniform_list(
1100 view,
1101 "saved_conversations",
1102 conversation_count,
1103 |this, range, cx| {
1104 range
1105 .map(|ix| this.render_saved_conversation(ix, cx))
1106 .collect()
1107 },
1108 )
1109 .track_scroll(scroll_handle)
1110 .into_any_element();
1111 saved_conversations.layout(
1112 bounds.origin,
1113 bounds.size.map(AvailableSpace::Definite),
1114 cx,
1115 );
1116 saved_conversations
1117 },
1118 |_bounds, mut saved_conversations, cx| saved_conversations.paint(cx),
1119 )
1120 .size_full()
1121 .into_any_element()
1122 } else {
1123 let editor = self.active_conversation_editor().unwrap();
1124 let conversation = editor.read(cx).conversation.clone();
1125 div()
1126 .size_full()
1127 .child(editor.clone())
1128 .child(
1129 h_flex()
1130 .absolute()
1131 .gap_1()
1132 .top_3()
1133 .right_5()
1134 .child(self.render_model(&conversation, cx))
1135 .children(self.render_remaining_tokens(&conversation, cx)),
1136 )
1137 .into_any_element()
1138 },
1139 ))
1140 }
1141
1142 fn render_model(
1143 &self,
1144 conversation: &Model<Conversation>,
1145 cx: &mut ViewContext<Self>,
1146 ) -> impl IntoElement {
1147 Button::new("current_model", conversation.read(cx).model.display_name())
1148 .style(ButtonStyle::Filled)
1149 .tooltip(move |cx| Tooltip::text("Change Model", cx))
1150 .on_click(cx.listener(|this, _, cx| this.cycle_model(cx)))
1151 }
1152
1153 fn render_remaining_tokens(
1154 &self,
1155 conversation: &Model<Conversation>,
1156 cx: &mut ViewContext<Self>,
1157 ) -> Option<impl IntoElement> {
1158 let remaining_tokens = conversation.read(cx).remaining_tokens()?;
1159 let remaining_tokens_color = if remaining_tokens <= 0 {
1160 Color::Error
1161 } else if remaining_tokens <= 500 {
1162 Color::Warning
1163 } else {
1164 Color::Default
1165 };
1166 Some(Label::new(remaining_tokens.to_string()).color(remaining_tokens_color))
1167 }
1168}
1169
1170impl Render for AssistantPanel {
1171 fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
1172 if let Some(authentication_prompt) = self.authentication_prompt.as_ref() {
1173 authentication_prompt.clone().into_any()
1174 } else {
1175 self.render_signed_in(cx).into_any_element()
1176 }
1177 }
1178}
1179
1180impl Panel for AssistantPanel {
1181 fn persistent_name() -> &'static str {
1182 "AssistantPanel"
1183 }
1184
1185 fn position(&self, cx: &WindowContext) -> DockPosition {
1186 match AssistantSettings::get_global(cx).dock {
1187 AssistantDockPosition::Left => DockPosition::Left,
1188 AssistantDockPosition::Bottom => DockPosition::Bottom,
1189 AssistantDockPosition::Right => DockPosition::Right,
1190 }
1191 }
1192
1193 fn position_is_valid(&self, _: DockPosition) -> bool {
1194 true
1195 }
1196
1197 fn set_position(&mut self, position: DockPosition, cx: &mut ViewContext<Self>) {
1198 settings::update_settings_file::<AssistantSettings>(self.fs.clone(), cx, move |settings| {
1199 let dock = match position {
1200 DockPosition::Left => AssistantDockPosition::Left,
1201 DockPosition::Bottom => AssistantDockPosition::Bottom,
1202 DockPosition::Right => AssistantDockPosition::Right,
1203 };
1204 settings.set_dock(dock);
1205 });
1206 }
1207
1208 fn size(&self, cx: &WindowContext) -> Pixels {
1209 let settings = AssistantSettings::get_global(cx);
1210 match self.position(cx) {
1211 DockPosition::Left | DockPosition::Right => {
1212 self.width.unwrap_or(settings.default_width)
1213 }
1214 DockPosition::Bottom => self.height.unwrap_or(settings.default_height),
1215 }
1216 }
1217
1218 fn set_size(&mut self, size: Option<Pixels>, cx: &mut ViewContext<Self>) {
1219 match self.position(cx) {
1220 DockPosition::Left | DockPosition::Right => self.width = size,
1221 DockPosition::Bottom => self.height = size,
1222 }
1223 cx.notify();
1224 }
1225
1226 fn is_zoomed(&self, _: &WindowContext) -> bool {
1227 self.zoomed
1228 }
1229
1230 fn set_zoomed(&mut self, zoomed: bool, cx: &mut ViewContext<Self>) {
1231 self.zoomed = zoomed;
1232 cx.notify();
1233 }
1234
1235 fn set_active(&mut self, active: bool, cx: &mut ViewContext<Self>) {
1236 if active {
1237 let load_credentials = self.authenticate(cx);
1238 cx.spawn(|this, mut cx| async move {
1239 load_credentials.await?;
1240 this.update(&mut cx, |this, cx| {
1241 if this.is_authenticated(cx) && this.active_conversation_editor().is_none() {
1242 this.new_conversation(cx);
1243 }
1244 })
1245 })
1246 .detach_and_log_err(cx);
1247 }
1248 }
1249
1250 fn icon(&self, cx: &WindowContext) -> Option<IconName> {
1251 let settings = AssistantSettings::get_global(cx);
1252 if !settings.enabled || !settings.button {
1253 return None;
1254 }
1255
1256 Some(IconName::Ai)
1257 }
1258
1259 fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {
1260 Some("Assistant Panel")
1261 }
1262
1263 fn toggle_action(&self) -> Box<dyn Action> {
1264 Box::new(ToggleFocus)
1265 }
1266}
1267
1268impl EventEmitter<PanelEvent> for AssistantPanel {}
1269
1270impl FocusableView for AssistantPanel {
1271 fn focus_handle(&self, _cx: &AppContext) -> FocusHandle {
1272 self.focus_handle.clone()
1273 }
1274}
1275
1276enum ConversationEvent {
1277 MessagesEdited,
1278 SummaryChanged,
1279 StreamedCompletion,
1280}
1281
1282#[derive(Default)]
1283struct Summary {
1284 text: String,
1285 done: bool,
1286}
1287
1288pub struct Conversation {
1289 id: Option<String>,
1290 buffer: Model<Buffer>,
1291 embedded_scope: EmbeddedScope,
1292 message_anchors: Vec<MessageAnchor>,
1293 messages_metadata: HashMap<MessageId, MessageMetadata>,
1294 next_message_id: MessageId,
1295 summary: Option<Summary>,
1296 pending_summary: Task<Option<()>>,
1297 completion_count: usize,
1298 pending_completions: Vec<PendingCompletion>,
1299 model: LanguageModel,
1300 token_count: Option<usize>,
1301 pending_token_count: Task<Option<()>>,
1302 pending_save: Task<Result<()>>,
1303 path: Option<PathBuf>,
1304 _subscriptions: Vec<Subscription>,
1305}
1306
1307impl EventEmitter<ConversationEvent> for Conversation {}
1308
1309impl Conversation {
1310 fn new(
1311 model: LanguageModel,
1312 language_registry: Arc<LanguageRegistry>,
1313 embedded_scope: EmbeddedScope,
1314 cx: &mut ModelContext<Self>,
1315 ) -> Self {
1316 let markdown = language_registry.language_for_name("Markdown");
1317 let buffer = cx.new_model(|cx| {
1318 let mut buffer = Buffer::local("", cx);
1319 buffer.set_language_registry(language_registry);
1320 cx.spawn(|buffer, mut cx| async move {
1321 let markdown = markdown.await?;
1322 buffer.update(&mut cx, |buffer: &mut Buffer, cx| {
1323 buffer.set_language(Some(markdown), cx)
1324 })?;
1325 anyhow::Ok(())
1326 })
1327 .detach_and_log_err(cx);
1328 buffer
1329 });
1330
1331 let mut this = Self {
1332 id: Some(Uuid::new_v4().to_string()),
1333 message_anchors: Default::default(),
1334 messages_metadata: Default::default(),
1335 next_message_id: Default::default(),
1336 summary: None,
1337 pending_summary: Task::ready(None),
1338 completion_count: Default::default(),
1339 pending_completions: Default::default(),
1340 token_count: None,
1341 pending_token_count: Task::ready(None),
1342 model,
1343 _subscriptions: vec![cx.subscribe(&buffer, Self::handle_buffer_event)],
1344 pending_save: Task::ready(Ok(())),
1345 path: None,
1346 buffer,
1347 embedded_scope,
1348 };
1349
1350 let message = MessageAnchor {
1351 id: MessageId(post_inc(&mut this.next_message_id.0)),
1352 start: language::Anchor::MIN,
1353 };
1354 this.message_anchors.push(message.clone());
1355 this.messages_metadata.insert(
1356 message.id,
1357 MessageMetadata {
1358 role: Role::User,
1359 sent_at: Local::now(),
1360 status: MessageStatus::Done,
1361 },
1362 );
1363
1364 this.count_remaining_tokens(cx);
1365 this
1366 }
1367
1368 fn serialize(&self, cx: &AppContext) -> SavedConversation {
1369 SavedConversation {
1370 id: self.id.clone(),
1371 zed: "conversation".into(),
1372 version: SavedConversation::VERSION.into(),
1373 text: self.buffer.read(cx).text(),
1374 message_metadata: self.messages_metadata.clone(),
1375 messages: self
1376 .messages(cx)
1377 .map(|message| SavedMessage {
1378 id: message.id,
1379 start: message.offset_range.start,
1380 })
1381 .collect(),
1382 summary: self
1383 .summary
1384 .as_ref()
1385 .map(|summary| summary.text.clone())
1386 .unwrap_or_default(),
1387 }
1388 }
1389
1390 async fn deserialize(
1391 saved_conversation: SavedConversation,
1392 model: LanguageModel,
1393 path: PathBuf,
1394 language_registry: Arc<LanguageRegistry>,
1395 cx: &mut AsyncAppContext,
1396 ) -> Result<Model<Self>> {
1397 let id = match saved_conversation.id {
1398 Some(id) => Some(id),
1399 None => Some(Uuid::new_v4().to_string()),
1400 };
1401
1402 let markdown = language_registry.language_for_name("Markdown");
1403 let mut message_anchors = Vec::new();
1404 let mut next_message_id = MessageId(0);
1405 let buffer = cx.new_model(|cx| {
1406 let mut buffer = Buffer::local(saved_conversation.text, cx);
1407 for message in saved_conversation.messages {
1408 message_anchors.push(MessageAnchor {
1409 id: message.id,
1410 start: buffer.anchor_before(message.start),
1411 });
1412 next_message_id = cmp::max(next_message_id, MessageId(message.id.0 + 1));
1413 }
1414 buffer.set_language_registry(language_registry);
1415 cx.spawn(|buffer, mut cx| async move {
1416 let markdown = markdown.await?;
1417 buffer.update(&mut cx, |buffer: &mut Buffer, cx| {
1418 buffer.set_language(Some(markdown), cx)
1419 })?;
1420 anyhow::Ok(())
1421 })
1422 .detach_and_log_err(cx);
1423 buffer
1424 })?;
1425
1426 cx.new_model(|cx| {
1427 let mut this = Self {
1428 id,
1429 message_anchors,
1430 messages_metadata: saved_conversation.message_metadata,
1431 next_message_id,
1432 summary: Some(Summary {
1433 text: saved_conversation.summary,
1434 done: true,
1435 }),
1436 pending_summary: Task::ready(None),
1437 completion_count: Default::default(),
1438 pending_completions: Default::default(),
1439 token_count: None,
1440 pending_token_count: Task::ready(None),
1441 model,
1442 _subscriptions: vec![cx.subscribe(&buffer, Self::handle_buffer_event)],
1443 pending_save: Task::ready(Ok(())),
1444 path: Some(path),
1445 buffer,
1446 embedded_scope: EmbeddedScope::new(),
1447 };
1448 this.count_remaining_tokens(cx);
1449 this
1450 })
1451 }
1452
1453 fn handle_buffer_event(
1454 &mut self,
1455 _: Model<Buffer>,
1456 event: &language::Event,
1457 cx: &mut ModelContext<Self>,
1458 ) {
1459 if *event == language::Event::Edited {
1460 self.count_remaining_tokens(cx);
1461 cx.emit(ConversationEvent::MessagesEdited);
1462 }
1463 }
1464
1465 pub(crate) fn count_remaining_tokens(&mut self, cx: &mut ModelContext<Self>) {
1466 let request = self.to_completion_request(cx);
1467 self.pending_token_count = cx.spawn(|this, mut cx| {
1468 async move {
1469 cx.background_executor()
1470 .timer(Duration::from_millis(200))
1471 .await;
1472
1473 let token_count = cx
1474 .update(|cx| CompletionProvider::global(cx).count_tokens(request, cx))?
1475 .await?;
1476
1477 this.update(&mut cx, |this, cx| {
1478 this.token_count = Some(token_count);
1479 cx.notify()
1480 })?;
1481 anyhow::Ok(())
1482 }
1483 .log_err()
1484 });
1485 }
1486
1487 fn remaining_tokens(&self) -> Option<isize> {
1488 Some(self.model.max_token_count() as isize - self.token_count? as isize)
1489 }
1490
1491 fn set_model(&mut self, model: LanguageModel, cx: &mut ModelContext<Self>) {
1492 self.model = model;
1493 self.count_remaining_tokens(cx);
1494 }
1495
1496 fn assist(
1497 &mut self,
1498 selected_messages: HashSet<MessageId>,
1499 cx: &mut ModelContext<Self>,
1500 ) -> Vec<MessageAnchor> {
1501 let mut user_messages = Vec::new();
1502
1503 let last_message_id = if let Some(last_message_id) =
1504 self.message_anchors.iter().rev().find_map(|message| {
1505 message
1506 .start
1507 .is_valid(self.buffer.read(cx))
1508 .then_some(message.id)
1509 }) {
1510 last_message_id
1511 } else {
1512 return Default::default();
1513 };
1514
1515 let mut should_assist = false;
1516 for selected_message_id in selected_messages {
1517 let selected_message_role =
1518 if let Some(metadata) = self.messages_metadata.get(&selected_message_id) {
1519 metadata.role
1520 } else {
1521 continue;
1522 };
1523
1524 if selected_message_role == Role::Assistant {
1525 if let Some(user_message) = self.insert_message_after(
1526 selected_message_id,
1527 Role::User,
1528 MessageStatus::Done,
1529 cx,
1530 ) {
1531 user_messages.push(user_message);
1532 }
1533 } else {
1534 should_assist = true;
1535 }
1536 }
1537
1538 if should_assist {
1539 if !CompletionProvider::global(cx).is_authenticated() {
1540 log::info!("completion provider has no credentials");
1541 return Default::default();
1542 }
1543
1544 let request = self.to_completion_request(cx);
1545 let stream = CompletionProvider::global(cx).complete(request);
1546 let assistant_message = self
1547 .insert_message_after(last_message_id, Role::Assistant, MessageStatus::Pending, cx)
1548 .unwrap();
1549
1550 // Queue up the user's next reply.
1551 let user_message = self
1552 .insert_message_after(assistant_message.id, Role::User, MessageStatus::Done, cx)
1553 .unwrap();
1554 user_messages.push(user_message);
1555
1556 let task = cx.spawn({
1557 |this, mut cx| async move {
1558 let assistant_message_id = assistant_message.id;
1559 let stream_completion = async {
1560 let mut messages = stream.await?;
1561
1562 while let Some(message) = messages.next().await {
1563 let text = message?;
1564
1565 this.update(&mut cx, |this, cx| {
1566 let message_ix = this
1567 .message_anchors
1568 .iter()
1569 .position(|message| message.id == assistant_message_id)?;
1570 this.buffer.update(cx, |buffer, cx| {
1571 let offset = this.message_anchors[message_ix + 1..]
1572 .iter()
1573 .find(|message| message.start.is_valid(buffer))
1574 .map_or(buffer.len(), |message| {
1575 message.start.to_offset(buffer).saturating_sub(1)
1576 });
1577 buffer.edit([(offset..offset, text)], None, cx);
1578 });
1579 cx.emit(ConversationEvent::StreamedCompletion);
1580
1581 Some(())
1582 })?;
1583 smol::future::yield_now().await;
1584 }
1585
1586 this.update(&mut cx, |this, cx| {
1587 this.pending_completions
1588 .retain(|completion| completion.id != this.completion_count);
1589 this.summarize(cx);
1590 })?;
1591
1592 anyhow::Ok(())
1593 };
1594
1595 let result = stream_completion.await;
1596
1597 this.update(&mut cx, |this, cx| {
1598 if let Some(metadata) =
1599 this.messages_metadata.get_mut(&assistant_message.id)
1600 {
1601 match result {
1602 Ok(_) => {
1603 metadata.status = MessageStatus::Done;
1604 }
1605 Err(error) => {
1606 metadata.status = MessageStatus::Error(SharedString::from(
1607 error.to_string().trim().to_string(),
1608 ));
1609 }
1610 }
1611 cx.emit(ConversationEvent::MessagesEdited);
1612 }
1613 })
1614 .ok();
1615 }
1616 });
1617
1618 self.pending_completions.push(PendingCompletion {
1619 id: post_inc(&mut self.completion_count),
1620 _task: task,
1621 });
1622 }
1623
1624 user_messages
1625 }
1626
1627 fn to_completion_request(&self, cx: &mut ModelContext<Conversation>) -> LanguageModelRequest {
1628 let mut request = LanguageModelRequest {
1629 model: self.model.clone(),
1630 messages: self
1631 .messages(cx)
1632 .filter(|message| matches!(message.status, MessageStatus::Done))
1633 .map(|message| message.to_open_ai_message(self.buffer.read(cx)))
1634 .collect(),
1635 stop: vec![],
1636 temperature: 1.0,
1637 };
1638
1639 let context_message = self.embedded_scope.message(cx);
1640 request.messages.extend(context_message);
1641 request
1642 }
1643
1644 fn cancel_last_assist(&mut self) -> bool {
1645 self.pending_completions.pop().is_some()
1646 }
1647
1648 fn cycle_message_roles(&mut self, ids: HashSet<MessageId>, cx: &mut ModelContext<Self>) {
1649 for id in ids {
1650 if let Some(metadata) = self.messages_metadata.get_mut(&id) {
1651 metadata.role.cycle();
1652 cx.emit(ConversationEvent::MessagesEdited);
1653 cx.notify();
1654 }
1655 }
1656 }
1657
1658 fn insert_message_after(
1659 &mut self,
1660 message_id: MessageId,
1661 role: Role,
1662 status: MessageStatus,
1663 cx: &mut ModelContext<Self>,
1664 ) -> Option<MessageAnchor> {
1665 if let Some(prev_message_ix) = self
1666 .message_anchors
1667 .iter()
1668 .position(|message| message.id == message_id)
1669 {
1670 // Find the next valid message after the one we were given.
1671 let mut next_message_ix = prev_message_ix + 1;
1672 while let Some(next_message) = self.message_anchors.get(next_message_ix) {
1673 if next_message.start.is_valid(self.buffer.read(cx)) {
1674 break;
1675 }
1676 next_message_ix += 1;
1677 }
1678
1679 let start = self.buffer.update(cx, |buffer, cx| {
1680 let offset = self
1681 .message_anchors
1682 .get(next_message_ix)
1683 .map_or(buffer.len(), |message| message.start.to_offset(buffer) - 1);
1684 buffer.edit([(offset..offset, "\n")], None, cx);
1685 buffer.anchor_before(offset + 1)
1686 });
1687 let message = MessageAnchor {
1688 id: MessageId(post_inc(&mut self.next_message_id.0)),
1689 start,
1690 };
1691 self.message_anchors
1692 .insert(next_message_ix, message.clone());
1693 self.messages_metadata.insert(
1694 message.id,
1695 MessageMetadata {
1696 role,
1697 sent_at: Local::now(),
1698 status,
1699 },
1700 );
1701 cx.emit(ConversationEvent::MessagesEdited);
1702 Some(message)
1703 } else {
1704 None
1705 }
1706 }
1707
1708 fn split_message(
1709 &mut self,
1710 range: Range<usize>,
1711 cx: &mut ModelContext<Self>,
1712 ) -> (Option<MessageAnchor>, Option<MessageAnchor>) {
1713 let start_message = self.message_for_offset(range.start, cx);
1714 let end_message = self.message_for_offset(range.end, cx);
1715 if let Some((start_message, end_message)) = start_message.zip(end_message) {
1716 // Prevent splitting when range spans multiple messages.
1717 if start_message.id != end_message.id {
1718 return (None, None);
1719 }
1720
1721 let message = start_message;
1722 let role = message.role;
1723 let mut edited_buffer = false;
1724
1725 let mut suffix_start = None;
1726 if range.start > message.offset_range.start && range.end < message.offset_range.end - 1
1727 {
1728 if self.buffer.read(cx).chars_at(range.end).next() == Some('\n') {
1729 suffix_start = Some(range.end + 1);
1730 } else if self.buffer.read(cx).reversed_chars_at(range.end).next() == Some('\n') {
1731 suffix_start = Some(range.end);
1732 }
1733 }
1734
1735 let suffix = if let Some(suffix_start) = suffix_start {
1736 MessageAnchor {
1737 id: MessageId(post_inc(&mut self.next_message_id.0)),
1738 start: self.buffer.read(cx).anchor_before(suffix_start),
1739 }
1740 } else {
1741 self.buffer.update(cx, |buffer, cx| {
1742 buffer.edit([(range.end..range.end, "\n")], None, cx);
1743 });
1744 edited_buffer = true;
1745 MessageAnchor {
1746 id: MessageId(post_inc(&mut self.next_message_id.0)),
1747 start: self.buffer.read(cx).anchor_before(range.end + 1),
1748 }
1749 };
1750
1751 self.message_anchors
1752 .insert(message.index_range.end + 1, suffix.clone());
1753 self.messages_metadata.insert(
1754 suffix.id,
1755 MessageMetadata {
1756 role,
1757 sent_at: Local::now(),
1758 status: MessageStatus::Done,
1759 },
1760 );
1761
1762 let new_messages =
1763 if range.start == range.end || range.start == message.offset_range.start {
1764 (None, Some(suffix))
1765 } else {
1766 let mut prefix_end = None;
1767 if range.start > message.offset_range.start
1768 && range.end < message.offset_range.end - 1
1769 {
1770 if self.buffer.read(cx).chars_at(range.start).next() == Some('\n') {
1771 prefix_end = Some(range.start + 1);
1772 } else if self.buffer.read(cx).reversed_chars_at(range.start).next()
1773 == Some('\n')
1774 {
1775 prefix_end = Some(range.start);
1776 }
1777 }
1778
1779 let selection = if let Some(prefix_end) = prefix_end {
1780 cx.emit(ConversationEvent::MessagesEdited);
1781 MessageAnchor {
1782 id: MessageId(post_inc(&mut self.next_message_id.0)),
1783 start: self.buffer.read(cx).anchor_before(prefix_end),
1784 }
1785 } else {
1786 self.buffer.update(cx, |buffer, cx| {
1787 buffer.edit([(range.start..range.start, "\n")], None, cx)
1788 });
1789 edited_buffer = true;
1790 MessageAnchor {
1791 id: MessageId(post_inc(&mut self.next_message_id.0)),
1792 start: self.buffer.read(cx).anchor_before(range.end + 1),
1793 }
1794 };
1795
1796 self.message_anchors
1797 .insert(message.index_range.end + 1, selection.clone());
1798 self.messages_metadata.insert(
1799 selection.id,
1800 MessageMetadata {
1801 role,
1802 sent_at: Local::now(),
1803 status: MessageStatus::Done,
1804 },
1805 );
1806 (Some(selection), Some(suffix))
1807 };
1808
1809 if !edited_buffer {
1810 cx.emit(ConversationEvent::MessagesEdited);
1811 }
1812 new_messages
1813 } else {
1814 (None, None)
1815 }
1816 }
1817
1818 fn summarize(&mut self, cx: &mut ModelContext<Self>) {
1819 if self.message_anchors.len() >= 2 && self.summary.is_none() {
1820 if !CompletionProvider::global(cx).is_authenticated() {
1821 return;
1822 }
1823
1824 let messages = self
1825 .messages(cx)
1826 .take(2)
1827 .map(|message| message.to_open_ai_message(self.buffer.read(cx)))
1828 .chain(Some(LanguageModelRequestMessage {
1829 role: Role::User,
1830 content: "Summarize the conversation into a short title without punctuation"
1831 .into(),
1832 }));
1833 let request = LanguageModelRequest {
1834 model: self.model.clone(),
1835 messages: messages.collect(),
1836 stop: vec![],
1837 temperature: 1.0,
1838 };
1839
1840 let stream = CompletionProvider::global(cx).complete(request);
1841 self.pending_summary = cx.spawn(|this, mut cx| {
1842 async move {
1843 let mut messages = stream.await?;
1844
1845 while let Some(message) = messages.next().await {
1846 let text = message?;
1847 this.update(&mut cx, |this, cx| {
1848 this.summary
1849 .get_or_insert(Default::default())
1850 .text
1851 .push_str(&text);
1852 cx.emit(ConversationEvent::SummaryChanged);
1853 })?;
1854 }
1855
1856 this.update(&mut cx, |this, cx| {
1857 if let Some(summary) = this.summary.as_mut() {
1858 summary.done = true;
1859 cx.emit(ConversationEvent::SummaryChanged);
1860 }
1861 })?;
1862
1863 anyhow::Ok(())
1864 }
1865 .log_err()
1866 });
1867 }
1868 }
1869
1870 fn message_for_offset(&self, offset: usize, cx: &AppContext) -> Option<Message> {
1871 self.messages_for_offsets([offset], cx).pop()
1872 }
1873
1874 fn messages_for_offsets(
1875 &self,
1876 offsets: impl IntoIterator<Item = usize>,
1877 cx: &AppContext,
1878 ) -> Vec<Message> {
1879 let mut result = Vec::new();
1880
1881 let mut messages = self.messages(cx).peekable();
1882 let mut offsets = offsets.into_iter().peekable();
1883 let mut current_message = messages.next();
1884 while let Some(offset) = offsets.next() {
1885 // Locate the message that contains the offset.
1886 while current_message.as_ref().map_or(false, |message| {
1887 !message.offset_range.contains(&offset) && messages.peek().is_some()
1888 }) {
1889 current_message = messages.next();
1890 }
1891 let Some(message) = current_message.as_ref() else {
1892 break;
1893 };
1894
1895 // Skip offsets that are in the same message.
1896 while offsets.peek().map_or(false, |offset| {
1897 message.offset_range.contains(offset) || messages.peek().is_none()
1898 }) {
1899 offsets.next();
1900 }
1901
1902 result.push(message.clone());
1903 }
1904 result
1905 }
1906
1907 fn messages<'a>(&'a self, cx: &'a AppContext) -> impl 'a + Iterator<Item = Message> {
1908 let buffer = self.buffer.read(cx);
1909 let mut message_anchors = self.message_anchors.iter().enumerate().peekable();
1910 iter::from_fn(move || {
1911 if let Some((start_ix, message_anchor)) = message_anchors.next() {
1912 let metadata = self.messages_metadata.get(&message_anchor.id)?;
1913 let message_start = message_anchor.start.to_offset(buffer);
1914 let mut message_end = None;
1915 let mut end_ix = start_ix;
1916 while let Some((_, next_message)) = message_anchors.peek() {
1917 if next_message.start.is_valid(buffer) {
1918 message_end = Some(next_message.start);
1919 break;
1920 } else {
1921 end_ix += 1;
1922 message_anchors.next();
1923 }
1924 }
1925 let message_end = message_end
1926 .unwrap_or(language::Anchor::MAX)
1927 .to_offset(buffer);
1928 return Some(Message {
1929 index_range: start_ix..end_ix,
1930 offset_range: message_start..message_end,
1931 id: message_anchor.id,
1932 anchor: message_anchor.start,
1933 role: metadata.role,
1934 sent_at: metadata.sent_at,
1935 status: metadata.status.clone(),
1936 });
1937 }
1938 None
1939 })
1940 }
1941
1942 fn save(
1943 &mut self,
1944 debounce: Option<Duration>,
1945 fs: Arc<dyn Fs>,
1946 cx: &mut ModelContext<Conversation>,
1947 ) {
1948 self.pending_save = cx.spawn(|this, mut cx| async move {
1949 if let Some(debounce) = debounce {
1950 cx.background_executor().timer(debounce).await;
1951 }
1952
1953 let (old_path, summary) = this.read_with(&cx, |this, _| {
1954 let path = this.path.clone();
1955 let summary = if let Some(summary) = this.summary.as_ref() {
1956 if summary.done {
1957 Some(summary.text.clone())
1958 } else {
1959 None
1960 }
1961 } else {
1962 None
1963 };
1964 (path, summary)
1965 })?;
1966
1967 if let Some(summary) = summary {
1968 let conversation = this.read_with(&cx, |this, cx| this.serialize(cx))?;
1969 let path = if let Some(old_path) = old_path {
1970 old_path
1971 } else {
1972 let mut discriminant = 1;
1973 let mut new_path;
1974 loop {
1975 new_path = CONVERSATIONS_DIR.join(&format!(
1976 "{} - {}.zed.json",
1977 summary.trim(),
1978 discriminant
1979 ));
1980 if fs.is_file(&new_path).await {
1981 discriminant += 1;
1982 } else {
1983 break;
1984 }
1985 }
1986 new_path
1987 };
1988
1989 fs.create_dir(CONVERSATIONS_DIR.as_ref()).await?;
1990 fs.atomic_write(path.clone(), serde_json::to_string(&conversation).unwrap())
1991 .await?;
1992 this.update(&mut cx, |this, _| this.path = Some(path))?;
1993 }
1994
1995 Ok(())
1996 });
1997 }
1998}
1999
2000struct PendingCompletion {
2001 id: usize,
2002 _task: Task<()>,
2003}
2004
2005enum ConversationEditorEvent {
2006 TabContentChanged,
2007}
2008
2009#[derive(Copy, Clone, Debug, PartialEq)]
2010struct ScrollPosition {
2011 offset_before_cursor: gpui::Point<f32>,
2012 cursor: Anchor,
2013}
2014
2015struct ConversationEditor {
2016 conversation: Model<Conversation>,
2017 fs: Arc<dyn Fs>,
2018 workspace: WeakView<Workspace>,
2019 editor: View<Editor>,
2020 blocks: HashSet<BlockId>,
2021 scroll_position: Option<ScrollPosition>,
2022 _subscriptions: Vec<Subscription>,
2023}
2024
2025impl ConversationEditor {
2026 fn new(
2027 model: LanguageModel,
2028 language_registry: Arc<LanguageRegistry>,
2029 fs: Arc<dyn Fs>,
2030 workspace: View<Workspace>,
2031 cx: &mut ViewContext<Self>,
2032 ) -> Self {
2033 let conversation = cx
2034 .new_model(|cx| Conversation::new(model, language_registry, EmbeddedScope::new(), cx));
2035 Self::for_conversation(conversation, fs, workspace, cx)
2036 }
2037
2038 fn for_conversation(
2039 conversation: Model<Conversation>,
2040 fs: Arc<dyn Fs>,
2041 workspace: View<Workspace>,
2042 cx: &mut ViewContext<Self>,
2043 ) -> Self {
2044 let editor = cx.new_view(|cx| {
2045 let mut editor = Editor::for_buffer(conversation.read(cx).buffer.clone(), None, cx);
2046 editor.set_soft_wrap_mode(SoftWrap::EditorWidth, cx);
2047 editor.set_show_gutter(false, cx);
2048 editor.set_show_wrap_guides(false, cx);
2049 editor
2050 });
2051
2052 let _subscriptions = vec![
2053 cx.observe(&conversation, |_, _, cx| cx.notify()),
2054 cx.subscribe(&conversation, Self::handle_conversation_event),
2055 cx.subscribe(&editor, Self::handle_editor_event),
2056 cx.subscribe(&workspace, Self::handle_workspace_event),
2057 ];
2058
2059 let mut this = Self {
2060 conversation,
2061 editor,
2062 blocks: Default::default(),
2063 scroll_position: None,
2064 fs,
2065 workspace: workspace.downgrade(),
2066 _subscriptions,
2067 };
2068 this.update_active_buffer(workspace, cx);
2069 this.update_message_headers(cx);
2070 this
2071 }
2072
2073 fn assist(&mut self, _: &Assist, cx: &mut ViewContext<Self>) {
2074 self.conversation.update(cx, |conversation, cx| {
2075 report_assistant_event(
2076 self.workspace.clone(),
2077 Some(conversation),
2078 AssistantKind::Panel,
2079 cx,
2080 )
2081 });
2082
2083 let cursors = self.cursors(cx);
2084
2085 let user_messages = self.conversation.update(cx, |conversation, cx| {
2086 let selected_messages = conversation
2087 .messages_for_offsets(cursors, cx)
2088 .into_iter()
2089 .map(|message| message.id)
2090 .collect();
2091 conversation.assist(selected_messages, cx)
2092 });
2093 let new_selections = user_messages
2094 .iter()
2095 .map(|message| {
2096 let cursor = message
2097 .start
2098 .to_offset(self.conversation.read(cx).buffer.read(cx));
2099 cursor..cursor
2100 })
2101 .collect::<Vec<_>>();
2102 if !new_selections.is_empty() {
2103 self.editor.update(cx, |editor, cx| {
2104 editor.change_selections(
2105 Some(Autoscroll::Strategy(AutoscrollStrategy::Fit)),
2106 cx,
2107 |selections| selections.select_ranges(new_selections),
2108 );
2109 });
2110 // Avoid scrolling to the new cursor position so the assistant's output is stable.
2111 cx.defer(|this, _| this.scroll_position = None);
2112 }
2113 }
2114
2115 fn cancel_last_assist(&mut self, _: &editor::actions::Cancel, cx: &mut ViewContext<Self>) {
2116 if !self
2117 .conversation
2118 .update(cx, |conversation, _| conversation.cancel_last_assist())
2119 {
2120 cx.propagate();
2121 }
2122 }
2123
2124 fn cycle_message_role(&mut self, _: &CycleMessageRole, cx: &mut ViewContext<Self>) {
2125 let cursors = self.cursors(cx);
2126 self.conversation.update(cx, |conversation, cx| {
2127 let messages = conversation
2128 .messages_for_offsets(cursors, cx)
2129 .into_iter()
2130 .map(|message| message.id)
2131 .collect();
2132 conversation.cycle_message_roles(messages, cx)
2133 });
2134 }
2135
2136 fn cursors(&self, cx: &AppContext) -> Vec<usize> {
2137 let selections = self.editor.read(cx).selections.all::<usize>(cx);
2138 selections
2139 .into_iter()
2140 .map(|selection| selection.head())
2141 .collect()
2142 }
2143
2144 fn handle_conversation_event(
2145 &mut self,
2146 _: Model<Conversation>,
2147 event: &ConversationEvent,
2148 cx: &mut ViewContext<Self>,
2149 ) {
2150 match event {
2151 ConversationEvent::MessagesEdited => {
2152 self.update_message_headers(cx);
2153 self.conversation.update(cx, |conversation, cx| {
2154 conversation.save(Some(Duration::from_millis(500)), self.fs.clone(), cx);
2155 });
2156 }
2157 ConversationEvent::SummaryChanged => {
2158 cx.emit(ConversationEditorEvent::TabContentChanged);
2159 self.conversation.update(cx, |conversation, cx| {
2160 conversation.save(None, self.fs.clone(), cx);
2161 });
2162 }
2163 ConversationEvent::StreamedCompletion => {
2164 self.editor.update(cx, |editor, cx| {
2165 if let Some(scroll_position) = self.scroll_position {
2166 let snapshot = editor.snapshot(cx);
2167 let cursor_point = scroll_position.cursor.to_display_point(&snapshot);
2168 let scroll_top =
2169 cursor_point.row() as f32 - scroll_position.offset_before_cursor.y;
2170 editor.set_scroll_position(
2171 point(scroll_position.offset_before_cursor.x, scroll_top),
2172 cx,
2173 );
2174 }
2175 });
2176 }
2177 }
2178 }
2179
2180 fn handle_editor_event(
2181 &mut self,
2182 _: View<Editor>,
2183 event: &EditorEvent,
2184 cx: &mut ViewContext<Self>,
2185 ) {
2186 match event {
2187 EditorEvent::ScrollPositionChanged { autoscroll, .. } => {
2188 let cursor_scroll_position = self.cursor_scroll_position(cx);
2189 if *autoscroll {
2190 self.scroll_position = cursor_scroll_position;
2191 } else if self.scroll_position != cursor_scroll_position {
2192 self.scroll_position = None;
2193 }
2194 }
2195 EditorEvent::SelectionsChanged { .. } => {
2196 self.scroll_position = self.cursor_scroll_position(cx);
2197 }
2198 _ => {}
2199 }
2200 }
2201
2202 fn handle_workspace_event(
2203 &mut self,
2204 workspace: View<Workspace>,
2205 event: &WorkspaceEvent,
2206 cx: &mut ViewContext<Self>,
2207 ) {
2208 if let WorkspaceEvent::ActiveItemChanged = event {
2209 self.update_active_buffer(workspace, cx);
2210 }
2211 }
2212
2213 fn update_active_buffer(
2214 &mut self,
2215 workspace: View<Workspace>,
2216 cx: &mut ViewContext<'_, ConversationEditor>,
2217 ) {
2218 let active_buffer = workspace
2219 .read(cx)
2220 .active_item(cx)
2221 .and_then(|item| Some(item.act_as::<Editor>(cx)?.read(cx).buffer().clone()));
2222
2223 self.conversation.update(cx, |conversation, cx| {
2224 conversation
2225 .embedded_scope
2226 .set_active_buffer(active_buffer.clone(), cx);
2227
2228 conversation.count_remaining_tokens(cx);
2229 cx.notify();
2230 });
2231 }
2232
2233 fn cursor_scroll_position(&self, cx: &mut ViewContext<Self>) -> Option<ScrollPosition> {
2234 self.editor.update(cx, |editor, cx| {
2235 let snapshot = editor.snapshot(cx);
2236 let cursor = editor.selections.newest_anchor().head();
2237 let cursor_row = cursor.to_display_point(&snapshot.display_snapshot).row() as f32;
2238 let scroll_position = editor
2239 .scroll_manager
2240 .anchor()
2241 .scroll_position(&snapshot.display_snapshot);
2242
2243 let scroll_bottom = scroll_position.y + editor.visible_line_count().unwrap_or(0.);
2244 if (scroll_position.y..scroll_bottom).contains(&cursor_row) {
2245 Some(ScrollPosition {
2246 cursor,
2247 offset_before_cursor: point(scroll_position.x, cursor_row - scroll_position.y),
2248 })
2249 } else {
2250 None
2251 }
2252 })
2253 }
2254
2255 fn update_message_headers(&mut self, cx: &mut ViewContext<Self>) {
2256 self.editor.update(cx, |editor, cx| {
2257 let buffer = editor.buffer().read(cx).snapshot(cx);
2258 let excerpt_id = *buffer.as_singleton().unwrap().0;
2259 let old_blocks = std::mem::take(&mut self.blocks);
2260 let new_blocks = self
2261 .conversation
2262 .read(cx)
2263 .messages(cx)
2264 .map(|message| BlockProperties {
2265 position: buffer
2266 .anchor_in_excerpt(excerpt_id, message.anchor)
2267 .unwrap(),
2268 height: 2,
2269 style: BlockStyle::Sticky,
2270 render: Box::new({
2271 let conversation = self.conversation.clone();
2272 move |_cx| {
2273 let message_id = message.id;
2274 let sender = ButtonLike::new("role")
2275 .style(ButtonStyle::Filled)
2276 .child(match message.role {
2277 Role::User => Label::new("You").color(Color::Default),
2278 Role::Assistant => Label::new("Assistant").color(Color::Info),
2279 Role::System => Label::new("System").color(Color::Warning),
2280 })
2281 .tooltip(|cx| {
2282 Tooltip::with_meta(
2283 "Toggle message role",
2284 None,
2285 "Available roles: You (User), Assistant, System",
2286 cx,
2287 )
2288 })
2289 .on_click({
2290 let conversation = conversation.clone();
2291 move |_, cx| {
2292 conversation.update(cx, |conversation, cx| {
2293 conversation.cycle_message_roles(
2294 HashSet::from_iter(Some(message_id)),
2295 cx,
2296 )
2297 })
2298 }
2299 });
2300
2301 h_flex()
2302 .id(("message_header", message_id.0))
2303 .h_11()
2304 .relative()
2305 .gap_1()
2306 .child(sender)
2307 // TODO: Only show this if the message if the message has been sent
2308 .child(
2309 Label::new(
2310 FormatDistance::from_now(DateTimeType::Local(
2311 message.sent_at,
2312 ))
2313 .hide_prefix(true)
2314 .add_suffix(true)
2315 .to_string(),
2316 )
2317 .size(LabelSize::XSmall)
2318 .color(Color::Muted),
2319 )
2320 .children(
2321 if let MessageStatus::Error(error) = message.status.clone() {
2322 Some(
2323 div()
2324 .id("error")
2325 .tooltip(move |cx| Tooltip::text(error.clone(), cx))
2326 .child(Icon::new(IconName::XCircle)),
2327 )
2328 } else {
2329 None
2330 },
2331 )
2332 .into_any_element()
2333 }
2334 }),
2335 disposition: BlockDisposition::Above,
2336 })
2337 .collect::<Vec<_>>();
2338
2339 editor.remove_blocks(old_blocks, None, cx);
2340 let ids = editor.insert_blocks(new_blocks, None, cx);
2341 self.blocks = HashSet::from_iter(ids);
2342 });
2343 }
2344
2345 fn quote_selection(
2346 workspace: &mut Workspace,
2347 _: &QuoteSelection,
2348 cx: &mut ViewContext<Workspace>,
2349 ) {
2350 let Some(panel) = workspace.panel::<AssistantPanel>(cx) else {
2351 return;
2352 };
2353 let Some(editor) = workspace
2354 .active_item(cx)
2355 .and_then(|item| item.act_as::<Editor>(cx))
2356 else {
2357 return;
2358 };
2359
2360 let editor = editor.read(cx);
2361 let range = editor.selections.newest::<usize>(cx).range();
2362 let buffer = editor.buffer().read(cx).snapshot(cx);
2363 let start_language = buffer.language_at(range.start);
2364 let end_language = buffer.language_at(range.end);
2365 let language_name = if start_language == end_language {
2366 start_language.map(|language| language.code_fence_block_name())
2367 } else {
2368 None
2369 };
2370 let language_name = language_name.as_deref().unwrap_or("");
2371
2372 let selected_text = buffer.text_for_range(range).collect::<String>();
2373 let text = if selected_text.is_empty() {
2374 None
2375 } else {
2376 Some(if language_name == "markdown" {
2377 selected_text
2378 .lines()
2379 .map(|line| format!("> {}", line))
2380 .collect::<Vec<_>>()
2381 .join("\n")
2382 } else {
2383 format!("```{language_name}\n{selected_text}\n```")
2384 })
2385 };
2386
2387 // Activate the panel
2388 if !panel.focus_handle(cx).contains_focused(cx) {
2389 workspace.toggle_panel_focus::<AssistantPanel>(cx);
2390 }
2391
2392 if let Some(text) = text {
2393 panel.update(cx, |panel, cx| {
2394 if let Some(conversation) = panel
2395 .active_conversation_editor()
2396 .cloned()
2397 .or_else(|| panel.new_conversation(cx))
2398 {
2399 conversation.update(cx, |conversation, cx| {
2400 conversation
2401 .editor
2402 .update(cx, |editor, cx| editor.insert(&text, cx))
2403 });
2404 };
2405 });
2406 }
2407 }
2408
2409 fn copy(&mut self, _: &editor::actions::Copy, cx: &mut ViewContext<Self>) {
2410 let editor = self.editor.read(cx);
2411 let conversation = self.conversation.read(cx);
2412 if editor.selections.count() == 1 {
2413 let selection = editor.selections.newest::<usize>(cx);
2414 let mut copied_text = String::new();
2415 let mut spanned_messages = 0;
2416 for message in conversation.messages(cx) {
2417 if message.offset_range.start >= selection.range().end {
2418 break;
2419 } else if message.offset_range.end >= selection.range().start {
2420 let range = cmp::max(message.offset_range.start, selection.range().start)
2421 ..cmp::min(message.offset_range.end, selection.range().end);
2422 if !range.is_empty() {
2423 spanned_messages += 1;
2424 write!(&mut copied_text, "## {}\n\n", message.role).unwrap();
2425 for chunk in conversation.buffer.read(cx).text_for_range(range) {
2426 copied_text.push_str(chunk);
2427 }
2428 copied_text.push('\n');
2429 }
2430 }
2431 }
2432
2433 if spanned_messages > 1 {
2434 cx.write_to_clipboard(ClipboardItem::new(copied_text));
2435 return;
2436 }
2437 }
2438
2439 cx.propagate();
2440 }
2441
2442 fn split(&mut self, _: &Split, cx: &mut ViewContext<Self>) {
2443 self.conversation.update(cx, |conversation, cx| {
2444 let selections = self.editor.read(cx).selections.disjoint_anchors();
2445 for selection in selections.as_ref() {
2446 let buffer = self.editor.read(cx).buffer().read(cx).snapshot(cx);
2447 let range = selection
2448 .map(|endpoint| endpoint.to_offset(&buffer))
2449 .range();
2450 conversation.split_message(range, cx);
2451 }
2452 });
2453 }
2454
2455 fn save(&mut self, _: &Save, cx: &mut ViewContext<Self>) {
2456 self.conversation.update(cx, |conversation, cx| {
2457 conversation.save(None, self.fs.clone(), cx)
2458 });
2459 }
2460
2461 fn title(&self, cx: &AppContext) -> String {
2462 self.conversation
2463 .read(cx)
2464 .summary
2465 .as_ref()
2466 .map(|summary| summary.text.clone())
2467 .unwrap_or_else(|| "New Conversation".into())
2468 }
2469
2470 fn render_embedded_scope(&self, cx: &mut ViewContext<Self>) -> Option<impl Element> {
2471 let active_buffer = self
2472 .conversation
2473 .read(cx)
2474 .embedded_scope
2475 .active_buffer()?
2476 .clone();
2477
2478 Some(
2479 div()
2480 .p_4()
2481 .v_flex()
2482 .child(
2483 div()
2484 .h_flex()
2485 .items_center()
2486 .child(Icon::new(IconName::File))
2487 .child(
2488 div()
2489 .h_6()
2490 .child(Label::new("File Contexts"))
2491 .ml_1()
2492 .font_weight(FontWeight::SEMIBOLD),
2493 ),
2494 )
2495 .child(
2496 div()
2497 .ml_4()
2498 .child(self.render_active_buffer(active_buffer, cx)),
2499 ),
2500 )
2501 }
2502
2503 fn render_active_buffer(
2504 &self,
2505 buffer: Model<MultiBuffer>,
2506 cx: &mut ViewContext<Self>,
2507 ) -> impl Element {
2508 let buffer = buffer.read(cx);
2509 let icon_path;
2510 let path;
2511 if let Some(singleton) = buffer.as_singleton() {
2512 let singleton = singleton.read(cx);
2513
2514 path = singleton.file().map(|file| file.full_path(cx));
2515
2516 icon_path = path
2517 .as_ref()
2518 .and_then(|path| FileIcons::get_icon(path.as_path(), cx))
2519 .map(SharedString::from)
2520 .unwrap_or_else(|| SharedString::from("icons/file_icons/file.svg"));
2521 } else {
2522 icon_path = SharedString::from("icons/file_icons/file.svg");
2523 path = None;
2524 }
2525
2526 let file_name = path.map_or("Untitled".to_string(), |path| {
2527 path.to_string_lossy().to_string()
2528 });
2529
2530 let enabled = self
2531 .conversation
2532 .read(cx)
2533 .embedded_scope
2534 .active_buffer_enabled();
2535
2536 let file_name_text_color = if enabled {
2537 Color::Default
2538 } else {
2539 Color::Disabled
2540 };
2541
2542 div()
2543 .id("active-buffer")
2544 .h_flex()
2545 .cursor_pointer()
2546 .child(Icon::from_path(icon_path).color(file_name_text_color))
2547 .child(
2548 div()
2549 .h_6()
2550 .child(Label::new(file_name).color(file_name_text_color))
2551 .ml_1(),
2552 )
2553 .children(enabled.then(|| {
2554 div()
2555 .child(Icon::new(IconName::Check).color(file_name_text_color))
2556 .ml_1()
2557 }))
2558 .on_click(cx.listener(move |this, _, cx| {
2559 this.conversation.update(cx, |conversation, cx| {
2560 conversation
2561 .embedded_scope
2562 .set_active_buffer_enabled(!enabled);
2563 cx.notify();
2564 })
2565 }))
2566 }
2567}
2568
2569impl EventEmitter<ConversationEditorEvent> for ConversationEditor {}
2570
2571impl Render for ConversationEditor {
2572 fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Element {
2573 //
2574 // The ConversationEditor has two main segments
2575 //
2576 // 1. Messages Editor
2577 // 2. Context
2578 // - File Context (currently only the active file)
2579 // - Project Diagnostics (Planned)
2580 // - Deep Code Context (Planned, for query and other tools for the model)
2581 //
2582
2583 div()
2584 .key_context("ConversationEditor")
2585 .capture_action(cx.listener(ConversationEditor::cancel_last_assist))
2586 .capture_action(cx.listener(ConversationEditor::save))
2587 .capture_action(cx.listener(ConversationEditor::copy))
2588 .capture_action(cx.listener(ConversationEditor::cycle_message_role))
2589 .on_action(cx.listener(ConversationEditor::assist))
2590 .on_action(cx.listener(ConversationEditor::split))
2591 .size_full()
2592 .v_flex()
2593 .child(
2594 div()
2595 .flex_grow()
2596 .pl_4()
2597 .bg(cx.theme().colors().editor_background)
2598 .child(self.editor.clone()),
2599 )
2600 .child(div().flex_shrink().children(self.render_embedded_scope(cx)))
2601 }
2602}
2603
2604impl FocusableView for ConversationEditor {
2605 fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
2606 self.editor.focus_handle(cx)
2607 }
2608}
2609
2610#[derive(Clone, Debug)]
2611struct MessageAnchor {
2612 id: MessageId,
2613 start: language::Anchor,
2614}
2615
2616#[derive(Clone, Debug)]
2617pub struct Message {
2618 offset_range: Range<usize>,
2619 index_range: Range<usize>,
2620 id: MessageId,
2621 anchor: language::Anchor,
2622 role: Role,
2623 sent_at: DateTime<Local>,
2624 status: MessageStatus,
2625}
2626
2627impl Message {
2628 fn to_open_ai_message(&self, buffer: &Buffer) -> LanguageModelRequestMessage {
2629 let content = buffer
2630 .text_for_range(self.offset_range.clone())
2631 .collect::<String>();
2632 LanguageModelRequestMessage {
2633 role: self.role,
2634 content: content.trim_end().into(),
2635 }
2636 }
2637}
2638
2639enum InlineAssistantEvent {
2640 Confirmed {
2641 prompt: String,
2642 include_conversation: bool,
2643 },
2644 Canceled,
2645 Dismissed,
2646 IncludeConversationToggled {
2647 include_conversation: bool,
2648 },
2649}
2650
2651struct InlineAssistant {
2652 id: usize,
2653 prompt_editor: View<Editor>,
2654 workspace: WeakView<Workspace>,
2655 confirmed: bool,
2656 include_conversation: bool,
2657 measurements: Arc<Mutex<BlockMeasurements>>,
2658 prompt_history: VecDeque<String>,
2659 prompt_history_ix: Option<usize>,
2660 pending_prompt: String,
2661 codegen: Model<Codegen>,
2662 _subscriptions: Vec<Subscription>,
2663}
2664
2665impl EventEmitter<InlineAssistantEvent> for InlineAssistant {}
2666
2667impl Render for InlineAssistant {
2668 fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Element {
2669 let measurements = *self.measurements.lock();
2670 h_flex()
2671 .w_full()
2672 .py_2()
2673 .border_y_1()
2674 .border_color(cx.theme().colors().border)
2675 .on_action(cx.listener(Self::confirm))
2676 .on_action(cx.listener(Self::cancel))
2677 .on_action(cx.listener(Self::toggle_include_conversation))
2678 .on_action(cx.listener(Self::move_up))
2679 .on_action(cx.listener(Self::move_down))
2680 .child(
2681 h_flex()
2682 .justify_center()
2683 .w(measurements.gutter_width)
2684 .child(
2685 IconButton::new("include_conversation", IconName::Ai)
2686 .on_click(cx.listener(|this, _, cx| {
2687 this.toggle_include_conversation(&ToggleIncludeConversation, cx)
2688 }))
2689 .selected(self.include_conversation)
2690 .tooltip(|cx| {
2691 Tooltip::for_action(
2692 "Include Conversation",
2693 &ToggleIncludeConversation,
2694 cx,
2695 )
2696 }),
2697 )
2698 .children(if let Some(error) = self.codegen.read(cx).error() {
2699 let error_message = SharedString::from(error.to_string());
2700 Some(
2701 div()
2702 .id("error")
2703 .tooltip(move |cx| Tooltip::text(error_message.clone(), cx))
2704 .child(Icon::new(IconName::XCircle).color(Color::Error)),
2705 )
2706 } else {
2707 None
2708 }),
2709 )
2710 .child(
2711 h_flex()
2712 .w_full()
2713 .ml(measurements.anchor_x - measurements.gutter_width)
2714 .child(self.render_prompt_editor(cx)),
2715 )
2716 }
2717}
2718
2719impl FocusableView for InlineAssistant {
2720 fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
2721 self.prompt_editor.focus_handle(cx)
2722 }
2723}
2724
2725impl InlineAssistant {
2726 fn new(
2727 id: usize,
2728 measurements: Arc<Mutex<BlockMeasurements>>,
2729 include_conversation: bool,
2730 prompt_history: VecDeque<String>,
2731 codegen: Model<Codegen>,
2732 workspace: WeakView<Workspace>,
2733 cx: &mut ViewContext<Self>,
2734 ) -> Self {
2735 let prompt_editor = cx.new_view(|cx| {
2736 let mut editor = Editor::single_line(cx);
2737 let placeholder = match codegen.read(cx).kind() {
2738 CodegenKind::Transform { .. } => "Enter transformation prompt…",
2739 CodegenKind::Generate { .. } => "Enter generation prompt…",
2740 };
2741 editor.set_placeholder_text(placeholder, cx);
2742 editor
2743 });
2744 cx.focus_view(&prompt_editor);
2745
2746 let subscriptions = vec![
2747 cx.observe(&codegen, Self::handle_codegen_changed),
2748 cx.subscribe(&prompt_editor, Self::handle_prompt_editor_events),
2749 ];
2750
2751 Self {
2752 id,
2753 prompt_editor,
2754 workspace,
2755 confirmed: false,
2756 include_conversation,
2757 measurements,
2758 prompt_history,
2759 prompt_history_ix: None,
2760 pending_prompt: String::new(),
2761 codegen,
2762 _subscriptions: subscriptions,
2763 }
2764 }
2765
2766 fn handle_prompt_editor_events(
2767 &mut self,
2768 _: View<Editor>,
2769 event: &EditorEvent,
2770 cx: &mut ViewContext<Self>,
2771 ) {
2772 if let EditorEvent::Edited = event {
2773 self.pending_prompt = self.prompt_editor.read(cx).text(cx);
2774 cx.notify();
2775 }
2776 }
2777
2778 fn handle_codegen_changed(&mut self, _: Model<Codegen>, cx: &mut ViewContext<Self>) {
2779 let is_read_only = !self.codegen.read(cx).idle();
2780 self.prompt_editor.update(cx, |editor, cx| {
2781 let was_read_only = editor.read_only(cx);
2782 if was_read_only != is_read_only {
2783 if is_read_only {
2784 editor.set_read_only(true);
2785 } else {
2786 self.confirmed = false;
2787 editor.set_read_only(false);
2788 }
2789 }
2790 });
2791 cx.notify();
2792 }
2793
2794 fn cancel(&mut self, _: &editor::actions::Cancel, cx: &mut ViewContext<Self>) {
2795 cx.emit(InlineAssistantEvent::Canceled);
2796 }
2797
2798 fn confirm(&mut self, _: &menu::Confirm, cx: &mut ViewContext<Self>) {
2799 if self.confirmed {
2800 cx.emit(InlineAssistantEvent::Dismissed);
2801 } else {
2802 report_assistant_event(self.workspace.clone(), None, AssistantKind::Inline, cx);
2803
2804 let prompt = self.prompt_editor.read(cx).text(cx);
2805 self.prompt_editor
2806 .update(cx, |editor, _cx| editor.set_read_only(true));
2807 cx.emit(InlineAssistantEvent::Confirmed {
2808 prompt,
2809 include_conversation: self.include_conversation,
2810 });
2811 self.confirmed = true;
2812 cx.notify();
2813 }
2814 }
2815
2816 fn toggle_include_conversation(
2817 &mut self,
2818 _: &ToggleIncludeConversation,
2819 cx: &mut ViewContext<Self>,
2820 ) {
2821 self.include_conversation = !self.include_conversation;
2822 cx.emit(InlineAssistantEvent::IncludeConversationToggled {
2823 include_conversation: self.include_conversation,
2824 });
2825 cx.notify();
2826 }
2827
2828 fn move_up(&mut self, _: &MoveUp, cx: &mut ViewContext<Self>) {
2829 if let Some(ix) = self.prompt_history_ix {
2830 if ix > 0 {
2831 self.prompt_history_ix = Some(ix - 1);
2832 let prompt = self.prompt_history[ix - 1].clone();
2833 self.set_prompt(&prompt, cx);
2834 }
2835 } else if !self.prompt_history.is_empty() {
2836 self.prompt_history_ix = Some(self.prompt_history.len() - 1);
2837 let prompt = self.prompt_history[self.prompt_history.len() - 1].clone();
2838 self.set_prompt(&prompt, cx);
2839 }
2840 }
2841
2842 fn move_down(&mut self, _: &MoveDown, cx: &mut ViewContext<Self>) {
2843 if let Some(ix) = self.prompt_history_ix {
2844 if ix < self.prompt_history.len() - 1 {
2845 self.prompt_history_ix = Some(ix + 1);
2846 let prompt = self.prompt_history[ix + 1].clone();
2847 self.set_prompt(&prompt, cx);
2848 } else {
2849 self.prompt_history_ix = None;
2850 let pending_prompt = self.pending_prompt.clone();
2851 self.set_prompt(&pending_prompt, cx);
2852 }
2853 }
2854 }
2855
2856 fn set_prompt(&mut self, prompt: &str, cx: &mut ViewContext<Self>) {
2857 self.prompt_editor.update(cx, |editor, cx| {
2858 editor.buffer().update(cx, |buffer, cx| {
2859 let len = buffer.len(cx);
2860 buffer.edit([(0..len, prompt)], None, cx);
2861 });
2862 });
2863 }
2864
2865 fn render_prompt_editor(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
2866 let settings = ThemeSettings::get_global(cx);
2867 let text_style = TextStyle {
2868 color: if self.prompt_editor.read(cx).read_only(cx) {
2869 cx.theme().colors().text_disabled
2870 } else {
2871 cx.theme().colors().text
2872 },
2873 font_family: settings.ui_font.family.clone(),
2874 font_features: settings.ui_font.features,
2875 font_size: rems(0.875).into(),
2876 font_weight: FontWeight::NORMAL,
2877 font_style: FontStyle::Normal,
2878 line_height: relative(1.3),
2879 background_color: None,
2880 underline: None,
2881 strikethrough: None,
2882 white_space: WhiteSpace::Normal,
2883 };
2884 EditorElement::new(
2885 &self.prompt_editor,
2886 EditorStyle {
2887 background: cx.theme().colors().editor_background,
2888 local_player: cx.theme().players().local(),
2889 text: text_style,
2890 ..Default::default()
2891 },
2892 )
2893 }
2894}
2895
2896// This wouldn't need to exist if we could pass parameters when rendering child views.
2897#[derive(Copy, Clone, Default)]
2898struct BlockMeasurements {
2899 anchor_x: Pixels,
2900 gutter_width: Pixels,
2901}
2902
2903struct PendingInlineAssist {
2904 editor: WeakView<Editor>,
2905 inline_assistant: Option<(BlockId, View<InlineAssistant>)>,
2906 codegen: Model<Codegen>,
2907 _subscriptions: Vec<Subscription>,
2908 project: WeakModel<Project>,
2909}
2910
2911fn merge_ranges(ranges: &mut Vec<Range<Anchor>>, buffer: &MultiBufferSnapshot) {
2912 ranges.sort_unstable_by(|a, b| {
2913 a.start
2914 .cmp(&b.start, buffer)
2915 .then_with(|| b.end.cmp(&a.end, buffer))
2916 });
2917
2918 let mut ix = 0;
2919 while ix + 1 < ranges.len() {
2920 let b = ranges[ix + 1].clone();
2921 let a = &mut ranges[ix];
2922 if a.end.cmp(&b.start, buffer).is_gt() {
2923 if a.end.cmp(&b.end, buffer).is_lt() {
2924 a.end = b.end;
2925 }
2926 ranges.remove(ix + 1);
2927 } else {
2928 ix += 1;
2929 }
2930 }
2931}
2932
2933fn report_assistant_event(
2934 workspace: WeakView<Workspace>,
2935 conversation: Option<&Conversation>,
2936 assistant_kind: AssistantKind,
2937 cx: &mut AppContext,
2938) {
2939 let Some(workspace) = workspace.upgrade() else {
2940 return;
2941 };
2942
2943 let client = workspace.read(cx).project().read(cx).client();
2944 let telemetry = client.telemetry();
2945
2946 let conversation_id = conversation.and_then(|conversation| conversation.id.clone());
2947 let model_id = conversation
2948 .map(|c| c.model.telemetry_id())
2949 .unwrap_or_else(|| {
2950 CompletionProvider::global(cx)
2951 .default_model()
2952 .telemetry_id()
2953 });
2954 telemetry.report_assistant_event(conversation_id, assistant_kind, model_id)
2955}
2956
2957#[cfg(test)]
2958mod tests {
2959 use super::*;
2960 use crate::{FakeCompletionProvider, MessageId};
2961 use gpui::{AppContext, TestAppContext};
2962 use settings::SettingsStore;
2963
2964 #[gpui::test]
2965 fn test_inserting_and_removing_messages(cx: &mut AppContext) {
2966 let settings_store = SettingsStore::test(cx);
2967 cx.set_global(CompletionProvider::Fake(FakeCompletionProvider::default()));
2968 cx.set_global(settings_store);
2969 init(cx);
2970 let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
2971
2972 let conversation = cx.new_model(|cx| {
2973 Conversation::new(LanguageModel::default(), registry, EmbeddedScope::new(), cx)
2974 });
2975 let buffer = conversation.read(cx).buffer.clone();
2976
2977 let message_1 = conversation.read(cx).message_anchors[0].clone();
2978 assert_eq!(
2979 messages(&conversation, cx),
2980 vec![(message_1.id, Role::User, 0..0)]
2981 );
2982
2983 let message_2 = conversation.update(cx, |conversation, cx| {
2984 conversation
2985 .insert_message_after(message_1.id, Role::Assistant, MessageStatus::Done, cx)
2986 .unwrap()
2987 });
2988 assert_eq!(
2989 messages(&conversation, cx),
2990 vec![
2991 (message_1.id, Role::User, 0..1),
2992 (message_2.id, Role::Assistant, 1..1)
2993 ]
2994 );
2995
2996 buffer.update(cx, |buffer, cx| {
2997 buffer.edit([(0..0, "1"), (1..1, "2")], None, cx)
2998 });
2999 assert_eq!(
3000 messages(&conversation, cx),
3001 vec![
3002 (message_1.id, Role::User, 0..2),
3003 (message_2.id, Role::Assistant, 2..3)
3004 ]
3005 );
3006
3007 let message_3 = conversation.update(cx, |conversation, cx| {
3008 conversation
3009 .insert_message_after(message_2.id, Role::User, MessageStatus::Done, cx)
3010 .unwrap()
3011 });
3012 assert_eq!(
3013 messages(&conversation, cx),
3014 vec![
3015 (message_1.id, Role::User, 0..2),
3016 (message_2.id, Role::Assistant, 2..4),
3017 (message_3.id, Role::User, 4..4)
3018 ]
3019 );
3020
3021 let message_4 = conversation.update(cx, |conversation, cx| {
3022 conversation
3023 .insert_message_after(message_2.id, Role::User, MessageStatus::Done, cx)
3024 .unwrap()
3025 });
3026 assert_eq!(
3027 messages(&conversation, cx),
3028 vec![
3029 (message_1.id, Role::User, 0..2),
3030 (message_2.id, Role::Assistant, 2..4),
3031 (message_4.id, Role::User, 4..5),
3032 (message_3.id, Role::User, 5..5),
3033 ]
3034 );
3035
3036 buffer.update(cx, |buffer, cx| {
3037 buffer.edit([(4..4, "C"), (5..5, "D")], None, cx)
3038 });
3039 assert_eq!(
3040 messages(&conversation, cx),
3041 vec![
3042 (message_1.id, Role::User, 0..2),
3043 (message_2.id, Role::Assistant, 2..4),
3044 (message_4.id, Role::User, 4..6),
3045 (message_3.id, Role::User, 6..7),
3046 ]
3047 );
3048
3049 // Deleting across message boundaries merges the messages.
3050 buffer.update(cx, |buffer, cx| buffer.edit([(1..4, "")], None, cx));
3051 assert_eq!(
3052 messages(&conversation, cx),
3053 vec![
3054 (message_1.id, Role::User, 0..3),
3055 (message_3.id, Role::User, 3..4),
3056 ]
3057 );
3058
3059 // Undoing the deletion should also undo the merge.
3060 buffer.update(cx, |buffer, cx| buffer.undo(cx));
3061 assert_eq!(
3062 messages(&conversation, cx),
3063 vec![
3064 (message_1.id, Role::User, 0..2),
3065 (message_2.id, Role::Assistant, 2..4),
3066 (message_4.id, Role::User, 4..6),
3067 (message_3.id, Role::User, 6..7),
3068 ]
3069 );
3070
3071 // Redoing the deletion should also redo the merge.
3072 buffer.update(cx, |buffer, cx| buffer.redo(cx));
3073 assert_eq!(
3074 messages(&conversation, cx),
3075 vec![
3076 (message_1.id, Role::User, 0..3),
3077 (message_3.id, Role::User, 3..4),
3078 ]
3079 );
3080
3081 // Ensure we can still insert after a merged message.
3082 let message_5 = conversation.update(cx, |conversation, cx| {
3083 conversation
3084 .insert_message_after(message_1.id, Role::System, MessageStatus::Done, cx)
3085 .unwrap()
3086 });
3087 assert_eq!(
3088 messages(&conversation, cx),
3089 vec![
3090 (message_1.id, Role::User, 0..3),
3091 (message_5.id, Role::System, 3..4),
3092 (message_3.id, Role::User, 4..5)
3093 ]
3094 );
3095 }
3096
3097 #[gpui::test]
3098 fn test_message_splitting(cx: &mut AppContext) {
3099 let settings_store = SettingsStore::test(cx);
3100 cx.set_global(settings_store);
3101 cx.set_global(CompletionProvider::Fake(FakeCompletionProvider::default()));
3102 init(cx);
3103 let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
3104
3105 let conversation = cx.new_model(|cx| {
3106 Conversation::new(LanguageModel::default(), registry, EmbeddedScope::new(), cx)
3107 });
3108 let buffer = conversation.read(cx).buffer.clone();
3109
3110 let message_1 = conversation.read(cx).message_anchors[0].clone();
3111 assert_eq!(
3112 messages(&conversation, cx),
3113 vec![(message_1.id, Role::User, 0..0)]
3114 );
3115
3116 buffer.update(cx, |buffer, cx| {
3117 buffer.edit([(0..0, "aaa\nbbb\nccc\nddd\n")], None, cx)
3118 });
3119
3120 let (_, message_2) =
3121 conversation.update(cx, |conversation, cx| conversation.split_message(3..3, cx));
3122 let message_2 = message_2.unwrap();
3123
3124 // We recycle newlines in the middle of a split message
3125 assert_eq!(buffer.read(cx).text(), "aaa\nbbb\nccc\nddd\n");
3126 assert_eq!(
3127 messages(&conversation, cx),
3128 vec![
3129 (message_1.id, Role::User, 0..4),
3130 (message_2.id, Role::User, 4..16),
3131 ]
3132 );
3133
3134 let (_, message_3) =
3135 conversation.update(cx, |conversation, cx| conversation.split_message(3..3, cx));
3136 let message_3 = message_3.unwrap();
3137
3138 // We don't recycle newlines at the end of a split message
3139 assert_eq!(buffer.read(cx).text(), "aaa\n\nbbb\nccc\nddd\n");
3140 assert_eq!(
3141 messages(&conversation, cx),
3142 vec![
3143 (message_1.id, Role::User, 0..4),
3144 (message_3.id, Role::User, 4..5),
3145 (message_2.id, Role::User, 5..17),
3146 ]
3147 );
3148
3149 let (_, message_4) =
3150 conversation.update(cx, |conversation, cx| conversation.split_message(9..9, cx));
3151 let message_4 = message_4.unwrap();
3152 assert_eq!(buffer.read(cx).text(), "aaa\n\nbbb\nccc\nddd\n");
3153 assert_eq!(
3154 messages(&conversation, cx),
3155 vec![
3156 (message_1.id, Role::User, 0..4),
3157 (message_3.id, Role::User, 4..5),
3158 (message_2.id, Role::User, 5..9),
3159 (message_4.id, Role::User, 9..17),
3160 ]
3161 );
3162
3163 let (_, message_5) =
3164 conversation.update(cx, |conversation, cx| conversation.split_message(9..9, cx));
3165 let message_5 = message_5.unwrap();
3166 assert_eq!(buffer.read(cx).text(), "aaa\n\nbbb\n\nccc\nddd\n");
3167 assert_eq!(
3168 messages(&conversation, cx),
3169 vec![
3170 (message_1.id, Role::User, 0..4),
3171 (message_3.id, Role::User, 4..5),
3172 (message_2.id, Role::User, 5..9),
3173 (message_4.id, Role::User, 9..10),
3174 (message_5.id, Role::User, 10..18),
3175 ]
3176 );
3177
3178 let (message_6, message_7) = conversation.update(cx, |conversation, cx| {
3179 conversation.split_message(14..16, cx)
3180 });
3181 let message_6 = message_6.unwrap();
3182 let message_7 = message_7.unwrap();
3183 assert_eq!(buffer.read(cx).text(), "aaa\n\nbbb\n\nccc\ndd\nd\n");
3184 assert_eq!(
3185 messages(&conversation, cx),
3186 vec![
3187 (message_1.id, Role::User, 0..4),
3188 (message_3.id, Role::User, 4..5),
3189 (message_2.id, Role::User, 5..9),
3190 (message_4.id, Role::User, 9..10),
3191 (message_5.id, Role::User, 10..14),
3192 (message_6.id, Role::User, 14..17),
3193 (message_7.id, Role::User, 17..19),
3194 ]
3195 );
3196 }
3197
3198 #[gpui::test]
3199 fn test_messages_for_offsets(cx: &mut AppContext) {
3200 let settings_store = SettingsStore::test(cx);
3201 cx.set_global(CompletionProvider::Fake(FakeCompletionProvider::default()));
3202 cx.set_global(settings_store);
3203 init(cx);
3204 let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
3205 let conversation = cx.new_model(|cx| {
3206 Conversation::new(LanguageModel::default(), registry, EmbeddedScope::new(), cx)
3207 });
3208 let buffer = conversation.read(cx).buffer.clone();
3209
3210 let message_1 = conversation.read(cx).message_anchors[0].clone();
3211 assert_eq!(
3212 messages(&conversation, cx),
3213 vec![(message_1.id, Role::User, 0..0)]
3214 );
3215
3216 buffer.update(cx, |buffer, cx| buffer.edit([(0..0, "aaa")], None, cx));
3217 let message_2 = conversation
3218 .update(cx, |conversation, cx| {
3219 conversation.insert_message_after(message_1.id, Role::User, MessageStatus::Done, cx)
3220 })
3221 .unwrap();
3222 buffer.update(cx, |buffer, cx| buffer.edit([(4..4, "bbb")], None, cx));
3223
3224 let message_3 = conversation
3225 .update(cx, |conversation, cx| {
3226 conversation.insert_message_after(message_2.id, Role::User, MessageStatus::Done, cx)
3227 })
3228 .unwrap();
3229 buffer.update(cx, |buffer, cx| buffer.edit([(8..8, "ccc")], None, cx));
3230
3231 assert_eq!(buffer.read(cx).text(), "aaa\nbbb\nccc");
3232 assert_eq!(
3233 messages(&conversation, cx),
3234 vec![
3235 (message_1.id, Role::User, 0..4),
3236 (message_2.id, Role::User, 4..8),
3237 (message_3.id, Role::User, 8..11)
3238 ]
3239 );
3240
3241 assert_eq!(
3242 message_ids_for_offsets(&conversation, &[0, 4, 9], cx),
3243 [message_1.id, message_2.id, message_3.id]
3244 );
3245 assert_eq!(
3246 message_ids_for_offsets(&conversation, &[0, 1, 11], cx),
3247 [message_1.id, message_3.id]
3248 );
3249
3250 let message_4 = conversation
3251 .update(cx, |conversation, cx| {
3252 conversation.insert_message_after(message_3.id, Role::User, MessageStatus::Done, cx)
3253 })
3254 .unwrap();
3255 assert_eq!(buffer.read(cx).text(), "aaa\nbbb\nccc\n");
3256 assert_eq!(
3257 messages(&conversation, cx),
3258 vec![
3259 (message_1.id, Role::User, 0..4),
3260 (message_2.id, Role::User, 4..8),
3261 (message_3.id, Role::User, 8..12),
3262 (message_4.id, Role::User, 12..12)
3263 ]
3264 );
3265 assert_eq!(
3266 message_ids_for_offsets(&conversation, &[0, 4, 8, 12], cx),
3267 [message_1.id, message_2.id, message_3.id, message_4.id]
3268 );
3269
3270 fn message_ids_for_offsets(
3271 conversation: &Model<Conversation>,
3272 offsets: &[usize],
3273 cx: &AppContext,
3274 ) -> Vec<MessageId> {
3275 conversation
3276 .read(cx)
3277 .messages_for_offsets(offsets.iter().copied(), cx)
3278 .into_iter()
3279 .map(|message| message.id)
3280 .collect()
3281 }
3282 }
3283
3284 #[gpui::test]
3285 async fn test_serialization(cx: &mut TestAppContext) {
3286 let settings_store = cx.update(SettingsStore::test);
3287 cx.set_global(settings_store);
3288 cx.set_global(CompletionProvider::Fake(FakeCompletionProvider::default()));
3289 cx.update(init);
3290 let registry = Arc::new(LanguageRegistry::test(cx.executor()));
3291 let conversation = cx.new_model(|cx| {
3292 Conversation::new(
3293 LanguageModel::default(),
3294 registry.clone(),
3295 EmbeddedScope::new(),
3296 cx,
3297 )
3298 });
3299 let buffer = conversation.read_with(cx, |conversation, _| conversation.buffer.clone());
3300 let message_0 =
3301 conversation.read_with(cx, |conversation, _| conversation.message_anchors[0].id);
3302 let message_1 = conversation.update(cx, |conversation, cx| {
3303 conversation
3304 .insert_message_after(message_0, Role::Assistant, MessageStatus::Done, cx)
3305 .unwrap()
3306 });
3307 let message_2 = conversation.update(cx, |conversation, cx| {
3308 conversation
3309 .insert_message_after(message_1.id, Role::System, MessageStatus::Done, cx)
3310 .unwrap()
3311 });
3312 buffer.update(cx, |buffer, cx| {
3313 buffer.edit([(0..0, "a"), (1..1, "b\nc")], None, cx);
3314 buffer.finalize_last_transaction();
3315 });
3316 let _message_3 = conversation.update(cx, |conversation, cx| {
3317 conversation
3318 .insert_message_after(message_2.id, Role::System, MessageStatus::Done, cx)
3319 .unwrap()
3320 });
3321 buffer.update(cx, |buffer, cx| buffer.undo(cx));
3322 assert_eq!(buffer.read_with(cx, |buffer, _| buffer.text()), "a\nb\nc\n");
3323 assert_eq!(
3324 cx.read(|cx| messages(&conversation, cx)),
3325 [
3326 (message_0, Role::User, 0..2),
3327 (message_1.id, Role::Assistant, 2..6),
3328 (message_2.id, Role::System, 6..6),
3329 ]
3330 );
3331
3332 let deserialized_conversation = Conversation::deserialize(
3333 conversation.read_with(cx, |conversation, cx| conversation.serialize(cx)),
3334 LanguageModel::default(),
3335 Default::default(),
3336 registry.clone(),
3337 &mut cx.to_async(),
3338 )
3339 .await
3340 .unwrap();
3341 let deserialized_buffer =
3342 deserialized_conversation.read_with(cx, |conversation, _| conversation.buffer.clone());
3343 assert_eq!(
3344 deserialized_buffer.read_with(cx, |buffer, _| buffer.text()),
3345 "a\nb\nc\n"
3346 );
3347 assert_eq!(
3348 cx.read(|cx| messages(&deserialized_conversation, cx)),
3349 [
3350 (message_0, Role::User, 0..2),
3351 (message_1.id, Role::Assistant, 2..6),
3352 (message_2.id, Role::System, 6..6),
3353 ]
3354 );
3355 }
3356
3357 fn messages(
3358 conversation: &Model<Conversation>,
3359 cx: &AppContext,
3360 ) -> Vec<(MessageId, Role, Range<usize>)> {
3361 conversation
3362 .read(cx)
3363 .messages(cx)
3364 .map(|message| (message.id, message.role, message.offset_range))
3365 .collect()
3366 }
3367}