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