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