; fn render(&mut self, cx: &mut ViewContext) -> Self::Element { if let Some(api_key_editor) = self.api_key_editor.clone() { v_stack() .on_action(cx.listener(AssistantPanel::save_credentials)) .track_focus(&self.focus_handle) .child(Label::new( "To use the assistant panel or inline assistant, you need to add your OpenAI api key.", )) .child(Label::new( " - Having a subscription for another service like GitHub Copilot won't work." )) .child(Label::new( " - You can create a api key at: platform.openai.com/api-keys" )) .child(Label::new( " " )) .child(Label::new( "Paste your OpenAI API key and press Enter to use the assistant" )) .child(api_key_editor) .child(Label::new( "Click on the Z button in the status bar to close this panel." )) .border() .border_color(gpui::red()) } else { let title = self .active_editor() .map(|editor| Label::new(editor.read(cx).title(cx))); let mut header = h_stack() .child(Self::render_hamburger_button(cx)) .children(title); if self.focus_handle.contains_focused(cx) { header = header .children(self.render_editor_tools(cx)) .child(Self::render_plus_button(cx)) .child(self.render_zoom_button(cx)); } v_stack() .size_full() .on_action(cx.listener(|this, _: &workspace::NewFile, cx| { this.new_conversation(cx); })) .on_action(cx.listener(AssistantPanel::reset_credentials)) .on_action(cx.listener(AssistantPanel::toggle_zoom)) .on_action(cx.listener(AssistantPanel::deploy)) .on_action(cx.listener(AssistantPanel::select_next_match)) .on_action(cx.listener(AssistantPanel::select_prev_match)) .on_action(cx.listener(AssistantPanel::handle_editor_cancel)) .track_focus(&self.focus_handle) .child(header) .children(if self.toolbar.read(cx).hidden() { None } else { Some(self.toolbar.clone()) }) .child( div() .flex_1() .child(if let Some(editor) = self.active_editor() { editor.clone().into_any_element() } else { uniform_list( cx.view().clone(), "saved_conversations", self.saved_conversations.len(), |this, range, cx| { range .map(|ix| this.render_saved_conversation(ix, cx)) .collect() }, ) .track_scroll(self.saved_conversations_scroll_handle.clone()) .into_any_element() }), ) .border() .border_color(gpui::red()) } } } impl Panel for AssistantPanel { fn persistent_name() -> &'static str { "AssistantPanel" } fn position(&self, cx: &WindowContext) -> DockPosition { match AssistantSettings::get_global(cx).dock { AssistantDockPosition::Left => DockPosition::Left, AssistantDockPosition::Bottom => DockPosition::Bottom, AssistantDockPosition::Right => DockPosition::Right, } } fn position_is_valid(&self, _: DockPosition) -> bool { true } fn set_position(&mut self, position: DockPosition, cx: &mut ViewContext) { settings::update_settings_file::(self.fs.clone(), cx, move |settings| { let dock = match position { DockPosition::Left => AssistantDockPosition::Left, DockPosition::Bottom => AssistantDockPosition::Bottom, DockPosition::Right => AssistantDockPosition::Right, }; settings.dock = Some(dock); }); } fn size(&self, cx: &WindowContext) -> f32 { let settings = AssistantSettings::get_global(cx); match self.position(cx) { DockPosition::Left | DockPosition::Right => { self.width.unwrap_or_else(|| settings.default_width) } DockPosition::Bottom => self.height.unwrap_or_else(|| settings.default_height), } } fn set_size(&mut self, size: Option, cx: &mut ViewContext) { match self.position(cx) { DockPosition::Left | DockPosition::Right => self.width = size, DockPosition::Bottom => self.height = size, } cx.notify(); } fn is_zoomed(&self, _: &WindowContext) -> bool { self.zoomed } fn set_zoomed(&mut self, zoomed: bool, cx: &mut ViewContext) { self.zoomed = zoomed; cx.notify(); } fn set_active(&mut self, active: bool, cx: &mut ViewContext) { if active { self.load_credentials(cx); if self.editors.is_empty() { self.new_conversation(cx); } } } fn icon(&self, _cx: &WindowContext) -> Option { Some(Icon::Ai) } fn toggle_action(&self) -> Box { Box::new(ToggleFocus) } } impl EventEmitter for AssistantPanel {} impl FocusableView for AssistantPanel { fn focus_handle(&self, _cx: &AppContext) -> FocusHandle { self.focus_handle.clone() } } enum ConversationEvent { MessagesEdited, SummaryChanged, StreamedCompletion, } #[derive(Default)] struct Summary { text: String, done: bool, } struct Conversation { id: Option, buffer: Model, message_anchors: Vec, messages_metadata: HashMap, next_message_id: MessageId, summary: Option

, pending_summary: Task>, completion_count: usize, pending_completions: Vec, model: OpenAIModel, token_count: Option, max_token_count: usize, pending_token_count: Task>, pending_save: Task>, path: Option, _subscriptions: Vec, completion_provider: Arc, } impl EventEmitter for Conversation {} impl Conversation { fn new( language_registry: Arc, cx: &mut ModelContext, completion_provider: Arc, ) -> Self { let markdown = language_registry.language_for_name("Markdown"); let buffer = cx.build_model(|cx| { let mut buffer = Buffer::new(0, cx.entity_id().as_u64(), ""); buffer.set_language_registry(language_registry); cx.spawn(|buffer, mut cx| async move { let markdown = markdown.await?; buffer.update(&mut cx, |buffer: &mut Buffer, cx| { buffer.set_language(Some(markdown), cx) })?; anyhow::Ok(()) }) .detach_and_log_err(cx); buffer }); let settings = AssistantSettings::get_global(cx); let model = settings.default_open_ai_model.clone(); let mut this = Self { id: Some(Uuid::new_v4().to_string()), message_anchors: Default::default(), messages_metadata: Default::default(), next_message_id: Default::default(), summary: None, pending_summary: Task::ready(None), completion_count: Default::default(), pending_completions: Default::default(), token_count: None, max_token_count: tiktoken_rs::model::get_context_size(&model.full_name()), pending_token_count: Task::ready(None), model: model.clone(), _subscriptions: vec![cx.subscribe(&buffer, Self::handle_buffer_event)], pending_save: Task::ready(Ok(())), path: None, buffer, completion_provider, }; let message = MessageAnchor { id: MessageId(post_inc(&mut this.next_message_id.0)), start: language::Anchor::MIN, }; this.message_anchors.push(message.clone()); this.messages_metadata.insert( message.id, MessageMetadata { role: Role::User, sent_at: Local::now(), status: MessageStatus::Done, }, ); this.count_remaining_tokens(cx); this } fn serialize(&self, cx: &AppContext) -> SavedConversation { SavedConversation { id: self.id.clone(), zed: "conversation".into(), version: SavedConversation::VERSION.into(), text: self.buffer.read(cx).text(), message_metadata: self.messages_metadata.clone(), messages: self .messages(cx) .map(|message| SavedMessage { id: message.id, start: message.offset_range.start, }) .collect(), summary: self .summary .as_ref() .map(|summary| summary.text.clone()) .unwrap_or_default(), model: self.model.clone(), } } fn deserialize( saved_conversation: SavedConversation, path: PathBuf, language_registry: Arc, cx: &mut ModelContext, ) -> Self { let id = match saved_conversation.id { Some(id) => Some(id), None => Some(Uuid::new_v4().to_string()), }; let model = saved_conversation.model; let completion_provider: Arc = Arc::new( OpenAICompletionProvider::new(model.full_name(), cx.background_executor().clone()), ); completion_provider.retrieve_credentials(cx); let markdown = language_registry.language_for_name("Markdown"); let mut message_anchors = Vec::new(); let mut next_message_id = MessageId(0); let buffer = cx.build_model(|cx| { let mut buffer = Buffer::new(0, cx.entity_id().as_u64(), saved_conversation.text); for message in saved_conversation.messages { message_anchors.push(MessageAnchor { id: message.id, start: buffer.anchor_before(message.start), }); next_message_id = cmp::max(next_message_id, MessageId(message.id.0 + 1)); } buffer.set_language_registry(language_registry); cx.spawn(|buffer, mut cx| async move { let markdown = markdown.await?; buffer.update(&mut cx, |buffer: &mut Buffer, cx| { buffer.set_language(Some(markdown), cx) })?; anyhow::Ok(()) }) .detach_and_log_err(cx); buffer }); let mut this = Self { id, message_anchors, messages_metadata: saved_conversation.message_metadata, next_message_id, summary: Some(Summary { text: saved_conversation.summary, done: true, }), pending_summary: Task::ready(None), completion_count: Default::default(), pending_completions: Default::default(), token_count: None, max_token_count: tiktoken_rs::model::get_context_size(&model.full_name()), pending_token_count: Task::ready(None), model, _subscriptions: vec![cx.subscribe(&buffer, Self::handle_buffer_event)], pending_save: Task::ready(Ok(())), path: Some(path), buffer, completion_provider, }; this.count_remaining_tokens(cx); this } fn handle_buffer_event( &mut self, _: Model, event: &language::Event, cx: &mut ModelContext, ) { match event { language::Event::Edited => { self.count_remaining_tokens(cx); cx.emit(ConversationEvent::MessagesEdited); } _ => {} } } fn count_remaining_tokens(&mut self, cx: &mut ModelContext) { let messages = self .messages(cx) .into_iter() .filter_map(|message| { Some(tiktoken_rs::ChatCompletionRequestMessage { role: match message.role { Role::User => "user".into(), Role::Assistant => "assistant".into(), Role::System => "system".into(), }, content: Some( self.buffer .read(cx) .text_for_range(message.offset_range) .collect(), ), name: None, function_call: None, }) }) .collect::>(); let model = self.model.clone(); self.pending_token_count = cx.spawn(|this, mut cx| { async move { cx.background_executor() .timer(Duration::from_millis(200)) .await; let token_count = cx .background_executor() .spawn(async move { tiktoken_rs::num_tokens_from_messages(&model.full_name(), &messages) }) .await?; this.update(&mut cx, |this, cx| { this.max_token_count = tiktoken_rs::model::get_context_size(&this.model.full_name()); this.token_count = Some(token_count); cx.notify() })?; anyhow::Ok(()) } .log_err() }); } fn remaining_tokens(&self) -> Option { Some(self.max_token_count as isize - self.token_count? as isize) } fn set_model(&mut self, model: OpenAIModel, cx: &mut ModelContext) { self.model = model; self.count_remaining_tokens(cx); cx.notify(); } fn assist( &mut self, selected_messages: HashSet, cx: &mut ModelContext, ) -> Vec { let mut user_messages = Vec::new(); let last_message_id = if let Some(last_message_id) = self.message_anchors.iter().rev().find_map(|message| { message .start .is_valid(self.buffer.read(cx)) .then_some(message.id) }) { last_message_id } else { return Default::default(); }; let mut should_assist = false; for selected_message_id in selected_messages { let selected_message_role = if let Some(metadata) = self.messages_metadata.get(&selected_message_id) { metadata.role } else { continue; }; if selected_message_role == Role::Assistant { if let Some(user_message) = self.insert_message_after( selected_message_id, Role::User, MessageStatus::Done, cx, ) { user_messages.push(user_message); } } else { should_assist = true; } } if should_assist { if !self.completion_provider.has_credentials() { return Default::default(); } let request: Box = Box::new(OpenAIRequest { model: self.model.full_name().to_string(), messages: self .messages(cx) .filter(|message| matches!(message.status, MessageStatus::Done)) .map(|message| message.to_open_ai_message(self.buffer.read(cx))) .collect(), stream: true, stop: vec![], temperature: 1.0, }); let stream = self.completion_provider.complete(request); let assistant_message = self .insert_message_after(last_message_id, Role::Assistant, MessageStatus::Pending, cx) .unwrap(); // Queue up the user's next reply. let user_message = self .insert_message_after(assistant_message.id, Role::User, MessageStatus::Done, cx) .unwrap(); user_messages.push(user_message); let task = cx.spawn({ |this, mut cx| async move { let assistant_message_id = assistant_message.id; let stream_completion = async { let mut messages = stream.await?; while let Some(message) = messages.next().await { let text = message?; this.update(&mut cx, |this, cx| { let message_ix = this .message_anchors .iter() .position(|message| message.id == assistant_message_id)?; this.buffer.update(cx, |buffer, cx| { let offset = this.message_anchors[message_ix + 1..] .iter() .find(|message| message.start.is_valid(buffer)) .map_or(buffer.len(), |message| { message.start.to_offset(buffer).saturating_sub(1) }); buffer.edit([(offset..offset, text)], None, cx); }); cx.emit(ConversationEvent::StreamedCompletion); Some(()) })?; smol::future::yield_now().await; } this.update(&mut cx, |this, cx| { this.pending_completions .retain(|completion| completion.id != this.completion_count); this.summarize(cx); })?; anyhow::Ok(()) }; let result = stream_completion.await; this.update(&mut cx, |this, cx| { if let Some(metadata) = this.messages_metadata.get_mut(&assistant_message.id) { match result { Ok(_) => { metadata.status = MessageStatus::Done; } Err(error) => { metadata.status = MessageStatus::Error(error.to_string().trim().into()); } } cx.notify(); } }) .ok(); } }); self.pending_completions.push(PendingCompletion { id: post_inc(&mut self.completion_count), _task: task, }); } user_messages } fn cancel_last_assist(&mut self) -> bool { self.pending_completions.pop().is_some() } fn cycle_message_roles(&mut self, ids: HashSet, cx: &mut ModelContext) { for id in ids { if let Some(metadata) = self.messages_metadata.get_mut(&id) { metadata.role.cycle(); cx.emit(ConversationEvent::MessagesEdited); cx.notify(); } } } fn insert_message_after( &mut self, message_id: MessageId, role: Role, status: MessageStatus, cx: &mut ModelContext, ) -> Option { if let Some(prev_message_ix) = self .message_anchors .iter() .position(|message| message.id == message_id) { // Find the next valid message after the one we were given. let mut next_message_ix = prev_message_ix + 1; while let Some(next_message) = self.message_anchors.get(next_message_ix) { if next_message.start.is_valid(self.buffer.read(cx)) { break; } next_message_ix += 1; } let start = self.buffer.update(cx, |buffer, cx| { let offset = self .message_anchors .get(next_message_ix) .map_or(buffer.len(), |message| message.start.to_offset(buffer) - 1); buffer.edit([(offset..offset, "\n")], None, cx); buffer.anchor_before(offset + 1) }); let message = MessageAnchor { id: MessageId(post_inc(&mut self.next_message_id.0)), start, }; self.message_anchors .insert(next_message_ix, message.clone()); self.messages_metadata.insert( message.id, MessageMetadata { role, sent_at: Local::now(), status, }, ); cx.emit(ConversationEvent::MessagesEdited); Some(message) } else { None } } fn split_message( &mut self, range: Range, cx: &mut ModelContext, ) -> (Option, Option) { let start_message = self.message_for_offset(range.start, cx); let end_message = self.message_for_offset(range.end, cx); if let Some((start_message, end_message)) = start_message.zip(end_message) { // Prevent splitting when range spans multiple messages. if start_message.id != end_message.id { return (None, None); } let message = start_message; let role = message.role; let mut edited_buffer = false; let mut suffix_start = None; if range.start > message.offset_range.start && range.end < message.offset_range.end - 1 { if self.buffer.read(cx).chars_at(range.end).next() == Some('\n') { suffix_start = Some(range.end + 1); } else if self.buffer.read(cx).reversed_chars_at(range.end).next() == Some('\n') { suffix_start = Some(range.end); } } let suffix = if let Some(suffix_start) = suffix_start { MessageAnchor { id: MessageId(post_inc(&mut self.next_message_id.0)), start: self.buffer.read(cx).anchor_before(suffix_start), } } else { self.buffer.update(cx, |buffer, cx| { buffer.edit([(range.end..range.end, "\n")], None, cx); }); edited_buffer = true; MessageAnchor { id: MessageId(post_inc(&mut self.next_message_id.0)), start: self.buffer.read(cx).anchor_before(range.end + 1), } }; self.message_anchors .insert(message.index_range.end + 1, suffix.clone()); self.messages_metadata.insert( suffix.id, MessageMetadata { role, sent_at: Local::now(), status: MessageStatus::Done, }, ); let new_messages = if range.start == range.end || range.start == message.offset_range.start { (None, Some(suffix)) } else { let mut prefix_end = None; if range.start > message.offset_range.start && range.end < message.offset_range.end - 1 { if self.buffer.read(cx).chars_at(range.start).next() == Some('\n') { prefix_end = Some(range.start + 1); } else if self.buffer.read(cx).reversed_chars_at(range.start).next() == Some('\n') { prefix_end = Some(range.start); } } let selection = if let Some(prefix_end) = prefix_end { cx.emit(ConversationEvent::MessagesEdited); MessageAnchor { id: MessageId(post_inc(&mut self.next_message_id.0)), start: self.buffer.read(cx).anchor_before(prefix_end), } } else { self.buffer.update(cx, |buffer, cx| { buffer.edit([(range.start..range.start, "\n")], None, cx) }); edited_buffer = true; MessageAnchor { id: MessageId(post_inc(&mut self.next_message_id.0)), start: self.buffer.read(cx).anchor_before(range.end + 1), } }; self.message_anchors .insert(message.index_range.end + 1, selection.clone()); self.messages_metadata.insert( selection.id, MessageMetadata { role, sent_at: Local::now(), status: MessageStatus::Done, }, ); (Some(selection), Some(suffix)) }; if !edited_buffer { cx.emit(ConversationEvent::MessagesEdited); } new_messages } else { (None, None) } } fn summarize(&mut self, cx: &mut ModelContext) { if self.message_anchors.len() >= 2 && self.summary.is_none() { if !self.completion_provider.has_credentials() { return; } let messages = self .messages(cx) .take(2) .map(|message| message.to_open_ai_message(self.buffer.read(cx))) .chain(Some(RequestMessage { role: Role::User, content: "Summarize the conversation into a short title without punctuation" .into(), })); let request: Box = Box::new(OpenAIRequest { model: self.model.full_name().to_string(), messages: messages.collect(), stream: true, stop: vec![], temperature: 1.0, }); let stream = self.completion_provider.complete(request); self.pending_summary = cx.spawn(|this, mut cx| { async move { let mut messages = stream.await?; while let Some(message) = messages.next().await { let text = message?; this.update(&mut cx, |this, cx| { this.summary .get_or_insert(Default::default()) .text .push_str(&text); cx.emit(ConversationEvent::SummaryChanged); })?; } this.update(&mut cx, |this, cx| { if let Some(summary) = this.summary.as_mut() { summary.done = true; cx.emit(ConversationEvent::SummaryChanged); } })?; anyhow::Ok(()) } .log_err() }); } } fn message_for_offset(&self, offset: usize, cx: &AppContext) -> Option { self.messages_for_offsets([offset], cx).pop() } fn messages_for_offsets( &self, offsets: impl IntoIterator, cx: &AppContext, ) -> Vec { let mut result = Vec::new(); let mut messages = self.messages(cx).peekable(); let mut offsets = offsets.into_iter().peekable(); let mut current_message = messages.next(); while let Some(offset) = offsets.next() { // Locate the message that contains the offset. while current_message.as_ref().map_or(false, |message| { !message.offset_range.contains(&offset) && messages.peek().is_some() }) { current_message = messages.next(); } let Some(message) = current_message.as_ref() else { break; }; // Skip offsets that are in the same message. while offsets.peek().map_or(false, |offset| { message.offset_range.contains(offset) || messages.peek().is_none() }) { offsets.next(); } result.push(message.clone()); } result } fn messages<'a>(&'a self, cx: &'a AppContext) -> impl 'a + Iterator { let buffer = self.buffer.read(cx); let mut message_anchors = self.message_anchors.iter().enumerate().peekable(); iter::from_fn(move || { while let Some((start_ix, message_anchor)) = message_anchors.next() { let metadata = self.messages_metadata.get(&message_anchor.id)?; let message_start = message_anchor.start.to_offset(buffer); let mut message_end = None; let mut end_ix = start_ix; while let Some((_, next_message)) = message_anchors.peek() { if next_message.start.is_valid(buffer) { message_end = Some(next_message.start); break; } else { end_ix += 1; message_anchors.next(); } } let message_end = message_end .unwrap_or(language::Anchor::MAX) .to_offset(buffer); return Some(Message { index_range: start_ix..end_ix, offset_range: message_start..message_end, id: message_anchor.id, anchor: message_anchor.start, role: metadata.role, sent_at: metadata.sent_at, status: metadata.status.clone(), }); } None }) } fn save( &mut self, debounce: Option, fs: Arc, cx: &mut ModelContext, ) { self.pending_save = cx.spawn(|this, mut cx| async move { if let Some(debounce) = debounce { cx.background_executor().timer(debounce).await; } let (old_path, summary) = this.read_with(&cx, |this, _| { let path = this.path.clone(); let summary = if let Some(summary) = this.summary.as_ref() { if summary.done { Some(summary.text.clone()) } else { None } } else { None }; (path, summary) })?; if let Some(summary) = summary { let conversation = this.read_with(&cx, |this, cx| this.serialize(cx))?; let path = if let Some(old_path) = old_path { old_path } else { let mut discriminant = 1; let mut new_path; loop { new_path = CONVERSATIONS_DIR.join(&format!( "{} - {}.zed.json", summary.trim(), discriminant )); if fs.is_file(&new_path).await { discriminant += 1; } else { break; } } new_path }; fs.create_dir(CONVERSATIONS_DIR.as_ref()).await?; fs.atomic_write(path.clone(), serde_json::to_string(&conversation).unwrap()) .await?; this.update(&mut cx, |this, _| this.path = Some(path))?; } Ok(()) }); } } struct PendingCompletion { id: usize, _task: Task<()>, } enum ConversationEditorEvent { TabContentChanged, } #[derive(Copy, Clone, Debug, PartialEq)] struct ScrollPosition { offset_before_cursor: gpui::Point, cursor: Anchor, } struct ConversationEditor { conversation: Model, fs: Arc, workspace: WeakView, editor: View, blocks: HashSet, scroll_position: Option, focus_handle: FocusHandle, _subscriptions: Vec, } impl ConversationEditor { fn new( completion_provider: Arc, language_registry: Arc, fs: Arc, workspace: WeakView, cx: &mut ViewContext, ) -> Self { let conversation = cx.build_model(|cx| Conversation::new(language_registry, cx, completion_provider)); Self::for_conversation(conversation, fs, workspace, cx) } fn for_conversation( conversation: Model, fs: Arc, workspace: WeakView, cx: &mut ViewContext, ) -> Self { let editor = cx.build_view(|cx| { let mut editor = Editor::for_buffer(conversation.read(cx).buffer.clone(), None, cx); editor.set_soft_wrap_mode(SoftWrap::EditorWidth, cx); editor.set_show_gutter(false, cx); editor.set_show_wrap_guides(false, cx); editor }); let focus_handle = cx.focus_handle(); let _subscriptions = vec![ cx.observe(&conversation, |_, _, cx| cx.notify()), cx.subscribe(&conversation, Self::handle_conversation_event), cx.subscribe(&editor, Self::handle_editor_event), cx.on_focus(&focus_handle, |this, cx| cx.focus_view(&this.editor)), ]; let mut this = Self { conversation, editor, blocks: Default::default(), scroll_position: None, fs, workspace, focus_handle, _subscriptions, }; this.update_message_headers(cx); this } fn assist(&mut self, _: &Assist, cx: &mut ViewContext) { report_assistant_event( self.workspace.clone(), self.conversation.read(cx).id.clone(), AssistantKind::Panel, cx, ); let cursors = self.cursors(cx); let user_messages = self.conversation.update(cx, |conversation, cx| { let selected_messages = conversation .messages_for_offsets(cursors, cx) .into_iter() .map(|message| message.id) .collect(); conversation.assist(selected_messages, cx) }); let new_selections = user_messages .iter() .map(|message| { let cursor = message .start .to_offset(self.conversation.read(cx).buffer.read(cx)); cursor..cursor }) .collect::>(); if !new_selections.is_empty() { self.editor.update(cx, |editor, cx| { editor.change_selections( Some(Autoscroll::Strategy(AutoscrollStrategy::Fit)), cx, |selections| selections.select_ranges(new_selections), ); }); // Avoid scrolling to the new cursor position so the assistant's output is stable. cx.defer(|this, _| this.scroll_position = None); } } fn cancel_last_assist(&mut self, _: &editor::Cancel, cx: &mut ViewContext) { if !self .conversation .update(cx, |conversation, _| conversation.cancel_last_assist()) { cx.propagate(); } } fn cycle_message_role(&mut self, _: &CycleMessageRole, cx: &mut ViewContext) { let cursors = self.cursors(cx); self.conversation.update(cx, |conversation, cx| { let messages = conversation .messages_for_offsets(cursors, cx) .into_iter() .map(|message| message.id) .collect(); conversation.cycle_message_roles(messages, cx) }); } fn cursors(&self, cx: &AppContext) -> Vec { let selections = self.editor.read(cx).selections.all::(cx); selections .into_iter() .map(|selection| selection.head()) .collect() } fn handle_conversation_event( &mut self, _: Model, event: &ConversationEvent, cx: &mut ViewContext, ) { match event { ConversationEvent::MessagesEdited => { self.update_message_headers(cx); self.conversation.update(cx, |conversation, cx| { conversation.save(Some(Duration::from_millis(500)), self.fs.clone(), cx); }); } ConversationEvent::SummaryChanged => { cx.emit(ConversationEditorEvent::TabContentChanged); self.conversation.update(cx, |conversation, cx| { conversation.save(None, self.fs.clone(), cx); }); } ConversationEvent::StreamedCompletion => { self.editor.update(cx, |editor, cx| { if let Some(scroll_position) = self.scroll_position { let snapshot = editor.snapshot(cx); let cursor_point = scroll_position.cursor.to_display_point(&snapshot); let scroll_top = cursor_point.row() as f32 - scroll_position.offset_before_cursor.y; editor.set_scroll_position( point(scroll_position.offset_before_cursor.x, scroll_top), cx, ); } }); } } } fn handle_editor_event( &mut self, _: View, event: &EditorEvent, cx: &mut ViewContext, ) { match event { EditorEvent::ScrollPositionChanged { autoscroll, .. } => { let cursor_scroll_position = self.cursor_scroll_position(cx); if *autoscroll { self.scroll_position = cursor_scroll_position; } else if self.scroll_position != cursor_scroll_position { self.scroll_position = None; } } EditorEvent::SelectionsChanged { .. } => { self.scroll_position = self.cursor_scroll_position(cx); } _ => {} } } fn cursor_scroll_position(&self, cx: &mut ViewContext) -> Option { self.editor.update(cx, |editor, cx| { let snapshot = editor.snapshot(cx); let cursor = editor.selections.newest_anchor().head(); let cursor_row = cursor.to_display_point(&snapshot.display_snapshot).row() as f32; let scroll_position = editor .scroll_manager .anchor() .scroll_position(&snapshot.display_snapshot); let scroll_bottom = scroll_position.y + editor.visible_line_count().unwrap_or(0.); if (scroll_position.y..scroll_bottom).contains(&cursor_row) { Some(ScrollPosition { cursor, offset_before_cursor: point(scroll_position.x, cursor_row - scroll_position.y), }) } else { None } }) } fn update_message_headers(&mut self, cx: &mut ViewContext) { self.editor.update(cx, |editor, cx| { let buffer = editor.buffer().read(cx).snapshot(cx); let excerpt_id = *buffer.as_singleton().unwrap().0; let old_blocks = std::mem::take(&mut self.blocks); let new_blocks = self .conversation .read(cx) .messages(cx) .map(|message| BlockProperties { position: buffer.anchor_in_excerpt(excerpt_id, message.anchor), height: 2, style: BlockStyle::Sticky, render: Arc::new({ let conversation = self.conversation.clone(); move |_cx| { let message_id = message.id; let sender = ButtonLike::new("role") .child(match message.role { Role::User => Label::new("You").color(Color::Default), Role::Assistant => { Label::new("Assistant").color(Color::Modified) } Role::System => Label::new("System").color(Color::Warning), }) .on_click({ let conversation = conversation.clone(); move |_, cx| { conversation.update(cx, |conversation, cx| { conversation.cycle_message_roles( HashSet::from_iter(Some(message_id)), cx, ) }) } }); h_stack() .id(("message_header", message_id.0)) .border() .border_color(gpui::red()) .child(sender) .child(Label::new(message.sent_at.format("%I:%M%P").to_string())) .children( if let MessageStatus::Error(error) = message.status.clone() { Some( div() .id("error") .tooltip(move |cx| Tooltip::text(&error, cx)) .child(IconElement::new(Icon::XCircle)), ) } else { None }, ) .into_any_element() } }), disposition: BlockDisposition::Above, }) .collect::>(); editor.remove_blocks(old_blocks, None, cx); let ids = editor.insert_blocks(new_blocks, None, cx); self.blocks = HashSet::from_iter(ids); }); } fn quote_selection( workspace: &mut Workspace, _: &QuoteSelection, cx: &mut ViewContext, ) { let Some(panel) = workspace.panel::(cx) else { return; }; let Some(editor) = workspace .active_item(cx) .and_then(|item| item.act_as::(cx)) else { return; }; let editor = editor.read(cx); let range = editor.selections.newest::(cx).range(); let buffer = editor.buffer().read(cx).snapshot(cx); let start_language = buffer.language_at(range.start); let end_language = buffer.language_at(range.end); let language_name = if start_language == end_language { start_language.map(|language| language.name()) } else { None }; let language_name = language_name.as_deref().unwrap_or("").to_lowercase(); let selected_text = buffer.text_for_range(range).collect::(); let text = if selected_text.is_empty() { None } else { Some(if language_name == "markdown" { selected_text .lines() .map(|line| format!("> {}", line)) .collect::>() .join("\n") } else { format!("```{language_name}\n{selected_text}\n```") }) }; // Activate the panel if !panel.focus_handle(cx).contains_focused(cx) { workspace.toggle_panel_focus::(cx); } if let Some(text) = text { panel.update(cx, |panel, cx| { let conversation = panel .active_editor() .cloned() .unwrap_or_else(|| panel.new_conversation(cx)); conversation.update(cx, |conversation, cx| { conversation .editor .update(cx, |editor, cx| editor.insert(&text, cx)) }); }); } } fn copy(&mut self, _: &editor::Copy, cx: &mut ViewContext) { let editor = self.editor.read(cx); let conversation = self.conversation.read(cx); if editor.selections.count() == 1 { let selection = editor.selections.newest::(cx); let mut copied_text = String::new(); let mut spanned_messages = 0; for message in conversation.messages(cx) { if message.offset_range.start >= selection.range().end { break; } else if message.offset_range.end >= selection.range().start { let range = cmp::max(message.offset_range.start, selection.range().start) ..cmp::min(message.offset_range.end, selection.range().end); if !range.is_empty() { spanned_messages += 1; write!(&mut copied_text, "## {}\n\n", message.role).unwrap(); for chunk in conversation.buffer.read(cx).text_for_range(range) { copied_text.push_str(&chunk); } copied_text.push('\n'); } } } if spanned_messages > 1 { cx.write_to_clipboard(ClipboardItem::new(copied_text)); return; } } cx.propagate(); } fn split(&mut self, _: &Split, cx: &mut ViewContext) { self.conversation.update(cx, |conversation, cx| { let selections = self.editor.read(cx).selections.disjoint_anchors(); for selection in selections.into_iter() { let buffer = self.editor.read(cx).buffer().read(cx).snapshot(cx); let range = selection .map(|endpoint| endpoint.to_offset(&buffer)) .range(); conversation.split_message(range, cx); } }); } fn save(&mut self, _: &Save, cx: &mut ViewContext) { self.conversation.update(cx, |conversation, cx| { conversation.save(None, self.fs.clone(), cx) }); } fn cycle_model(&mut self, cx: &mut ViewContext) { self.conversation.update(cx, |conversation, cx| { let new_model = conversation.model.cycle(); conversation.set_model(new_model, cx); }); } fn title(&self, cx: &AppContext) -> String { self.conversation .read(cx) .summary .as_ref() .map(|summary| summary.text.clone()) .unwrap_or_else(|| "New Conversation".into()) } fn render_current_model(&self, cx: &mut ViewContext) -> impl IntoElement { Button::new( "current_model", self.conversation.read(cx).model.short_name(), ) .tooltip(move |cx| Tooltip::text("Change Model", cx)) .on_click(cx.listener(|this, _, cx| this.cycle_model(cx))) } fn render_remaining_tokens(&self, cx: &mut ViewContext) -> Option { let remaining_tokens = self.conversation.read(cx).remaining_tokens()?; let remaining_tokens_color = if remaining_tokens <= 0 { Color::Error } else if remaining_tokens <= 500 { Color::Warning } else { Color::Default }; Some( div() .border() .border_color(gpui::red()) .child(Label::new(remaining_tokens.to_string()).color(remaining_tokens_color)), ) } } impl EventEmitter for ConversationEditor {} impl Render for ConversationEditor { type Element = Div; fn render(&mut self, cx: &mut ViewContext) -> Self::Element { div() .key_context("ConversationEditor") .size_full() .relative() .capture_action(cx.listener(ConversationEditor::cancel_last_assist)) .capture_action(cx.listener(ConversationEditor::save)) .capture_action(cx.listener(ConversationEditor::copy)) .capture_action(cx.listener(ConversationEditor::cycle_message_role)) .on_action(cx.listener(ConversationEditor::assist)) .on_action(cx.listener(ConversationEditor::split)) .child(self.editor.clone()) .child( h_stack() .absolute() .gap_1() .top_3() .right_5() .child(self.render_current_model(cx)) .children(self.render_remaining_tokens(cx)), ) } } impl FocusableView for ConversationEditor { fn focus_handle(&self, _cx: &AppContext) -> FocusHandle { self.focus_handle.clone() } } #[derive(Clone, Debug)] struct MessageAnchor { id: MessageId, start: language::Anchor, } #[derive(Clone, Debug)] pub struct Message { offset_range: Range, index_range: Range, id: MessageId, anchor: language::Anchor, role: Role, sent_at: DateTime, status: MessageStatus, } impl Message { fn to_open_ai_message(&self, buffer: &Buffer) -> RequestMessage { let content = buffer .text_for_range(self.offset_range.clone()) .collect::(); RequestMessage { role: self.role, content: content.trim_end().into(), } } } enum InlineAssistantEvent { Confirmed { prompt: String, include_conversation: bool, retrieve_context: bool, }, Canceled, Dismissed, IncludeConversationToggled { include_conversation: bool, }, RetrieveContextToggled { retrieve_context: bool, }, } struct InlineAssistant { id: usize, prompt_editor: View, workspace: WeakView, confirmed: bool, focus_handle: FocusHandle, include_conversation: bool, measurements: Rc>, prompt_history: VecDeque, prompt_history_ix: Option, pending_prompt: String, codegen: Model, _subscriptions: Vec, retrieve_context: bool, semantic_index: Option>, semantic_permissioned: Option, project: WeakModel, maintain_rate_limit: Option>, } impl EventEmitter for InlineAssistant {} impl Render for InlineAssistant { type Element = Div; fn render(&mut self, cx: &mut ViewContext) -> Self::Element { let measurements = self.measurements.get(); h_stack() .on_action(cx.listener(Self::confirm)) .on_action(cx.listener(Self::cancel)) .on_action(cx.listener(Self::toggle_include_conversation)) .on_action(cx.listener(Self::toggle_retrieve_context)) .on_action(cx.listener(Self::move_up)) .on_action(cx.listener(Self::move_down)) .child( h_stack() .justify_center() .w(measurements.gutter_width) .child( IconButton::new("include_conversation", Icon::Ai) .action(Box::new(ToggleIncludeConversation)) .selected(self.include_conversation) .tooltip(|cx| { Tooltip::for_action( "Include Conversation", &ToggleIncludeConversation, cx, ) }), ) .children(if SemanticIndex::enabled(cx) { Some( IconButton::new("retrieve_context", Icon::MagnifyingGlass) .action(Box::new(ToggleRetrieveContext)) .selected(self.retrieve_context) .tooltip(|cx| { Tooltip::for_action( "Retrieve Context", &ToggleRetrieveContext, cx, ) }), ) } else { None }) .children(if let Some(error) = self.codegen.read(cx).error() { let error_message = SharedString::from(error.to_string()); Some( div() .id("error") .tooltip(move |cx| Tooltip::text(error_message.clone(), cx)) .child(IconElement::new(Icon::XCircle).color(Color::Error)), ) } else { None }), ) .child( div() .ml(measurements.anchor_x - measurements.gutter_width) .child(self.render_prompt_editor(cx)), ) .children(if self.retrieve_context { self.retrieve_context_status(cx) } else { None }) } } impl FocusableView for InlineAssistant { fn focus_handle(&self, _cx: &AppContext) -> FocusHandle { self.focus_handle.clone() } } impl InlineAssistant { fn new( id: usize, measurements: Rc>, include_conversation: bool, prompt_history: VecDeque, codegen: Model, workspace: WeakView, cx: &mut ViewContext, retrieve_context: bool, semantic_index: Option>, project: Model, ) -> Self { let prompt_editor = cx.build_view(|cx| { let mut editor = Editor::single_line(cx); let placeholder = match codegen.read(cx).kind() { CodegenKind::Transform { .. } => "Enter transformation prompt…", CodegenKind::Generate { .. } => "Enter generation prompt…", }; editor.set_placeholder_text(placeholder, cx); editor }); let focus_handle = cx.focus_handle(); let mut subscriptions = vec![ cx.observe(&codegen, Self::handle_codegen_changed), cx.subscribe(&prompt_editor, Self::handle_prompt_editor_events), cx.on_focus(&focus_handle, |this, cx| cx.focus_view(&this.prompt_editor)), ]; if let Some(semantic_index) = semantic_index.clone() { subscriptions.push(cx.observe(&semantic_index, Self::semantic_index_changed)); } let assistant = Self { id, prompt_editor, workspace, confirmed: false, focus_handle, include_conversation, measurements, prompt_history, prompt_history_ix: None, pending_prompt: String::new(), codegen, _subscriptions: subscriptions, retrieve_context, semantic_permissioned: None, semantic_index, project: project.downgrade(), maintain_rate_limit: None, }; assistant.index_project(cx).log_err(); assistant } fn semantic_permissioned(&self, cx: &mut ViewContext) -> Task> { if let Some(value) = self.semantic_permissioned { return Task::ready(Ok(value)); } let Some(project) = self.project.upgrade() else { return Task::ready(Err(anyhow!("project was dropped"))); }; self.semantic_index .as_ref() .map(|semantic| { semantic.update(cx, |this, cx| this.project_previously_indexed(&project, cx)) }) .unwrap_or(Task::ready(Ok(false))) } fn handle_prompt_editor_events( &mut self, _: View, event: &EditorEvent, cx: &mut ViewContext, ) { if let EditorEvent::Edited = event { self.pending_prompt = self.prompt_editor.read(cx).text(cx); cx.notify(); } } fn semantic_index_changed( &mut self, semantic_index: Model, cx: &mut ViewContext, ) { let Some(project) = self.project.upgrade() else { return; }; let status = semantic_index.read(cx).status(&project); match status { SemanticIndexStatus::Indexing { rate_limit_expiry: Some(_), .. } => { if self.maintain_rate_limit.is_none() { self.maintain_rate_limit = Some(cx.spawn(|this, mut cx| async move { loop { cx.background_executor().timer(Duration::from_secs(1)).await; this.update(&mut cx, |_, cx| cx.notify()).log_err(); } })); } return; } _ => { self.maintain_rate_limit = None; } } } fn handle_codegen_changed(&mut self, _: Model, cx: &mut ViewContext) { let is_read_only = !self.codegen.read(cx).idle(); self.prompt_editor.update(cx, |editor, _cx| { let was_read_only = editor.read_only(); if was_read_only != is_read_only { if is_read_only { editor.set_read_only(true); } else { self.confirmed = false; editor.set_read_only(false); } } }); cx.notify(); } fn cancel(&mut self, _: &editor::Cancel, cx: &mut ViewContext) { cx.emit(InlineAssistantEvent::Canceled); } fn confirm(&mut self, _: &menu::Confirm, cx: &mut ViewContext) { if self.confirmed { cx.emit(InlineAssistantEvent::Dismissed); } else { report_assistant_event(self.workspace.clone(), None, AssistantKind::Inline, cx); let prompt = self.prompt_editor.read(cx).text(cx); self.prompt_editor .update(cx, |editor, _cx| editor.set_read_only(true)); cx.emit(InlineAssistantEvent::Confirmed { prompt, include_conversation: self.include_conversation, retrieve_context: self.retrieve_context, }); self.confirmed = true; cx.notify(); } } fn toggle_retrieve_context(&mut self, _: &ToggleRetrieveContext, cx: &mut ViewContext) { let semantic_permissioned = self.semantic_permissioned(cx); let Some(project) = self.project.upgrade() else { return; }; let project_name = project .read(cx) .worktree_root_names(cx) .collect::>() .join("/"); let is_plural = project_name.chars().filter(|letter| *letter == '/').count() > 0; let prompt_text = format!("Would you like to index the '{}' project{} for context retrieval? This requires sending code to the OpenAI API", project_name, if is_plural { "s" } else {""}); cx.spawn(|this, mut cx| async move { // If Necessary prompt user if !semantic_permissioned.await.unwrap_or(false) { let answer = this.update(&mut cx, |_, cx| { cx.prompt( PromptLevel::Info, prompt_text.as_str(), &["Continue", "Cancel"], ) })?; if answer.await? == 0 { this.update(&mut cx, |this, _| { this.semantic_permissioned = Some(true); })?; } else { return anyhow::Ok(()); } } // If permissioned, update context appropriately this.update(&mut cx, |this, cx| { this.retrieve_context = !this.retrieve_context; cx.emit(InlineAssistantEvent::RetrieveContextToggled { retrieve_context: this.retrieve_context, }); if this.retrieve_context { this.index_project(cx).log_err(); } cx.notify(); })?; anyhow::Ok(()) }) .detach_and_log_err(cx); } fn index_project(&self, cx: &mut ViewContext) -> anyhow::Result<()> { let Some(project) = self.project.upgrade() else { return Err(anyhow!("project was dropped!")); }; let semantic_permissioned = self.semantic_permissioned(cx); if let Some(semantic_index) = SemanticIndex::global(cx) { cx.spawn(|_, mut cx| async move { // This has to be updated to accomodate for semantic_permissions if semantic_permissioned.await.unwrap_or(false) { semantic_index .update(&mut cx, |index, cx| index.index_project(project, cx))? .await } else { Err(anyhow!("project is not permissioned for semantic indexing")) } }) .detach_and_log_err(cx); } anyhow::Ok(()) } fn retrieve_context_status(&self, cx: &mut ViewContext) -> Option { let Some(project) = self.project.upgrade() else { return None; }; let semantic_index = SemanticIndex::global(cx)?; let status = semantic_index.update(cx, |index, _| index.status(&project)); match status { SemanticIndexStatus::NotAuthenticated {} => Some( div() .id("error") .tooltip(|cx| Tooltip::text("Not Authenticated. Please ensure you have a valid 'OPENAI_API_KEY' in your environment variables.", cx)) .child(IconElement::new(Icon::XCircle)) .into_any_element() ), SemanticIndexStatus::NotIndexed {} => Some( div() .id("error") .tooltip(|cx| Tooltip::text("Not Indexed", cx)) .child(IconElement::new(Icon::XCircle)) .into_any_element() ), SemanticIndexStatus::Indexing { remaining_files, rate_limit_expiry, } => { let mut status_text = if remaining_files == 0 { "Indexing...".to_string() } else { format!("Remaining files to index: {remaining_files}") }; if let Some(rate_limit_expiry) = rate_limit_expiry { let remaining_seconds = rate_limit_expiry.duration_since(Instant::now()); if remaining_seconds > Duration::from_secs(0) && remaining_files > 0 { write!( status_text, " (rate limit expires in {}s)", remaining_seconds.as_secs() ) .unwrap(); } } let status_text = SharedString::from(status_text); Some( div() .id("update") .tooltip(move |cx| Tooltip::text(status_text.clone(), cx)) .child(IconElement::new(Icon::Update).color(Color::Info)) .into_any_element() ) } SemanticIndexStatus::Indexed {} => Some( div() .id("check") .tooltip(|cx| Tooltip::text("Index up to date", cx)) .child(IconElement::new(Icon::Check).color(Color::Success)) .into_any_element() ), } } fn toggle_include_conversation( &mut self, _: &ToggleIncludeConversation, cx: &mut ViewContext, ) { self.include_conversation = !self.include_conversation; cx.emit(InlineAssistantEvent::IncludeConversationToggled { include_conversation: self.include_conversation, }); cx.notify(); } fn move_up(&mut self, _: &MoveUp, cx: &mut ViewContext) { if let Some(ix) = self.prompt_history_ix { if ix > 0 { self.prompt_history_ix = Some(ix - 1); let prompt = self.prompt_history[ix - 1].clone(); self.set_prompt(&prompt, cx); } } else if !self.prompt_history.is_empty() { self.prompt_history_ix = Some(self.prompt_history.len() - 1); let prompt = self.prompt_history[self.prompt_history.len() - 1].clone(); self.set_prompt(&prompt, cx); } } fn move_down(&mut self, _: &MoveDown, cx: &mut ViewContext) { if let Some(ix) = self.prompt_history_ix { if ix < self.prompt_history.len() - 1 { self.prompt_history_ix = Some(ix + 1); let prompt = self.prompt_history[ix + 1].clone(); self.set_prompt(&prompt, cx); } else { self.prompt_history_ix = None; let pending_prompt = self.pending_prompt.clone(); self.set_prompt(&pending_prompt, cx); } } } fn set_prompt(&mut self, prompt: &str, cx: &mut ViewContext) { self.prompt_editor.update(cx, |editor, cx| { editor.buffer().update(cx, |buffer, cx| { let len = buffer.len(cx); buffer.edit([(0..len, prompt)], None, cx); }); }); } fn render_prompt_editor(&self, cx: &mut ViewContext) -> impl IntoElement { let settings = ThemeSettings::get_global(cx); let text_style = TextStyle { color: if self.prompt_editor.read(cx).read_only() { cx.theme().colors().text_disabled } else { cx.theme().colors().text }, font_family: settings.ui_font.family.clone(), font_features: settings.ui_font.features, font_size: rems(0.875).into(), font_weight: FontWeight::NORMAL, font_style: FontStyle::Normal, line_height: relative(1.).into(), background_color: None, underline: None, white_space: WhiteSpace::Normal, }; EditorElement::new( &self.prompt_editor, EditorStyle { background: cx.theme().colors().editor_background, local_player: cx.theme().players().local(), text: text_style, ..Default::default() }, ) } } // This wouldn't need to exist if we could pass parameters when rendering child views. #[derive(Copy, Clone, Default)] struct BlockMeasurements { anchor_x: Pixels, gutter_width: Pixels, } struct PendingInlineAssist { editor: WeakView, inline_assistant: Option<(BlockId, View)>, codegen: Model, _subscriptions: Vec, project: WeakModel, } fn merge_ranges(ranges: &mut Vec>, buffer: &MultiBufferSnapshot) { ranges.sort_unstable_by(|a, b| { a.start .cmp(&b.start, buffer) .then_with(|| b.end.cmp(&a.end, buffer)) }); let mut ix = 0; while ix + 1 < ranges.len() { let b = ranges[ix + 1].clone(); let a = &mut ranges[ix]; if a.end.cmp(&b.start, buffer).is_gt() { if a.end.cmp(&b.end, buffer).is_lt() { a.end = b.end; } ranges.remove(ix + 1); } else { ix += 1; } } } #[cfg(test)] mod tests { use super::*; use crate::MessageId; use ai::test::FakeCompletionProvider; use gpui::AppContext; #[gpui::test] fn test_inserting_and_removing_messages(cx: &mut AppContext) { let settings_store = SettingsStore::test(cx); cx.set_global(settings_store); init(cx); let registry = Arc::new(LanguageRegistry::test()); let completion_provider = Arc::new(FakeCompletionProvider::new()); let conversation = cx.build_model(|cx| Conversation::new(registry, cx, completion_provider)); let buffer = conversation.read(cx).buffer.clone(); let message_1 = conversation.read(cx).message_anchors[0].clone(); assert_eq!( messages(&conversation, cx), vec![(message_1.id, Role::User, 0..0)] ); let message_2 = conversation.update(cx, |conversation, cx| { conversation .insert_message_after(message_1.id, Role::Assistant, MessageStatus::Done, cx) .unwrap() }); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..1), (message_2.id, Role::Assistant, 1..1) ] ); buffer.update(cx, |buffer, cx| { buffer.edit([(0..0, "1"), (1..1, "2")], None, cx) }); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..2), (message_2.id, Role::Assistant, 2..3) ] ); let message_3 = conversation.update(cx, |conversation, cx| { conversation .insert_message_after(message_2.id, Role::User, MessageStatus::Done, cx) .unwrap() }); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..2), (message_2.id, Role::Assistant, 2..4), (message_3.id, Role::User, 4..4) ] ); let message_4 = conversation.update(cx, |conversation, cx| { conversation .insert_message_after(message_2.id, Role::User, MessageStatus::Done, cx) .unwrap() }); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..2), (message_2.id, Role::Assistant, 2..4), (message_4.id, Role::User, 4..5), (message_3.id, Role::User, 5..5), ] ); buffer.update(cx, |buffer, cx| { buffer.edit([(4..4, "C"), (5..5, "D")], None, cx) }); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..2), (message_2.id, Role::Assistant, 2..4), (message_4.id, Role::User, 4..6), (message_3.id, Role::User, 6..7), ] ); // Deleting across message boundaries merges the messages. buffer.update(cx, |buffer, cx| buffer.edit([(1..4, "")], None, cx)); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..3), (message_3.id, Role::User, 3..4), ] ); // Undoing the deletion should also undo the merge. buffer.update(cx, |buffer, cx| buffer.undo(cx)); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..2), (message_2.id, Role::Assistant, 2..4), (message_4.id, Role::User, 4..6), (message_3.id, Role::User, 6..7), ] ); // Redoing the deletion should also redo the merge. buffer.update(cx, |buffer, cx| buffer.redo(cx)); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..3), (message_3.id, Role::User, 3..4), ] ); // Ensure we can still insert after a merged message. let message_5 = conversation.update(cx, |conversation, cx| { conversation .insert_message_after(message_1.id, Role::System, MessageStatus::Done, cx) .unwrap() }); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..3), (message_5.id, Role::System, 3..4), (message_3.id, Role::User, 4..5) ] ); } #[gpui::test] fn test_message_splitting(cx: &mut AppContext) { let settings_store = SettingsStore::test(cx); cx.set_global(settings_store); init(cx); let registry = Arc::new(LanguageRegistry::test()); let completion_provider = Arc::new(FakeCompletionProvider::new()); let conversation = cx.build_model(|cx| Conversation::new(registry, cx, completion_provider)); let buffer = conversation.read(cx).buffer.clone(); let message_1 = conversation.read(cx).message_anchors[0].clone(); assert_eq!( messages(&conversation, cx), vec![(message_1.id, Role::User, 0..0)] ); buffer.update(cx, |buffer, cx| { buffer.edit([(0..0, "aaa\nbbb\nccc\nddd\n")], None, cx) }); let (_, message_2) = conversation.update(cx, |conversation, cx| conversation.split_message(3..3, cx)); let message_2 = message_2.unwrap(); // We recycle newlines in the middle of a split message assert_eq!(buffer.read(cx).text(), "aaa\nbbb\nccc\nddd\n"); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..4), (message_2.id, Role::User, 4..16), ] ); let (_, message_3) = conversation.update(cx, |conversation, cx| conversation.split_message(3..3, cx)); let message_3 = message_3.unwrap(); // We don't recycle newlines at the end of a split message assert_eq!(buffer.read(cx).text(), "aaa\n\nbbb\nccc\nddd\n"); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..4), (message_3.id, Role::User, 4..5), (message_2.id, Role::User, 5..17), ] ); let (_, message_4) = conversation.update(cx, |conversation, cx| conversation.split_message(9..9, cx)); let message_4 = message_4.unwrap(); assert_eq!(buffer.read(cx).text(), "aaa\n\nbbb\nccc\nddd\n"); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..4), (message_3.id, Role::User, 4..5), (message_2.id, Role::User, 5..9), (message_4.id, Role::User, 9..17), ] ); let (_, message_5) = conversation.update(cx, |conversation, cx| conversation.split_message(9..9, cx)); let message_5 = message_5.unwrap(); assert_eq!(buffer.read(cx).text(), "aaa\n\nbbb\n\nccc\nddd\n"); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..4), (message_3.id, Role::User, 4..5), (message_2.id, Role::User, 5..9), (message_4.id, Role::User, 9..10), (message_5.id, Role::User, 10..18), ] ); let (message_6, message_7) = conversation.update(cx, |conversation, cx| { conversation.split_message(14..16, cx) }); let message_6 = message_6.unwrap(); let message_7 = message_7.unwrap(); assert_eq!(buffer.read(cx).text(), "aaa\n\nbbb\n\nccc\ndd\nd\n"); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..4), (message_3.id, Role::User, 4..5), (message_2.id, Role::User, 5..9), (message_4.id, Role::User, 9..10), (message_5.id, Role::User, 10..14), (message_6.id, Role::User, 14..17), (message_7.id, Role::User, 17..19), ] ); } #[gpui::test] fn test_messages_for_offsets(cx: &mut AppContext) { let settings_store = SettingsStore::test(cx); cx.set_global(settings_store); init(cx); let registry = Arc::new(LanguageRegistry::test()); let completion_provider = Arc::new(FakeCompletionProvider::new()); let conversation = cx.build_model(|cx| Conversation::new(registry, cx, completion_provider)); let buffer = conversation.read(cx).buffer.clone(); let message_1 = conversation.read(cx).message_anchors[0].clone(); assert_eq!( messages(&conversation, cx), vec![(message_1.id, Role::User, 0..0)] ); buffer.update(cx, |buffer, cx| buffer.edit([(0..0, "aaa")], None, cx)); let message_2 = conversation .update(cx, |conversation, cx| { conversation.insert_message_after(message_1.id, Role::User, MessageStatus::Done, cx) }) .unwrap(); buffer.update(cx, |buffer, cx| buffer.edit([(4..4, "bbb")], None, cx)); let message_3 = conversation .update(cx, |conversation, cx| { conversation.insert_message_after(message_2.id, Role::User, MessageStatus::Done, cx) }) .unwrap(); buffer.update(cx, |buffer, cx| buffer.edit([(8..8, "ccc")], None, cx)); assert_eq!(buffer.read(cx).text(), "aaa\nbbb\nccc"); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..4), (message_2.id, Role::User, 4..8), (message_3.id, Role::User, 8..11) ] ); assert_eq!( message_ids_for_offsets(&conversation, &[0, 4, 9], cx), [message_1.id, message_2.id, message_3.id] ); assert_eq!( message_ids_for_offsets(&conversation, &[0, 1, 11], cx), [message_1.id, message_3.id] ); let message_4 = conversation .update(cx, |conversation, cx| { conversation.insert_message_after(message_3.id, Role::User, MessageStatus::Done, cx) }) .unwrap(); assert_eq!(buffer.read(cx).text(), "aaa\nbbb\nccc\n"); assert_eq!( messages(&conversation, cx), vec![ (message_1.id, Role::User, 0..4), (message_2.id, Role::User, 4..8), (message_3.id, Role::User, 8..12), (message_4.id, Role::User, 12..12) ] ); assert_eq!( message_ids_for_offsets(&conversation, &[0, 4, 8, 12], cx), [message_1.id, message_2.id, message_3.id, message_4.id] ); fn message_ids_for_offsets( conversation: &Model, offsets: &[usize], cx: &AppContext, ) -> Vec { conversation .read(cx) .messages_for_offsets(offsets.iter().copied(), cx) .into_iter() .map(|message| message.id) .collect() } } #[gpui::test] fn test_serialization(cx: &mut AppContext) { let settings_store = SettingsStore::test(cx); cx.set_global(settings_store); init(cx); let registry = Arc::new(LanguageRegistry::test()); let completion_provider = Arc::new(FakeCompletionProvider::new()); let conversation = cx.build_model(|cx| Conversation::new(registry.clone(), cx, completion_provider)); let buffer = conversation.read(cx).buffer.clone(); let message_0 = conversation.read(cx).message_anchors[0].id; let message_1 = conversation.update(cx, |conversation, cx| { conversation .insert_message_after(message_0, Role::Assistant, MessageStatus::Done, cx) .unwrap() }); let message_2 = conversation.update(cx, |conversation, cx| { conversation .insert_message_after(message_1.id, Role::System, MessageStatus::Done, cx) .unwrap() }); buffer.update(cx, |buffer, cx| { buffer.edit([(0..0, "a"), (1..1, "b\nc")], None, cx); buffer.finalize_last_transaction(); }); let _message_3 = conversation.update(cx, |conversation, cx| { conversation .insert_message_after(message_2.id, Role::System, MessageStatus::Done, cx) .unwrap() }); buffer.update(cx, |buffer, cx| buffer.undo(cx)); assert_eq!(buffer.read(cx).text(), "a\nb\nc\n"); assert_eq!( messages(&conversation, cx), [ (message_0, Role::User, 0..2), (message_1.id, Role::Assistant, 2..6), (message_2.id, Role::System, 6..6), ] ); let deserialized_conversation = cx.build_model(|cx| { Conversation::deserialize( conversation.read(cx).serialize(cx), Default::default(), registry.clone(), cx, ) }); let deserialized_buffer = deserialized_conversation.read(cx).buffer.clone(); assert_eq!(deserialized_buffer.read(cx).text(), "a\nb\nc\n"); assert_eq!( messages(&deserialized_conversation, cx), [ (message_0, Role::User, 0..2), (message_1.id, Role::Assistant, 2..6), (message_2.id, Role::System, 6..6), ] ); } fn messages( conversation: &Model, cx: &AppContext, ) -> Vec<(MessageId, Role, Range)> { conversation .read(cx) .messages(cx) .map(|message| (message.id, message.role, message.offset_range)) .collect() } } fn report_assistant_event( workspace: WeakView, conversation_id: Option, assistant_kind: AssistantKind, cx: &AppContext, ) { let Some(workspace) = workspace.upgrade() else { return; }; let client = workspace.read(cx).project().read(cx).client(); let telemetry = client.telemetry(); let model = AssistantSettings::get_global(cx) .default_open_ai_model .clone(); let telemetry_settings = TelemetrySettings::get_global(cx).clone(); telemetry.report_assistant_event( telemetry_settings, conversation_id, assistant_kind, model.full_name(), ) }