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