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