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