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