1mod completion_diff_element;
   2mod init;
   3mod input_excerpt;
   4mod license_detection;
   5mod onboarding_modal;
   6mod onboarding_telemetry;
   7mod rate_completion_modal;
   8
   9pub(crate) use completion_diff_element::*;
  10use db::kvp::{Dismissable, KEY_VALUE_STORE};
  11use edit_prediction::DataCollectionState;
  12pub use init::*;
  13use license_detection::LICENSE_FILES_TO_CHECK;
  14pub use license_detection::is_license_eligible_for_data_collection;
  15pub use rate_completion_modal::*;
  16
  17use anyhow::{Context as _, Result, anyhow};
  18use arrayvec::ArrayVec;
  19use client::{Client, EditPredictionUsage, UserStore};
  20use cloud_llm_client::{
  21    AcceptEditPredictionBody, EXPIRED_LLM_TOKEN_HEADER_NAME, MINIMUM_REQUIRED_VERSION_HEADER_NAME,
  22    PredictEditsBody, PredictEditsGitInfo, PredictEditsResponse, ZED_VERSION_HEADER_NAME,
  23};
  24use collections::{HashMap, HashSet, VecDeque};
  25use futures::AsyncReadExt;
  26use gpui::{
  27    App, AppContext as _, AsyncApp, Context, Entity, EntityId, Global, SemanticVersion,
  28    Subscription, Task, WeakEntity, actions,
  29};
  30use http_client::{AsyncBody, HttpClient, Method, Request, Response};
  31use input_excerpt::excerpt_for_cursor_position;
  32use language::{
  33    Anchor, Buffer, BufferSnapshot, EditPreview, OffsetRangeExt, ToOffset, ToPoint, text_diff,
  34};
  35use language_model::{LlmApiToken, RefreshLlmTokenListener};
  36use postage::watch;
  37use project::{Project, ProjectPath};
  38use release_channel::AppVersion;
  39use settings::WorktreeId;
  40use std::str::FromStr;
  41use std::{
  42    borrow::Cow,
  43    cmp,
  44    fmt::Write,
  45    future::Future,
  46    mem,
  47    ops::Range,
  48    path::Path,
  49    rc::Rc,
  50    sync::Arc,
  51    time::{Duration, Instant},
  52};
  53use telemetry_events::EditPredictionRating;
  54use thiserror::Error;
  55use util::ResultExt;
  56use uuid::Uuid;
  57use workspace::Workspace;
  58use workspace::notifications::{ErrorMessagePrompt, NotificationId};
  59use worktree::Worktree;
  60
  61const CURSOR_MARKER: &'static str = "<|user_cursor_is_here|>";
  62const START_OF_FILE_MARKER: &'static str = "<|start_of_file|>";
  63const EDITABLE_REGION_START_MARKER: &'static str = "<|editable_region_start|>";
  64const EDITABLE_REGION_END_MARKER: &'static str = "<|editable_region_end|>";
  65const BUFFER_CHANGE_GROUPING_INTERVAL: Duration = Duration::from_secs(1);
  66const ZED_PREDICT_DATA_COLLECTION_CHOICE: &str = "zed_predict_data_collection_choice";
  67
  68const MAX_CONTEXT_TOKENS: usize = 150;
  69const MAX_REWRITE_TOKENS: usize = 350;
  70const MAX_EVENT_TOKENS: usize = 500;
  71
  72/// Maximum number of events to track.
  73const MAX_EVENT_COUNT: usize = 16;
  74
  75actions!(
  76    edit_prediction,
  77    [
  78        /// Clears the edit prediction history.
  79        ClearHistory
  80    ]
  81);
  82
  83#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
  84pub struct EditPredictionId(Uuid);
  85
  86impl From<EditPredictionId> for gpui::ElementId {
  87    fn from(value: EditPredictionId) -> Self {
  88        gpui::ElementId::Uuid(value.0)
  89    }
  90}
  91
  92impl std::fmt::Display for EditPredictionId {
  93    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  94        write!(f, "{}", self.0)
  95    }
  96}
  97
  98struct ZedPredictUpsell;
  99
 100impl Dismissable for ZedPredictUpsell {
 101    const KEY: &'static str = "dismissed-edit-predict-upsell";
 102
 103    fn dismissed() -> bool {
 104        // To make this backwards compatible with older versions of Zed, we
 105        // check if the user has seen the previous Edit Prediction Onboarding
 106        // before, by checking the data collection choice which was written to
 107        // the database once the user clicked on "Accept and Enable"
 108        if KEY_VALUE_STORE
 109            .read_kvp(ZED_PREDICT_DATA_COLLECTION_CHOICE)
 110            .log_err()
 111            .map_or(false, |s| s.is_some())
 112        {
 113            return true;
 114        }
 115
 116        KEY_VALUE_STORE
 117            .read_kvp(Self::KEY)
 118            .log_err()
 119            .map_or(false, |s| s.is_some())
 120    }
 121}
 122
 123pub fn should_show_upsell_modal(user_store: &Entity<UserStore>, cx: &App) -> bool {
 124    if user_store.read(cx).has_accepted_terms_of_service() {
 125        !ZedPredictUpsell::dismissed()
 126    } else {
 127        true
 128    }
 129}
 130
 131#[derive(Clone)]
 132struct ZetaGlobal(Entity<Zeta>);
 133
 134impl Global for ZetaGlobal {}
 135
 136#[derive(Clone)]
 137pub struct EditPrediction {
 138    id: EditPredictionId,
 139    path: Arc<Path>,
 140    excerpt_range: Range<usize>,
 141    cursor_offset: usize,
 142    edits: Arc<[(Range<Anchor>, String)]>,
 143    snapshot: BufferSnapshot,
 144    edit_preview: EditPreview,
 145    input_outline: Arc<str>,
 146    input_events: Arc<str>,
 147    input_excerpt: Arc<str>,
 148    output_excerpt: Arc<str>,
 149    buffer_snapshotted_at: Instant,
 150    response_received_at: Instant,
 151}
 152
 153impl EditPrediction {
 154    fn latency(&self) -> Duration {
 155        self.response_received_at
 156            .duration_since(self.buffer_snapshotted_at)
 157    }
 158
 159    fn interpolate(&self, new_snapshot: &BufferSnapshot) -> Option<Vec<(Range<Anchor>, String)>> {
 160        interpolate(&self.snapshot, new_snapshot, self.edits.clone())
 161    }
 162}
 163
 164fn interpolate(
 165    old_snapshot: &BufferSnapshot,
 166    new_snapshot: &BufferSnapshot,
 167    current_edits: Arc<[(Range<Anchor>, String)]>,
 168) -> Option<Vec<(Range<Anchor>, String)>> {
 169    let mut edits = Vec::new();
 170
 171    let mut model_edits = current_edits.into_iter().peekable();
 172    for user_edit in new_snapshot.edits_since::<usize>(&old_snapshot.version) {
 173        while let Some((model_old_range, _)) = model_edits.peek() {
 174            let model_old_range = model_old_range.to_offset(old_snapshot);
 175            if model_old_range.end < user_edit.old.start {
 176                let (model_old_range, model_new_text) = model_edits.next().unwrap();
 177                edits.push((model_old_range.clone(), model_new_text.clone()));
 178            } else {
 179                break;
 180            }
 181        }
 182
 183        if let Some((model_old_range, model_new_text)) = model_edits.peek() {
 184            let model_old_offset_range = model_old_range.to_offset(old_snapshot);
 185            if user_edit.old == model_old_offset_range {
 186                let user_new_text = new_snapshot
 187                    .text_for_range(user_edit.new.clone())
 188                    .collect::<String>();
 189
 190                if let Some(model_suffix) = model_new_text.strip_prefix(&user_new_text) {
 191                    if !model_suffix.is_empty() {
 192                        let anchor = old_snapshot.anchor_after(user_edit.old.end);
 193                        edits.push((anchor..anchor, model_suffix.to_string()));
 194                    }
 195
 196                    model_edits.next();
 197                    continue;
 198                }
 199            }
 200        }
 201
 202        return None;
 203    }
 204
 205    edits.extend(model_edits.cloned());
 206
 207    if edits.is_empty() { None } else { Some(edits) }
 208}
 209
 210impl std::fmt::Debug for EditPrediction {
 211    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 212        f.debug_struct("EditPrediction")
 213            .field("id", &self.id)
 214            .field("path", &self.path)
 215            .field("edits", &self.edits)
 216            .finish_non_exhaustive()
 217    }
 218}
 219
 220pub struct Zeta {
 221    workspace: Option<WeakEntity<Workspace>>,
 222    client: Arc<Client>,
 223    events: VecDeque<Event>,
 224    registered_buffers: HashMap<gpui::EntityId, RegisteredBuffer>,
 225    shown_completions: VecDeque<EditPrediction>,
 226    rated_completions: HashSet<EditPredictionId>,
 227    data_collection_choice: Entity<DataCollectionChoice>,
 228    llm_token: LlmApiToken,
 229    _llm_token_subscription: Subscription,
 230    /// Whether an update to a newer version of Zed is required to continue using Zeta.
 231    update_required: bool,
 232    user_store: Entity<UserStore>,
 233    license_detection_watchers: HashMap<WorktreeId, Rc<LicenseDetectionWatcher>>,
 234}
 235
 236impl Zeta {
 237    pub fn global(cx: &mut App) -> Option<Entity<Self>> {
 238        cx.try_global::<ZetaGlobal>().map(|global| global.0.clone())
 239    }
 240
 241    pub fn register(
 242        workspace: Option<WeakEntity<Workspace>>,
 243        worktree: Option<Entity<Worktree>>,
 244        client: Arc<Client>,
 245        user_store: Entity<UserStore>,
 246        cx: &mut App,
 247    ) -> Entity<Self> {
 248        let this = Self::global(cx).unwrap_or_else(|| {
 249            let entity = cx.new(|cx| Self::new(workspace, client, user_store, cx));
 250            cx.set_global(ZetaGlobal(entity.clone()));
 251            entity
 252        });
 253
 254        this.update(cx, move |this, cx| {
 255            if let Some(worktree) = worktree {
 256                worktree.update(cx, |worktree, cx| {
 257                    this.license_detection_watchers
 258                        .entry(worktree.id())
 259                        .or_insert_with(|| Rc::new(LicenseDetectionWatcher::new(worktree, cx)));
 260                });
 261            }
 262        });
 263
 264        this
 265    }
 266
 267    pub fn clear_history(&mut self) {
 268        self.events.clear();
 269    }
 270
 271    pub fn usage(&self, cx: &App) -> Option<EditPredictionUsage> {
 272        self.user_store.read(cx).edit_prediction_usage()
 273    }
 274
 275    fn new(
 276        workspace: Option<WeakEntity<Workspace>>,
 277        client: Arc<Client>,
 278        user_store: Entity<UserStore>,
 279        cx: &mut Context<Self>,
 280    ) -> Self {
 281        let refresh_llm_token_listener = RefreshLlmTokenListener::global(cx);
 282
 283        let data_collection_choice = Self::load_data_collection_choices();
 284        let data_collection_choice = cx.new(|_| data_collection_choice);
 285
 286        Self {
 287            workspace,
 288            client,
 289            events: VecDeque::new(),
 290            shown_completions: VecDeque::new(),
 291            rated_completions: HashSet::default(),
 292            registered_buffers: HashMap::default(),
 293            data_collection_choice,
 294            llm_token: LlmApiToken::default(),
 295            _llm_token_subscription: cx.subscribe(
 296                &refresh_llm_token_listener,
 297                |this, _listener, _event, cx| {
 298                    let client = this.client.clone();
 299                    let llm_token = this.llm_token.clone();
 300                    cx.spawn(async move |_this, _cx| {
 301                        llm_token.refresh(&client).await?;
 302                        anyhow::Ok(())
 303                    })
 304                    .detach_and_log_err(cx);
 305                },
 306            ),
 307            update_required: false,
 308            license_detection_watchers: HashMap::default(),
 309            user_store,
 310        }
 311    }
 312
 313    fn push_event(&mut self, event: Event) {
 314        if let Some(Event::BufferChange {
 315            new_snapshot: last_new_snapshot,
 316            timestamp: last_timestamp,
 317            ..
 318        }) = self.events.back_mut()
 319        {
 320            // Coalesce edits for the same buffer when they happen one after the other.
 321            let Event::BufferChange {
 322                old_snapshot,
 323                new_snapshot,
 324                timestamp,
 325            } = &event;
 326
 327            if timestamp.duration_since(*last_timestamp) <= BUFFER_CHANGE_GROUPING_INTERVAL
 328                && old_snapshot.remote_id() == last_new_snapshot.remote_id()
 329                && old_snapshot.version == last_new_snapshot.version
 330            {
 331                *last_new_snapshot = new_snapshot.clone();
 332                *last_timestamp = *timestamp;
 333                return;
 334            }
 335        }
 336
 337        self.events.push_back(event);
 338        if self.events.len() >= MAX_EVENT_COUNT {
 339            // These are halved instead of popping to improve prompt caching.
 340            self.events.drain(..MAX_EVENT_COUNT / 2);
 341        }
 342    }
 343
 344    pub fn register_buffer(&mut self, buffer: &Entity<Buffer>, cx: &mut Context<Self>) {
 345        let buffer_id = buffer.entity_id();
 346        let weak_buffer = buffer.downgrade();
 347
 348        if let std::collections::hash_map::Entry::Vacant(entry) =
 349            self.registered_buffers.entry(buffer_id)
 350        {
 351            let snapshot = buffer.read(cx).snapshot();
 352
 353            entry.insert(RegisteredBuffer {
 354                snapshot,
 355                _subscriptions: [
 356                    cx.subscribe(buffer, move |this, buffer, event, cx| {
 357                        this.handle_buffer_event(buffer, event, cx);
 358                    }),
 359                    cx.observe_release(buffer, move |this, _buffer, _cx| {
 360                        this.registered_buffers.remove(&weak_buffer.entity_id());
 361                    }),
 362                ],
 363            });
 364        };
 365    }
 366
 367    fn handle_buffer_event(
 368        &mut self,
 369        buffer: Entity<Buffer>,
 370        event: &language::BufferEvent,
 371        cx: &mut Context<Self>,
 372    ) {
 373        if let language::BufferEvent::Edited = event {
 374            self.report_changes_for_buffer(&buffer, cx);
 375        }
 376    }
 377
 378    fn request_completion_impl<F, R>(
 379        &mut self,
 380        workspace: Option<Entity<Workspace>>,
 381        project: Option<&Entity<Project>>,
 382        buffer: &Entity<Buffer>,
 383        cursor: language::Anchor,
 384        can_collect_data: bool,
 385        cx: &mut Context<Self>,
 386        perform_predict_edits: F,
 387    ) -> Task<Result<Option<EditPrediction>>>
 388    where
 389        F: FnOnce(PerformPredictEditsParams) -> R + 'static,
 390        R: Future<Output = Result<(PredictEditsResponse, Option<EditPredictionUsage>)>>
 391            + Send
 392            + 'static,
 393    {
 394        let buffer = buffer.clone();
 395        let buffer_snapshotted_at = Instant::now();
 396        let snapshot = self.report_changes_for_buffer(&buffer, cx);
 397        let zeta = cx.entity();
 398        let events = self.events.clone();
 399        let client = self.client.clone();
 400        let llm_token = self.llm_token.clone();
 401        let app_version = AppVersion::global(cx);
 402
 403        let git_info = if let (true, Some(project), Some(file)) =
 404            (can_collect_data, project, snapshot.file())
 405        {
 406            git_info_for_file(project, &ProjectPath::from_file(file.as_ref(), cx), cx)
 407        } else {
 408            None
 409        };
 410
 411        let full_path: Arc<Path> = snapshot
 412            .file()
 413            .map(|f| Arc::from(f.full_path(cx).as_path()))
 414            .unwrap_or_else(|| Arc::from(Path::new("untitled")));
 415        let full_path_str = full_path.to_string_lossy().to_string();
 416        let cursor_point = cursor.to_point(&snapshot);
 417        let cursor_offset = cursor_point.to_offset(&snapshot);
 418        let make_events_prompt = move || prompt_for_events(&events, MAX_EVENT_TOKENS);
 419        let gather_task = gather_context(
 420            project,
 421            full_path_str,
 422            &snapshot,
 423            cursor_point,
 424            make_events_prompt,
 425            can_collect_data,
 426            git_info,
 427            cx,
 428        );
 429
 430        cx.spawn(async move |this, cx| {
 431            let GatherContextOutput {
 432                body,
 433                editable_range,
 434            } = gather_task.await?;
 435            let done_gathering_context_at = Instant::now();
 436
 437            log::debug!(
 438                "Events:\n{}\nExcerpt:\n{:?}",
 439                body.input_events,
 440                body.input_excerpt
 441            );
 442
 443            let input_outline = body.outline.clone().unwrap_or_default();
 444            let input_events = body.input_events.clone();
 445            let input_excerpt = body.input_excerpt.clone();
 446
 447            let response = perform_predict_edits(PerformPredictEditsParams {
 448                client,
 449                llm_token,
 450                app_version,
 451                body,
 452            })
 453            .await;
 454            let (response, usage) = match response {
 455                Ok(response) => response,
 456                Err(err) => {
 457                    if err.is::<ZedUpdateRequiredError>() {
 458                        cx.update(|cx| {
 459                            zeta.update(cx, |zeta, _cx| {
 460                                zeta.update_required = true;
 461                            });
 462
 463                            if let Some(workspace) = workspace {
 464                                workspace.update(cx, |workspace, cx| {
 465                                    workspace.show_notification(
 466                                        NotificationId::unique::<ZedUpdateRequiredError>(),
 467                                        cx,
 468                                        |cx| {
 469                                            cx.new(|cx| {
 470                                                ErrorMessagePrompt::new(err.to_string(), cx)
 471                                                    .with_link_button(
 472                                                        "Update Zed",
 473                                                        "https://zed.dev/releases",
 474                                                    )
 475                                            })
 476                                        },
 477                                    );
 478                                });
 479                            }
 480                        })
 481                        .ok();
 482                    }
 483
 484                    return Err(err);
 485                }
 486            };
 487
 488            let received_response_at = Instant::now();
 489            log::debug!("completion response: {}", &response.output_excerpt);
 490
 491            if let Some(usage) = usage {
 492                this.update(cx, |this, cx| {
 493                    this.user_store.update(cx, |user_store, cx| {
 494                        user_store.update_edit_prediction_usage(usage, cx);
 495                    });
 496                })
 497                .ok();
 498            }
 499
 500            let edit_prediction = Self::process_completion_response(
 501                response,
 502                buffer,
 503                &snapshot,
 504                editable_range,
 505                cursor_offset,
 506                full_path,
 507                input_outline,
 508                input_events,
 509                input_excerpt,
 510                buffer_snapshotted_at,
 511                &cx,
 512            )
 513            .await;
 514
 515            let finished_at = Instant::now();
 516
 517            // record latency for ~1% of requests
 518            if rand::random::<u8>() <= 2 {
 519                telemetry::event!(
 520                    "Edit Prediction Request",
 521                    context_latency = done_gathering_context_at
 522                        .duration_since(buffer_snapshotted_at)
 523                        .as_millis(),
 524                    request_latency = received_response_at
 525                        .duration_since(done_gathering_context_at)
 526                        .as_millis(),
 527                    process_latency = finished_at.duration_since(received_response_at).as_millis()
 528                );
 529            }
 530
 531            edit_prediction
 532        })
 533    }
 534
 535    // Generates several example completions of various states to fill the Zeta completion modal
 536    #[cfg(any(test, feature = "test-support"))]
 537    pub fn fill_with_fake_completions(&mut self, cx: &mut Context<Self>) -> Task<()> {
 538        use language::Point;
 539
 540        let test_buffer_text = indoc::indoc! {r#"a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
 541            And maybe a short line
 542
 543            Then a few lines
 544
 545            and then another
 546            "#};
 547
 548        let project = None;
 549        let buffer = cx.new(|cx| Buffer::local(test_buffer_text, cx));
 550        let position = buffer.read(cx).anchor_before(Point::new(1, 0));
 551
 552        let completion_tasks = vec![
 553            self.fake_completion(
 554                project,
 555                &buffer,
 556                position,
 557                PredictEditsResponse {
 558                    request_id: Uuid::parse_str("e7861db5-0cea-4761-b1c5-ad083ac53a80").unwrap(),
 559                    output_excerpt: format!("{EDITABLE_REGION_START_MARKER}
 560a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
 561[here's an edit]
 562And maybe a short line
 563Then a few lines
 564and then another
 565{EDITABLE_REGION_END_MARKER}
 566                        ", ),
 567                },
 568                cx,
 569            ),
 570            self.fake_completion(
 571                project,
 572                &buffer,
 573                position,
 574                PredictEditsResponse {
 575                    request_id: Uuid::parse_str("077c556a-2c49-44e2-bbc6-dafc09032a5e").unwrap(),
 576                    output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
 577a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
 578And maybe a short line
 579[and another edit]
 580Then a few lines
 581and then another
 582{EDITABLE_REGION_END_MARKER}
 583                        "#),
 584                },
 585                cx,
 586            ),
 587            self.fake_completion(
 588                project,
 589                &buffer,
 590                position,
 591                PredictEditsResponse {
 592                    request_id: Uuid::parse_str("df8c7b23-3d1d-4f99-a306-1f6264a41277").unwrap(),
 593                    output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
 594a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
 595And maybe a short line
 596
 597Then a few lines
 598
 599and then another
 600{EDITABLE_REGION_END_MARKER}
 601                        "#),
 602                },
 603                cx,
 604            ),
 605            self.fake_completion(
 606                project,
 607                &buffer,
 608                position,
 609                PredictEditsResponse {
 610                    request_id: Uuid::parse_str("c743958d-e4d8-44a8-aa5b-eb1e305c5f5c").unwrap(),
 611                    output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
 612a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
 613And maybe a short line
 614
 615Then a few lines
 616
 617and then another
 618{EDITABLE_REGION_END_MARKER}
 619                        "#),
 620                },
 621                cx,
 622            ),
 623            self.fake_completion(
 624                project,
 625                &buffer,
 626                position,
 627                PredictEditsResponse {
 628                    request_id: Uuid::parse_str("ff5cd7ab-ad06-4808-986e-d3391e7b8355").unwrap(),
 629                    output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
 630a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
 631And maybe a short line
 632Then a few lines
 633[a third completion]
 634and then another
 635{EDITABLE_REGION_END_MARKER}
 636                        "#),
 637                },
 638                cx,
 639            ),
 640            self.fake_completion(
 641                project,
 642                &buffer,
 643                position,
 644                PredictEditsResponse {
 645                    request_id: Uuid::parse_str("83cafa55-cdba-4b27-8474-1865ea06be94").unwrap(),
 646                    output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
 647a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
 648And maybe a short line
 649and then another
 650[fourth completion example]
 651{EDITABLE_REGION_END_MARKER}
 652                        "#),
 653                },
 654                cx,
 655            ),
 656            self.fake_completion(
 657                project,
 658                &buffer,
 659                position,
 660                PredictEditsResponse {
 661                    request_id: Uuid::parse_str("d5bd3afd-8723-47c7-bd77-15a3a926867b").unwrap(),
 662                    output_excerpt: format!(r#"{EDITABLE_REGION_START_MARKER}
 663a longggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg line
 664And maybe a short line
 665Then a few lines
 666and then another
 667[fifth and final completion]
 668{EDITABLE_REGION_END_MARKER}
 669                        "#),
 670                },
 671                cx,
 672            ),
 673        ];
 674
 675        cx.spawn(async move |zeta, cx| {
 676            for task in completion_tasks {
 677                task.await.unwrap();
 678            }
 679
 680            zeta.update(cx, |zeta, _cx| {
 681                zeta.shown_completions.get_mut(2).unwrap().edits = Arc::new([]);
 682                zeta.shown_completions.get_mut(3).unwrap().edits = Arc::new([]);
 683            })
 684            .ok();
 685        })
 686    }
 687
 688    #[cfg(any(test, feature = "test-support"))]
 689    pub fn fake_completion(
 690        &mut self,
 691        project: Option<&Entity<Project>>,
 692        buffer: &Entity<Buffer>,
 693        position: language::Anchor,
 694        response: PredictEditsResponse,
 695        cx: &mut Context<Self>,
 696    ) -> Task<Result<Option<EditPrediction>>> {
 697        use std::future::ready;
 698
 699        self.request_completion_impl(None, project, buffer, position, false, cx, |_params| {
 700            ready(Ok((response, None)))
 701        })
 702    }
 703
 704    pub fn request_completion(
 705        &mut self,
 706        project: Option<&Entity<Project>>,
 707        buffer: &Entity<Buffer>,
 708        position: language::Anchor,
 709        can_collect_data: bool,
 710        cx: &mut Context<Self>,
 711    ) -> Task<Result<Option<EditPrediction>>> {
 712        let workspace = self
 713            .workspace
 714            .as_ref()
 715            .and_then(|workspace| workspace.upgrade());
 716        self.request_completion_impl(
 717            workspace,
 718            project,
 719            buffer,
 720            position,
 721            can_collect_data,
 722            cx,
 723            Self::perform_predict_edits,
 724        )
 725    }
 726
 727    pub fn perform_predict_edits(
 728        params: PerformPredictEditsParams,
 729    ) -> impl Future<Output = Result<(PredictEditsResponse, Option<EditPredictionUsage>)>> {
 730        async move {
 731            let PerformPredictEditsParams {
 732                client,
 733                llm_token,
 734                app_version,
 735                body,
 736                ..
 737            } = params;
 738
 739            let http_client = client.http_client();
 740            let mut token = llm_token.acquire(&client).await?;
 741            let mut did_retry = false;
 742
 743            loop {
 744                let request_builder = http_client::Request::builder().method(Method::POST);
 745                let request_builder =
 746                    if let Ok(predict_edits_url) = std::env::var("ZED_PREDICT_EDITS_URL") {
 747                        request_builder.uri(predict_edits_url)
 748                    } else {
 749                        request_builder.uri(
 750                            http_client
 751                                .build_zed_llm_url("/predict_edits/v2", &[])?
 752                                .as_ref(),
 753                        )
 754                    };
 755                let request = request_builder
 756                    .header("Content-Type", "application/json")
 757                    .header("Authorization", format!("Bearer {}", token))
 758                    .header(ZED_VERSION_HEADER_NAME, app_version.to_string())
 759                    .body(serde_json::to_string(&body)?.into())?;
 760
 761                let mut response = http_client.send(request).await?;
 762
 763                if let Some(minimum_required_version) = response
 764                    .headers()
 765                    .get(MINIMUM_REQUIRED_VERSION_HEADER_NAME)
 766                    .and_then(|version| SemanticVersion::from_str(version.to_str().ok()?).ok())
 767                {
 768                    anyhow::ensure!(
 769                        app_version >= minimum_required_version,
 770                        ZedUpdateRequiredError {
 771                            minimum_version: minimum_required_version
 772                        }
 773                    );
 774                }
 775
 776                if response.status().is_success() {
 777                    let usage = EditPredictionUsage::from_headers(response.headers()).ok();
 778
 779                    let mut body = String::new();
 780                    response.body_mut().read_to_string(&mut body).await?;
 781                    return Ok((serde_json::from_str(&body)?, usage));
 782                } else if !did_retry
 783                    && response
 784                        .headers()
 785                        .get(EXPIRED_LLM_TOKEN_HEADER_NAME)
 786                        .is_some()
 787                {
 788                    did_retry = true;
 789                    token = llm_token.refresh(&client).await?;
 790                } else {
 791                    let mut body = String::new();
 792                    response.body_mut().read_to_string(&mut body).await?;
 793                    anyhow::bail!(
 794                        "error predicting edits.\nStatus: {:?}\nBody: {}",
 795                        response.status(),
 796                        body
 797                    );
 798                }
 799            }
 800        }
 801    }
 802
 803    fn accept_edit_prediction(
 804        &mut self,
 805        request_id: EditPredictionId,
 806        cx: &mut Context<Self>,
 807    ) -> Task<Result<()>> {
 808        let client = self.client.clone();
 809        let llm_token = self.llm_token.clone();
 810        let app_version = AppVersion::global(cx);
 811        cx.spawn(async move |this, cx| {
 812            let http_client = client.http_client();
 813            let mut response = llm_token_retry(&llm_token, &client, |token| {
 814                let request_builder = http_client::Request::builder().method(Method::POST);
 815                let request_builder =
 816                    if let Ok(accept_prediction_url) = std::env::var("ZED_ACCEPT_PREDICTION_URL") {
 817                        request_builder.uri(accept_prediction_url)
 818                    } else {
 819                        request_builder.uri(
 820                            http_client
 821                                .build_zed_llm_url("/predict_edits/accept", &[])?
 822                                .as_ref(),
 823                        )
 824                    };
 825                Ok(request_builder
 826                    .header("Content-Type", "application/json")
 827                    .header("Authorization", format!("Bearer {}", token))
 828                    .header(ZED_VERSION_HEADER_NAME, app_version.to_string())
 829                    .body(
 830                        serde_json::to_string(&AcceptEditPredictionBody {
 831                            request_id: request_id.0,
 832                        })?
 833                        .into(),
 834                    )?)
 835            })
 836            .await?;
 837
 838            if let Some(minimum_required_version) = response
 839                .headers()
 840                .get(MINIMUM_REQUIRED_VERSION_HEADER_NAME)
 841                .and_then(|version| SemanticVersion::from_str(version.to_str().ok()?).ok())
 842            {
 843                if app_version < minimum_required_version {
 844                    return Err(anyhow!(ZedUpdateRequiredError {
 845                        minimum_version: minimum_required_version
 846                    }));
 847                }
 848            }
 849
 850            if response.status().is_success() {
 851                if let Some(usage) = EditPredictionUsage::from_headers(response.headers()).ok() {
 852                    this.update(cx, |this, cx| {
 853                        this.user_store.update(cx, |user_store, cx| {
 854                            user_store.update_edit_prediction_usage(usage, cx);
 855                        });
 856                    })?;
 857                }
 858
 859                Ok(())
 860            } else {
 861                let mut body = String::new();
 862                response.body_mut().read_to_string(&mut body).await?;
 863                Err(anyhow!(
 864                    "error accepting edit prediction.\nStatus: {:?}\nBody: {}",
 865                    response.status(),
 866                    body
 867                ))
 868            }
 869        })
 870    }
 871
 872    fn process_completion_response(
 873        prediction_response: PredictEditsResponse,
 874        buffer: Entity<Buffer>,
 875        snapshot: &BufferSnapshot,
 876        editable_range: Range<usize>,
 877        cursor_offset: usize,
 878        path: Arc<Path>,
 879        input_outline: String,
 880        input_events: String,
 881        input_excerpt: String,
 882        buffer_snapshotted_at: Instant,
 883        cx: &AsyncApp,
 884    ) -> Task<Result<Option<EditPrediction>>> {
 885        let snapshot = snapshot.clone();
 886        let request_id = prediction_response.request_id;
 887        let output_excerpt = prediction_response.output_excerpt;
 888        cx.spawn(async move |cx| {
 889            let output_excerpt: Arc<str> = output_excerpt.into();
 890
 891            let edits: Arc<[(Range<Anchor>, String)]> = cx
 892                .background_spawn({
 893                    let output_excerpt = output_excerpt.clone();
 894                    let editable_range = editable_range.clone();
 895                    let snapshot = snapshot.clone();
 896                    async move { Self::parse_edits(output_excerpt, editable_range, &snapshot) }
 897                })
 898                .await?
 899                .into();
 900
 901            let Some((edits, snapshot, edit_preview)) = buffer.read_with(cx, {
 902                let edits = edits.clone();
 903                |buffer, cx| {
 904                    let new_snapshot = buffer.snapshot();
 905                    let edits: Arc<[(Range<Anchor>, String)]> =
 906                        interpolate(&snapshot, &new_snapshot, edits)?.into();
 907                    Some((edits.clone(), new_snapshot, buffer.preview_edits(edits, cx)))
 908                }
 909            })?
 910            else {
 911                return anyhow::Ok(None);
 912            };
 913
 914            let edit_preview = edit_preview.await;
 915
 916            Ok(Some(EditPrediction {
 917                id: EditPredictionId(request_id),
 918                path,
 919                excerpt_range: editable_range,
 920                cursor_offset,
 921                edits,
 922                edit_preview,
 923                snapshot,
 924                input_outline: input_outline.into(),
 925                input_events: input_events.into(),
 926                input_excerpt: input_excerpt.into(),
 927                output_excerpt,
 928                buffer_snapshotted_at,
 929                response_received_at: Instant::now(),
 930            }))
 931        })
 932    }
 933
 934    fn parse_edits(
 935        output_excerpt: Arc<str>,
 936        editable_range: Range<usize>,
 937        snapshot: &BufferSnapshot,
 938    ) -> Result<Vec<(Range<Anchor>, String)>> {
 939        let content = output_excerpt.replace(CURSOR_MARKER, "");
 940
 941        let start_markers = content
 942            .match_indices(EDITABLE_REGION_START_MARKER)
 943            .collect::<Vec<_>>();
 944        anyhow::ensure!(
 945            start_markers.len() == 1,
 946            "expected exactly one start marker, found {}",
 947            start_markers.len()
 948        );
 949
 950        let end_markers = content
 951            .match_indices(EDITABLE_REGION_END_MARKER)
 952            .collect::<Vec<_>>();
 953        anyhow::ensure!(
 954            end_markers.len() == 1,
 955            "expected exactly one end marker, found {}",
 956            end_markers.len()
 957        );
 958
 959        let sof_markers = content
 960            .match_indices(START_OF_FILE_MARKER)
 961            .collect::<Vec<_>>();
 962        anyhow::ensure!(
 963            sof_markers.len() <= 1,
 964            "expected at most one start-of-file marker, found {}",
 965            sof_markers.len()
 966        );
 967
 968        let codefence_start = start_markers[0].0;
 969        let content = &content[codefence_start..];
 970
 971        let newline_ix = content.find('\n').context("could not find newline")?;
 972        let content = &content[newline_ix + 1..];
 973
 974        let codefence_end = content
 975            .rfind(&format!("\n{EDITABLE_REGION_END_MARKER}"))
 976            .context("could not find end marker")?;
 977        let new_text = &content[..codefence_end];
 978
 979        let old_text = snapshot
 980            .text_for_range(editable_range.clone())
 981            .collect::<String>();
 982
 983        Ok(Self::compute_edits(
 984            old_text,
 985            new_text,
 986            editable_range.start,
 987            &snapshot,
 988        ))
 989    }
 990
 991    pub fn compute_edits(
 992        old_text: String,
 993        new_text: &str,
 994        offset: usize,
 995        snapshot: &BufferSnapshot,
 996    ) -> Vec<(Range<Anchor>, String)> {
 997        text_diff(&old_text, &new_text)
 998            .into_iter()
 999            .map(|(mut old_range, new_text)| {
1000                old_range.start += offset;
1001                old_range.end += offset;
1002
1003                let prefix_len = common_prefix(
1004                    snapshot.chars_for_range(old_range.clone()),
1005                    new_text.chars(),
1006                );
1007                old_range.start += prefix_len;
1008
1009                let suffix_len = common_prefix(
1010                    snapshot.reversed_chars_for_range(old_range.clone()),
1011                    new_text[prefix_len..].chars().rev(),
1012                );
1013                old_range.end = old_range.end.saturating_sub(suffix_len);
1014
1015                let new_text = new_text[prefix_len..new_text.len() - suffix_len].to_string();
1016                let range = if old_range.is_empty() {
1017                    let anchor = snapshot.anchor_after(old_range.start);
1018                    anchor..anchor
1019                } else {
1020                    snapshot.anchor_after(old_range.start)..snapshot.anchor_before(old_range.end)
1021                };
1022                (range, new_text)
1023            })
1024            .collect()
1025    }
1026
1027    pub fn is_completion_rated(&self, completion_id: EditPredictionId) -> bool {
1028        self.rated_completions.contains(&completion_id)
1029    }
1030
1031    pub fn completion_shown(&mut self, completion: &EditPrediction, cx: &mut Context<Self>) {
1032        self.shown_completions.push_front(completion.clone());
1033        if self.shown_completions.len() > 50 {
1034            let completion = self.shown_completions.pop_back().unwrap();
1035            self.rated_completions.remove(&completion.id);
1036        }
1037        cx.notify();
1038    }
1039
1040    pub fn rate_completion(
1041        &mut self,
1042        completion: &EditPrediction,
1043        rating: EditPredictionRating,
1044        feedback: String,
1045        cx: &mut Context<Self>,
1046    ) {
1047        self.rated_completions.insert(completion.id);
1048        telemetry::event!(
1049            "Edit Prediction Rated",
1050            rating,
1051            input_events = completion.input_events,
1052            input_excerpt = completion.input_excerpt,
1053            input_outline = completion.input_outline,
1054            output_excerpt = completion.output_excerpt,
1055            feedback
1056        );
1057        self.client.telemetry().flush_events().detach();
1058        cx.notify();
1059    }
1060
1061    pub fn shown_completions(&self) -> impl DoubleEndedIterator<Item = &EditPrediction> {
1062        self.shown_completions.iter()
1063    }
1064
1065    pub fn shown_completions_len(&self) -> usize {
1066        self.shown_completions.len()
1067    }
1068
1069    fn report_changes_for_buffer(
1070        &mut self,
1071        buffer: &Entity<Buffer>,
1072        cx: &mut Context<Self>,
1073    ) -> BufferSnapshot {
1074        self.register_buffer(buffer, cx);
1075
1076        let registered_buffer = self
1077            .registered_buffers
1078            .get_mut(&buffer.entity_id())
1079            .unwrap();
1080        let new_snapshot = buffer.read(cx).snapshot();
1081
1082        if new_snapshot.version != registered_buffer.snapshot.version {
1083            let old_snapshot = mem::replace(&mut registered_buffer.snapshot, new_snapshot.clone());
1084            self.push_event(Event::BufferChange {
1085                old_snapshot,
1086                new_snapshot: new_snapshot.clone(),
1087                timestamp: Instant::now(),
1088            });
1089        }
1090
1091        new_snapshot
1092    }
1093
1094    fn load_data_collection_choices() -> DataCollectionChoice {
1095        let choice = KEY_VALUE_STORE
1096            .read_kvp(ZED_PREDICT_DATA_COLLECTION_CHOICE)
1097            .log_err()
1098            .flatten();
1099
1100        match choice.as_deref() {
1101            Some("true") => DataCollectionChoice::Enabled,
1102            Some("false") => DataCollectionChoice::Disabled,
1103            Some(_) => {
1104                log::error!("unknown value in '{ZED_PREDICT_DATA_COLLECTION_CHOICE}'");
1105                DataCollectionChoice::NotAnswered
1106            }
1107            None => DataCollectionChoice::NotAnswered,
1108        }
1109    }
1110}
1111
1112pub struct PerformPredictEditsParams {
1113    pub client: Arc<Client>,
1114    pub llm_token: LlmApiToken,
1115    pub app_version: SemanticVersion,
1116    pub body: PredictEditsBody,
1117}
1118
1119#[derive(Error, Debug)]
1120#[error(
1121    "You must update to Zed version {minimum_version} or higher to continue using edit predictions."
1122)]
1123pub struct ZedUpdateRequiredError {
1124    minimum_version: SemanticVersion,
1125}
1126
1127struct LicenseDetectionWatcher {
1128    is_open_source_rx: watch::Receiver<bool>,
1129    _is_open_source_task: Task<()>,
1130}
1131
1132impl LicenseDetectionWatcher {
1133    pub fn new(worktree: &Worktree, cx: &mut Context<Worktree>) -> Self {
1134        let (mut is_open_source_tx, is_open_source_rx) = watch::channel_with::<bool>(false);
1135
1136        // Check if worktree is a single file, if so we do not need to check for a LICENSE file
1137        let task = if worktree.abs_path().is_file() {
1138            Task::ready(())
1139        } else {
1140            let loaded_files = LICENSE_FILES_TO_CHECK
1141                .iter()
1142                .map(Path::new)
1143                .map(|file| worktree.load_file(file, cx))
1144                .collect::<ArrayVec<_, { LICENSE_FILES_TO_CHECK.len() }>>();
1145
1146            cx.background_spawn(async move {
1147                for loaded_file in loaded_files.into_iter() {
1148                    let Ok(loaded_file) = loaded_file.await else {
1149                        continue;
1150                    };
1151
1152                    let path = &loaded_file.file.path;
1153                    if is_license_eligible_for_data_collection(&loaded_file.text) {
1154                        log::info!("detected '{path:?}' as open source license");
1155                        *is_open_source_tx.borrow_mut() = true;
1156                    } else {
1157                        log::info!("didn't detect '{path:?}' as open source license");
1158                    }
1159
1160                    // stop on the first license that successfully read
1161                    return;
1162                }
1163
1164                log::debug!("didn't find a license file to check, assuming closed source");
1165            })
1166        };
1167
1168        Self {
1169            is_open_source_rx,
1170            _is_open_source_task: task,
1171        }
1172    }
1173
1174    /// Answers false until we find out it's open source
1175    pub fn is_project_open_source(&self) -> bool {
1176        *self.is_open_source_rx.borrow()
1177    }
1178}
1179
1180fn common_prefix<T1: Iterator<Item = char>, T2: Iterator<Item = char>>(a: T1, b: T2) -> usize {
1181    a.zip(b)
1182        .take_while(|(a, b)| a == b)
1183        .map(|(a, _)| a.len_utf8())
1184        .sum()
1185}
1186
1187fn git_info_for_file(
1188    project: &Entity<Project>,
1189    project_path: &ProjectPath,
1190    cx: &App,
1191) -> Option<PredictEditsGitInfo> {
1192    let git_store = project.read(cx).git_store().read(cx);
1193    if let Some((repository, _repo_path)) =
1194        git_store.repository_and_path_for_project_path(project_path, cx)
1195    {
1196        let repository = repository.read(cx);
1197        let head_sha = repository
1198            .head_commit
1199            .as_ref()
1200            .map(|head_commit| head_commit.sha.to_string());
1201        let remote_origin_url = repository.remote_origin_url.clone();
1202        let remote_upstream_url = repository.remote_upstream_url.clone();
1203        if head_sha.is_none() && remote_origin_url.is_none() && remote_upstream_url.is_none() {
1204            return None;
1205        }
1206        Some(PredictEditsGitInfo {
1207            head_sha,
1208            remote_origin_url,
1209            remote_upstream_url,
1210        })
1211    } else {
1212        None
1213    }
1214}
1215
1216pub struct GatherContextOutput {
1217    pub body: PredictEditsBody,
1218    pub editable_range: Range<usize>,
1219}
1220
1221pub fn gather_context(
1222    project: Option<&Entity<Project>>,
1223    full_path_str: String,
1224    snapshot: &BufferSnapshot,
1225    cursor_point: language::Point,
1226    make_events_prompt: impl FnOnce() -> String + Send + 'static,
1227    can_collect_data: bool,
1228    git_info: Option<PredictEditsGitInfo>,
1229    cx: &App,
1230) -> Task<Result<GatherContextOutput>> {
1231    let local_lsp_store =
1232        project.and_then(|project| project.read(cx).lsp_store().read(cx).as_local());
1233    let diagnostic_groups: Vec<(String, serde_json::Value)> =
1234        if let Some(local_lsp_store) = local_lsp_store {
1235            snapshot
1236                .diagnostic_groups(None)
1237                .into_iter()
1238                .filter_map(|(language_server_id, diagnostic_group)| {
1239                    let language_server =
1240                        local_lsp_store.running_language_server_for_id(language_server_id)?;
1241                    let diagnostic_group = diagnostic_group.resolve::<usize>(&snapshot);
1242                    let language_server_name = language_server.name().to_string();
1243                    let serialized = serde_json::to_value(diagnostic_group).unwrap();
1244                    Some((language_server_name, serialized))
1245                })
1246                .collect::<Vec<_>>()
1247        } else {
1248            Vec::new()
1249        };
1250
1251    cx.background_spawn({
1252        let snapshot = snapshot.clone();
1253        async move {
1254            let diagnostic_groups = if diagnostic_groups.is_empty() {
1255                None
1256            } else {
1257                Some(diagnostic_groups)
1258            };
1259
1260            let input_excerpt = excerpt_for_cursor_position(
1261                cursor_point,
1262                &full_path_str,
1263                &snapshot,
1264                MAX_REWRITE_TOKENS,
1265                MAX_CONTEXT_TOKENS,
1266            );
1267            let input_events = make_events_prompt();
1268            let input_outline = prompt_for_outline(&snapshot);
1269            let editable_range = input_excerpt.editable_range.to_offset(&snapshot);
1270
1271            let body = PredictEditsBody {
1272                input_events,
1273                input_excerpt: input_excerpt.prompt,
1274                speculated_output: Some(input_excerpt.speculated_output),
1275                outline: Some(input_outline),
1276                can_collect_data,
1277                diagnostic_groups,
1278                git_info,
1279            };
1280
1281            Ok(GatherContextOutput {
1282                body,
1283                editable_range,
1284            })
1285        }
1286    })
1287}
1288
1289fn prompt_for_outline(snapshot: &BufferSnapshot) -> String {
1290    let mut input_outline = String::new();
1291
1292    writeln!(
1293        input_outline,
1294        "```{}",
1295        snapshot
1296            .file()
1297            .map_or(Cow::Borrowed("untitled"), |file| file
1298                .path()
1299                .to_string_lossy())
1300    )
1301    .unwrap();
1302
1303    if let Some(outline) = snapshot.outline(None) {
1304        for item in &outline.items {
1305            let spacing = " ".repeat(item.depth);
1306            writeln!(input_outline, "{}{}", spacing, item.text).unwrap();
1307        }
1308    }
1309
1310    writeln!(input_outline, "```").unwrap();
1311
1312    input_outline
1313}
1314
1315fn prompt_for_events(events: &VecDeque<Event>, mut remaining_tokens: usize) -> String {
1316    let mut result = String::new();
1317    for event in events.iter().rev() {
1318        let event_string = event.to_prompt();
1319        let event_tokens = tokens_for_bytes(event_string.len());
1320        if event_tokens > remaining_tokens {
1321            break;
1322        }
1323
1324        if !result.is_empty() {
1325            result.insert_str(0, "\n\n");
1326        }
1327        result.insert_str(0, &event_string);
1328        remaining_tokens -= event_tokens;
1329    }
1330    result
1331}
1332
1333struct RegisteredBuffer {
1334    snapshot: BufferSnapshot,
1335    _subscriptions: [gpui::Subscription; 2],
1336}
1337
1338#[derive(Clone)]
1339pub enum Event {
1340    BufferChange {
1341        old_snapshot: BufferSnapshot,
1342        new_snapshot: BufferSnapshot,
1343        timestamp: Instant,
1344    },
1345}
1346
1347impl Event {
1348    fn to_prompt(&self) -> String {
1349        match self {
1350            Event::BufferChange {
1351                old_snapshot,
1352                new_snapshot,
1353                ..
1354            } => {
1355                let mut prompt = String::new();
1356
1357                let old_path = old_snapshot
1358                    .file()
1359                    .map(|f| f.path().as_ref())
1360                    .unwrap_or(Path::new("untitled"));
1361                let new_path = new_snapshot
1362                    .file()
1363                    .map(|f| f.path().as_ref())
1364                    .unwrap_or(Path::new("untitled"));
1365                if old_path != new_path {
1366                    writeln!(prompt, "User renamed {:?} to {:?}\n", old_path, new_path).unwrap();
1367                }
1368
1369                let diff = language::unified_diff(&old_snapshot.text(), &new_snapshot.text());
1370                if !diff.is_empty() {
1371                    write!(
1372                        prompt,
1373                        "User edited {:?}:\n```diff\n{}\n```",
1374                        new_path, diff
1375                    )
1376                    .unwrap();
1377                }
1378
1379                prompt
1380            }
1381        }
1382    }
1383}
1384
1385#[derive(Debug, Clone)]
1386struct CurrentEditPrediction {
1387    buffer_id: EntityId,
1388    completion: EditPrediction,
1389}
1390
1391impl CurrentEditPrediction {
1392    fn should_replace_completion(&self, old_completion: &Self, snapshot: &BufferSnapshot) -> bool {
1393        if self.buffer_id != old_completion.buffer_id {
1394            return true;
1395        }
1396
1397        let Some(old_edits) = old_completion.completion.interpolate(&snapshot) else {
1398            return true;
1399        };
1400        let Some(new_edits) = self.completion.interpolate(&snapshot) else {
1401            return false;
1402        };
1403
1404        if old_edits.len() == 1 && new_edits.len() == 1 {
1405            let (old_range, old_text) = &old_edits[0];
1406            let (new_range, new_text) = &new_edits[0];
1407            new_range == old_range && new_text.starts_with(old_text)
1408        } else {
1409            true
1410        }
1411    }
1412}
1413
1414struct PendingCompletion {
1415    id: usize,
1416    _task: Task<()>,
1417}
1418
1419#[derive(Debug, Clone, Copy)]
1420pub enum DataCollectionChoice {
1421    NotAnswered,
1422    Enabled,
1423    Disabled,
1424}
1425
1426impl DataCollectionChoice {
1427    pub fn is_enabled(self) -> bool {
1428        match self {
1429            Self::Enabled => true,
1430            Self::NotAnswered | Self::Disabled => false,
1431        }
1432    }
1433
1434    pub fn is_answered(self) -> bool {
1435        match self {
1436            Self::Enabled | Self::Disabled => true,
1437            Self::NotAnswered => false,
1438        }
1439    }
1440
1441    pub fn toggle(&self) -> DataCollectionChoice {
1442        match self {
1443            Self::Enabled => Self::Disabled,
1444            Self::Disabled => Self::Enabled,
1445            Self::NotAnswered => Self::Enabled,
1446        }
1447    }
1448}
1449
1450impl From<bool> for DataCollectionChoice {
1451    fn from(value: bool) -> Self {
1452        match value {
1453            true => DataCollectionChoice::Enabled,
1454            false => DataCollectionChoice::Disabled,
1455        }
1456    }
1457}
1458
1459pub struct ProviderDataCollection {
1460    /// When set to None, data collection is not possible in the provider buffer
1461    choice: Option<Entity<DataCollectionChoice>>,
1462    license_detection_watcher: Option<Rc<LicenseDetectionWatcher>>,
1463}
1464
1465impl ProviderDataCollection {
1466    pub fn new(zeta: Entity<Zeta>, buffer: Option<Entity<Buffer>>, cx: &mut App) -> Self {
1467        let choice_and_watcher = buffer.and_then(|buffer| {
1468            let file = buffer.read(cx).file()?;
1469
1470            if !file.is_local() || file.is_private() {
1471                return None;
1472            }
1473
1474            let zeta = zeta.read(cx);
1475            let choice = zeta.data_collection_choice.clone();
1476
1477            let license_detection_watcher = zeta
1478                .license_detection_watchers
1479                .get(&file.worktree_id(cx))
1480                .cloned()?;
1481
1482            Some((choice, license_detection_watcher))
1483        });
1484
1485        if let Some((choice, watcher)) = choice_and_watcher {
1486            ProviderDataCollection {
1487                choice: Some(choice),
1488                license_detection_watcher: Some(watcher),
1489            }
1490        } else {
1491            ProviderDataCollection {
1492                choice: None,
1493                license_detection_watcher: None,
1494            }
1495        }
1496    }
1497
1498    pub fn can_collect_data(&self, cx: &App) -> bool {
1499        self.is_data_collection_enabled(cx) && self.is_project_open_source()
1500    }
1501
1502    pub fn is_data_collection_enabled(&self, cx: &App) -> bool {
1503        self.choice
1504            .as_ref()
1505            .is_some_and(|choice| choice.read(cx).is_enabled())
1506    }
1507
1508    fn is_project_open_source(&self) -> bool {
1509        self.license_detection_watcher
1510            .as_ref()
1511            .is_some_and(|watcher| watcher.is_project_open_source())
1512    }
1513
1514    pub fn toggle(&mut self, cx: &mut App) {
1515        if let Some(choice) = self.choice.as_mut() {
1516            let new_choice = choice.update(cx, |choice, _cx| {
1517                let new_choice = choice.toggle();
1518                *choice = new_choice;
1519                new_choice
1520            });
1521
1522            db::write_and_log(cx, move || {
1523                KEY_VALUE_STORE.write_kvp(
1524                    ZED_PREDICT_DATA_COLLECTION_CHOICE.into(),
1525                    new_choice.is_enabled().to_string(),
1526                )
1527            });
1528        }
1529    }
1530}
1531
1532async fn llm_token_retry(
1533    llm_token: &LlmApiToken,
1534    client: &Arc<Client>,
1535    build_request: impl Fn(String) -> Result<Request<AsyncBody>>,
1536) -> Result<Response<AsyncBody>> {
1537    let mut did_retry = false;
1538    let http_client = client.http_client();
1539    let mut token = llm_token.acquire(client).await?;
1540    loop {
1541        let request = build_request(token.clone())?;
1542        let response = http_client.send(request).await?;
1543
1544        if !did_retry
1545            && !response.status().is_success()
1546            && response
1547                .headers()
1548                .get(EXPIRED_LLM_TOKEN_HEADER_NAME)
1549                .is_some()
1550        {
1551            did_retry = true;
1552            token = llm_token.refresh(client).await?;
1553            continue;
1554        }
1555
1556        return Ok(response);
1557    }
1558}
1559
1560pub struct ZetaEditPredictionProvider {
1561    zeta: Entity<Zeta>,
1562    pending_completions: ArrayVec<PendingCompletion, 2>,
1563    next_pending_completion_id: usize,
1564    current_completion: Option<CurrentEditPrediction>,
1565    /// None if this is entirely disabled for this provider
1566    provider_data_collection: ProviderDataCollection,
1567    last_request_timestamp: Instant,
1568}
1569
1570impl ZetaEditPredictionProvider {
1571    pub const THROTTLE_TIMEOUT: Duration = Duration::from_millis(300);
1572
1573    pub fn new(zeta: Entity<Zeta>, provider_data_collection: ProviderDataCollection) -> Self {
1574        Self {
1575            zeta,
1576            pending_completions: ArrayVec::new(),
1577            next_pending_completion_id: 0,
1578            current_completion: None,
1579            provider_data_collection,
1580            last_request_timestamp: Instant::now(),
1581        }
1582    }
1583}
1584
1585impl edit_prediction::EditPredictionProvider for ZetaEditPredictionProvider {
1586    fn name() -> &'static str {
1587        "zed-predict"
1588    }
1589
1590    fn display_name() -> &'static str {
1591        "Zed's Edit Predictions"
1592    }
1593
1594    fn show_completions_in_menu() -> bool {
1595        true
1596    }
1597
1598    fn show_tab_accept_marker() -> bool {
1599        true
1600    }
1601
1602    fn data_collection_state(&self, cx: &App) -> DataCollectionState {
1603        let is_project_open_source = self.provider_data_collection.is_project_open_source();
1604
1605        if self.provider_data_collection.is_data_collection_enabled(cx) {
1606            DataCollectionState::Enabled {
1607                is_project_open_source,
1608            }
1609        } else {
1610            DataCollectionState::Disabled {
1611                is_project_open_source,
1612            }
1613        }
1614    }
1615
1616    fn toggle_data_collection(&mut self, cx: &mut App) {
1617        self.provider_data_collection.toggle(cx);
1618    }
1619
1620    fn usage(&self, cx: &App) -> Option<EditPredictionUsage> {
1621        self.zeta.read(cx).usage(cx)
1622    }
1623
1624    fn is_enabled(
1625        &self,
1626        _buffer: &Entity<Buffer>,
1627        _cursor_position: language::Anchor,
1628        _cx: &App,
1629    ) -> bool {
1630        true
1631    }
1632
1633    fn needs_terms_acceptance(&self, cx: &App) -> bool {
1634        !self
1635            .zeta
1636            .read(cx)
1637            .user_store
1638            .read(cx)
1639            .has_accepted_terms_of_service()
1640    }
1641
1642    fn is_refreshing(&self) -> bool {
1643        !self.pending_completions.is_empty()
1644    }
1645
1646    fn refresh(
1647        &mut self,
1648        project: Option<Entity<Project>>,
1649        buffer: Entity<Buffer>,
1650        position: language::Anchor,
1651        _debounce: bool,
1652        cx: &mut Context<Self>,
1653    ) {
1654        if self.needs_terms_acceptance(cx) {
1655            return;
1656        }
1657
1658        if self.zeta.read(cx).update_required {
1659            return;
1660        }
1661
1662        if self
1663            .zeta
1664            .read(cx)
1665            .user_store
1666            .read_with(cx, |user_store, _cx| {
1667                user_store.account_too_young() || user_store.has_overdue_invoices()
1668            })
1669        {
1670            return;
1671        }
1672
1673        if let Some(current_completion) = self.current_completion.as_ref() {
1674            let snapshot = buffer.read(cx).snapshot();
1675            if current_completion
1676                .completion
1677                .interpolate(&snapshot)
1678                .is_some()
1679            {
1680                return;
1681            }
1682        }
1683
1684        let pending_completion_id = self.next_pending_completion_id;
1685        self.next_pending_completion_id += 1;
1686        let can_collect_data = self.provider_data_collection.can_collect_data(cx);
1687        let last_request_timestamp = self.last_request_timestamp;
1688
1689        let task = cx.spawn(async move |this, cx| {
1690            if let Some(timeout) = (last_request_timestamp + Self::THROTTLE_TIMEOUT)
1691                .checked_duration_since(Instant::now())
1692            {
1693                cx.background_executor().timer(timeout).await;
1694            }
1695
1696            let completion_request = this.update(cx, |this, cx| {
1697                this.last_request_timestamp = Instant::now();
1698                this.zeta.update(cx, |zeta, cx| {
1699                    zeta.request_completion(
1700                        project.as_ref(),
1701                        &buffer,
1702                        position,
1703                        can_collect_data,
1704                        cx,
1705                    )
1706                })
1707            });
1708
1709            let completion = match completion_request {
1710                Ok(completion_request) => {
1711                    let completion_request = completion_request.await;
1712                    completion_request.map(|c| {
1713                        c.map(|completion| CurrentEditPrediction {
1714                            buffer_id: buffer.entity_id(),
1715                            completion,
1716                        })
1717                    })
1718                }
1719                Err(error) => Err(error),
1720            };
1721            let Some(new_completion) = completion
1722                .context("edit prediction failed")
1723                .log_err()
1724                .flatten()
1725            else {
1726                this.update(cx, |this, cx| {
1727                    if this.pending_completions[0].id == pending_completion_id {
1728                        this.pending_completions.remove(0);
1729                    } else {
1730                        this.pending_completions.clear();
1731                    }
1732
1733                    cx.notify();
1734                })
1735                .ok();
1736                return;
1737            };
1738
1739            this.update(cx, |this, cx| {
1740                if this.pending_completions[0].id == pending_completion_id {
1741                    this.pending_completions.remove(0);
1742                } else {
1743                    this.pending_completions.clear();
1744                }
1745
1746                if let Some(old_completion) = this.current_completion.as_ref() {
1747                    let snapshot = buffer.read(cx).snapshot();
1748                    if new_completion.should_replace_completion(&old_completion, &snapshot) {
1749                        this.zeta.update(cx, |zeta, cx| {
1750                            zeta.completion_shown(&new_completion.completion, cx);
1751                        });
1752                        this.current_completion = Some(new_completion);
1753                    }
1754                } else {
1755                    this.zeta.update(cx, |zeta, cx| {
1756                        zeta.completion_shown(&new_completion.completion, cx);
1757                    });
1758                    this.current_completion = Some(new_completion);
1759                }
1760
1761                cx.notify();
1762            })
1763            .ok();
1764        });
1765
1766        // We always maintain at most two pending completions. When we already
1767        // have two, we replace the newest one.
1768        if self.pending_completions.len() <= 1 {
1769            self.pending_completions.push(PendingCompletion {
1770                id: pending_completion_id,
1771                _task: task,
1772            });
1773        } else if self.pending_completions.len() == 2 {
1774            self.pending_completions.pop();
1775            self.pending_completions.push(PendingCompletion {
1776                id: pending_completion_id,
1777                _task: task,
1778            });
1779        }
1780    }
1781
1782    fn cycle(
1783        &mut self,
1784        _buffer: Entity<Buffer>,
1785        _cursor_position: language::Anchor,
1786        _direction: edit_prediction::Direction,
1787        _cx: &mut Context<Self>,
1788    ) {
1789        // Right now we don't support cycling.
1790    }
1791
1792    fn accept(&mut self, cx: &mut Context<Self>) {
1793        let completion_id = self
1794            .current_completion
1795            .as_ref()
1796            .map(|completion| completion.completion.id);
1797        if let Some(completion_id) = completion_id {
1798            self.zeta
1799                .update(cx, |zeta, cx| {
1800                    zeta.accept_edit_prediction(completion_id, cx)
1801                })
1802                .detach();
1803        }
1804        self.pending_completions.clear();
1805    }
1806
1807    fn discard(&mut self, _cx: &mut Context<Self>) {
1808        self.pending_completions.clear();
1809        self.current_completion.take();
1810    }
1811
1812    fn suggest(
1813        &mut self,
1814        buffer: &Entity<Buffer>,
1815        cursor_position: language::Anchor,
1816        cx: &mut Context<Self>,
1817    ) -> Option<edit_prediction::EditPrediction> {
1818        let CurrentEditPrediction {
1819            buffer_id,
1820            completion,
1821            ..
1822        } = self.current_completion.as_mut()?;
1823
1824        // Invalidate previous completion if it was generated for a different buffer.
1825        if *buffer_id != buffer.entity_id() {
1826            self.current_completion.take();
1827            return None;
1828        }
1829
1830        let buffer = buffer.read(cx);
1831        let Some(edits) = completion.interpolate(&buffer.snapshot()) else {
1832            self.current_completion.take();
1833            return None;
1834        };
1835
1836        let cursor_row = cursor_position.to_point(buffer).row;
1837        let (closest_edit_ix, (closest_edit_range, _)) =
1838            edits.iter().enumerate().min_by_key(|(_, (range, _))| {
1839                let distance_from_start = cursor_row.abs_diff(range.start.to_point(buffer).row);
1840                let distance_from_end = cursor_row.abs_diff(range.end.to_point(buffer).row);
1841                cmp::min(distance_from_start, distance_from_end)
1842            })?;
1843
1844        let mut edit_start_ix = closest_edit_ix;
1845        for (range, _) in edits[..edit_start_ix].iter().rev() {
1846            let distance_from_closest_edit =
1847                closest_edit_range.start.to_point(buffer).row - range.end.to_point(buffer).row;
1848            if distance_from_closest_edit <= 1 {
1849                edit_start_ix -= 1;
1850            } else {
1851                break;
1852            }
1853        }
1854
1855        let mut edit_end_ix = closest_edit_ix + 1;
1856        for (range, _) in &edits[edit_end_ix..] {
1857            let distance_from_closest_edit =
1858                range.start.to_point(buffer).row - closest_edit_range.end.to_point(buffer).row;
1859            if distance_from_closest_edit <= 1 {
1860                edit_end_ix += 1;
1861            } else {
1862                break;
1863            }
1864        }
1865
1866        Some(edit_prediction::EditPrediction {
1867            id: Some(completion.id.to_string().into()),
1868            edits: edits[edit_start_ix..edit_end_ix].to_vec(),
1869            edit_preview: Some(completion.edit_preview.clone()),
1870        })
1871    }
1872}
1873
1874fn tokens_for_bytes(bytes: usize) -> usize {
1875    /// Typical number of string bytes per token for the purposes of limiting model input. This is
1876    /// intentionally low to err on the side of underestimating limits.
1877    const BYTES_PER_TOKEN_GUESS: usize = 3;
1878    bytes / BYTES_PER_TOKEN_GUESS
1879}
1880
1881#[cfg(test)]
1882mod tests {
1883    use client::UserStore;
1884    use client::test::FakeServer;
1885    use clock::FakeSystemClock;
1886    use cloud_api_types::{CreateLlmTokenResponse, LlmToken};
1887    use gpui::TestAppContext;
1888    use http_client::FakeHttpClient;
1889    use indoc::indoc;
1890    use language::Point;
1891    use settings::SettingsStore;
1892
1893    use super::*;
1894
1895    #[gpui::test]
1896    async fn test_edit_prediction_basic_interpolation(cx: &mut TestAppContext) {
1897        let buffer = cx.new(|cx| Buffer::local("Lorem ipsum dolor", cx));
1898        let edits: Arc<[(Range<Anchor>, String)]> = cx.update(|cx| {
1899            to_completion_edits(
1900                [(2..5, "REM".to_string()), (9..11, "".to_string())],
1901                &buffer,
1902                cx,
1903            )
1904            .into()
1905        });
1906
1907        let edit_preview = cx
1908            .read(|cx| buffer.read(cx).preview_edits(edits.clone(), cx))
1909            .await;
1910
1911        let completion = EditPrediction {
1912            edits,
1913            edit_preview,
1914            path: Path::new("").into(),
1915            snapshot: cx.read(|cx| buffer.read(cx).snapshot()),
1916            id: EditPredictionId(Uuid::new_v4()),
1917            excerpt_range: 0..0,
1918            cursor_offset: 0,
1919            input_outline: "".into(),
1920            input_events: "".into(),
1921            input_excerpt: "".into(),
1922            output_excerpt: "".into(),
1923            buffer_snapshotted_at: Instant::now(),
1924            response_received_at: Instant::now(),
1925        };
1926
1927        cx.update(|cx| {
1928            assert_eq!(
1929                from_completion_edits(
1930                    &completion.interpolate(&buffer.read(cx).snapshot()).unwrap(),
1931                    &buffer,
1932                    cx
1933                ),
1934                vec![(2..5, "REM".to_string()), (9..11, "".to_string())]
1935            );
1936
1937            buffer.update(cx, |buffer, cx| buffer.edit([(2..5, "")], None, cx));
1938            assert_eq!(
1939                from_completion_edits(
1940                    &completion.interpolate(&buffer.read(cx).snapshot()).unwrap(),
1941                    &buffer,
1942                    cx
1943                ),
1944                vec![(2..2, "REM".to_string()), (6..8, "".to_string())]
1945            );
1946
1947            buffer.update(cx, |buffer, cx| buffer.undo(cx));
1948            assert_eq!(
1949                from_completion_edits(
1950                    &completion.interpolate(&buffer.read(cx).snapshot()).unwrap(),
1951                    &buffer,
1952                    cx
1953                ),
1954                vec![(2..5, "REM".to_string()), (9..11, "".to_string())]
1955            );
1956
1957            buffer.update(cx, |buffer, cx| buffer.edit([(2..5, "R")], None, cx));
1958            assert_eq!(
1959                from_completion_edits(
1960                    &completion.interpolate(&buffer.read(cx).snapshot()).unwrap(),
1961                    &buffer,
1962                    cx
1963                ),
1964                vec![(3..3, "EM".to_string()), (7..9, "".to_string())]
1965            );
1966
1967            buffer.update(cx, |buffer, cx| buffer.edit([(3..3, "E")], None, cx));
1968            assert_eq!(
1969                from_completion_edits(
1970                    &completion.interpolate(&buffer.read(cx).snapshot()).unwrap(),
1971                    &buffer,
1972                    cx
1973                ),
1974                vec![(4..4, "M".to_string()), (8..10, "".to_string())]
1975            );
1976
1977            buffer.update(cx, |buffer, cx| buffer.edit([(4..4, "M")], None, cx));
1978            assert_eq!(
1979                from_completion_edits(
1980                    &completion.interpolate(&buffer.read(cx).snapshot()).unwrap(),
1981                    &buffer,
1982                    cx
1983                ),
1984                vec![(9..11, "".to_string())]
1985            );
1986
1987            buffer.update(cx, |buffer, cx| buffer.edit([(4..5, "")], None, cx));
1988            assert_eq!(
1989                from_completion_edits(
1990                    &completion.interpolate(&buffer.read(cx).snapshot()).unwrap(),
1991                    &buffer,
1992                    cx
1993                ),
1994                vec![(4..4, "M".to_string()), (8..10, "".to_string())]
1995            );
1996
1997            buffer.update(cx, |buffer, cx| buffer.edit([(8..10, "")], None, cx));
1998            assert_eq!(
1999                from_completion_edits(
2000                    &completion.interpolate(&buffer.read(cx).snapshot()).unwrap(),
2001                    &buffer,
2002                    cx
2003                ),
2004                vec![(4..4, "M".to_string())]
2005            );
2006
2007            buffer.update(cx, |buffer, cx| buffer.edit([(4..6, "")], None, cx));
2008            assert_eq!(completion.interpolate(&buffer.read(cx).snapshot()), None);
2009        })
2010    }
2011
2012    #[gpui::test]
2013    async fn test_clean_up_diff(cx: &mut TestAppContext) {
2014        cx.update(|cx| {
2015            let settings_store = SettingsStore::test(cx);
2016            cx.set_global(settings_store);
2017            client::init_settings(cx);
2018        });
2019
2020        let edits = edits_for_prediction(
2021            indoc! {"
2022                fn main() {
2023                    let word_1 = \"lorem\";
2024                    let range = word.len()..word.len();
2025                }
2026            "},
2027            indoc! {"
2028                <|editable_region_start|>
2029                fn main() {
2030                    let word_1 = \"lorem\";
2031                    let range = word_1.len()..word_1.len();
2032                }
2033
2034                <|editable_region_end|>
2035            "},
2036            cx,
2037        )
2038        .await;
2039        assert_eq!(
2040            edits,
2041            [
2042                (Point::new(2, 20)..Point::new(2, 20), "_1".to_string()),
2043                (Point::new(2, 32)..Point::new(2, 32), "_1".to_string()),
2044            ]
2045        );
2046
2047        let edits = edits_for_prediction(
2048            indoc! {"
2049                fn main() {
2050                    let story = \"the quick\"
2051                }
2052            "},
2053            indoc! {"
2054                <|editable_region_start|>
2055                fn main() {
2056                    let story = \"the quick brown fox jumps over the lazy dog\";
2057                }
2058
2059                <|editable_region_end|>
2060            "},
2061            cx,
2062        )
2063        .await;
2064        assert_eq!(
2065            edits,
2066            [
2067                (
2068                    Point::new(1, 26)..Point::new(1, 26),
2069                    " brown fox jumps over the lazy dog".to_string()
2070                ),
2071                (Point::new(1, 27)..Point::new(1, 27), ";".to_string()),
2072            ]
2073        );
2074    }
2075
2076    #[gpui::test]
2077    async fn test_edit_prediction_end_of_buffer(cx: &mut TestAppContext) {
2078        cx.update(|cx| {
2079            let settings_store = SettingsStore::test(cx);
2080            cx.set_global(settings_store);
2081            client::init_settings(cx);
2082        });
2083
2084        let buffer_content = "lorem\n";
2085        let completion_response = indoc! {"
2086            ```animals.js
2087            <|start_of_file|>
2088            <|editable_region_start|>
2089            lorem
2090            ipsum
2091            <|editable_region_end|>
2092            ```"};
2093
2094        let http_client = FakeHttpClient::create(move |req| async move {
2095            match (req.method(), req.uri().path()) {
2096                (&Method::POST, "/client/llm_tokens") => Ok(http_client::Response::builder()
2097                    .status(200)
2098                    .body(
2099                        serde_json::to_string(&CreateLlmTokenResponse {
2100                            token: LlmToken("the-llm-token".to_string()),
2101                        })
2102                        .unwrap()
2103                        .into(),
2104                    )
2105                    .unwrap()),
2106                (&Method::POST, "/predict_edits/v2") => Ok(http_client::Response::builder()
2107                    .status(200)
2108                    .body(
2109                        serde_json::to_string(&PredictEditsResponse {
2110                            request_id: Uuid::parse_str("7e86480f-3536-4d2c-9334-8213e3445d45")
2111                                .unwrap(),
2112                            output_excerpt: completion_response.to_string(),
2113                        })
2114                        .unwrap()
2115                        .into(),
2116                    )
2117                    .unwrap()),
2118                _ => Ok(http_client::Response::builder()
2119                    .status(404)
2120                    .body("Not Found".into())
2121                    .unwrap()),
2122            }
2123        });
2124
2125        let client = cx.update(|cx| Client::new(Arc::new(FakeSystemClock::new()), http_client, cx));
2126        cx.update(|cx| {
2127            RefreshLlmTokenListener::register(client.clone(), cx);
2128        });
2129        // Construct the fake server to authenticate.
2130        let _server = FakeServer::for_client(42, &client, cx).await;
2131        let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));
2132        let zeta = cx.new(|cx| Zeta::new(None, client, user_store.clone(), cx));
2133
2134        let buffer = cx.new(|cx| Buffer::local(buffer_content, cx));
2135        let cursor = buffer.read_with(cx, |buffer, _| buffer.anchor_before(Point::new(1, 0)));
2136        let completion_task = zeta.update(cx, |zeta, cx| {
2137            zeta.request_completion(None, &buffer, cursor, false, cx)
2138        });
2139
2140        let completion = completion_task.await.unwrap().unwrap();
2141        buffer.update(cx, |buffer, cx| {
2142            buffer.edit(completion.edits.iter().cloned(), None, cx)
2143        });
2144        assert_eq!(
2145            buffer.read_with(cx, |buffer, _| buffer.text()),
2146            "lorem\nipsum"
2147        );
2148    }
2149
2150    async fn edits_for_prediction(
2151        buffer_content: &str,
2152        completion_response: &str,
2153        cx: &mut TestAppContext,
2154    ) -> Vec<(Range<Point>, String)> {
2155        let completion_response = completion_response.to_string();
2156        let http_client = FakeHttpClient::create(move |req| {
2157            let completion = completion_response.clone();
2158            async move {
2159                match (req.method(), req.uri().path()) {
2160                    (&Method::POST, "/client/llm_tokens") => Ok(http_client::Response::builder()
2161                        .status(200)
2162                        .body(
2163                            serde_json::to_string(&CreateLlmTokenResponse {
2164                                token: LlmToken("the-llm-token".to_string()),
2165                            })
2166                            .unwrap()
2167                            .into(),
2168                        )
2169                        .unwrap()),
2170                    (&Method::POST, "/predict_edits/v2") => Ok(http_client::Response::builder()
2171                        .status(200)
2172                        .body(
2173                            serde_json::to_string(&PredictEditsResponse {
2174                                request_id: Uuid::new_v4(),
2175                                output_excerpt: completion,
2176                            })
2177                            .unwrap()
2178                            .into(),
2179                        )
2180                        .unwrap()),
2181                    _ => Ok(http_client::Response::builder()
2182                        .status(404)
2183                        .body("Not Found".into())
2184                        .unwrap()),
2185                }
2186            }
2187        });
2188
2189        let client = cx.update(|cx| Client::new(Arc::new(FakeSystemClock::new()), http_client, cx));
2190        cx.update(|cx| {
2191            RefreshLlmTokenListener::register(client.clone(), cx);
2192        });
2193        // Construct the fake server to authenticate.
2194        let _server = FakeServer::for_client(42, &client, cx).await;
2195        let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));
2196        let zeta = cx.new(|cx| Zeta::new(None, client, user_store.clone(), cx));
2197
2198        let buffer = cx.new(|cx| Buffer::local(buffer_content, cx));
2199        let snapshot = buffer.read_with(cx, |buffer, _| buffer.snapshot());
2200        let cursor = buffer.read_with(cx, |buffer, _| buffer.anchor_before(Point::new(1, 0)));
2201        let completion_task = zeta.update(cx, |zeta, cx| {
2202            zeta.request_completion(None, &buffer, cursor, false, cx)
2203        });
2204
2205        let completion = completion_task.await.unwrap().unwrap();
2206        completion
2207            .edits
2208            .into_iter()
2209            .map(|(old_range, new_text)| (old_range.to_point(&snapshot), new_text.clone()))
2210            .collect::<Vec<_>>()
2211    }
2212
2213    fn to_completion_edits(
2214        iterator: impl IntoIterator<Item = (Range<usize>, String)>,
2215        buffer: &Entity<Buffer>,
2216        cx: &App,
2217    ) -> Vec<(Range<Anchor>, String)> {
2218        let buffer = buffer.read(cx);
2219        iterator
2220            .into_iter()
2221            .map(|(range, text)| {
2222                (
2223                    buffer.anchor_after(range.start)..buffer.anchor_before(range.end),
2224                    text,
2225                )
2226            })
2227            .collect()
2228    }
2229
2230    fn from_completion_edits(
2231        editor_edits: &[(Range<Anchor>, String)],
2232        buffer: &Entity<Buffer>,
2233        cx: &App,
2234    ) -> Vec<(Range<usize>, String)> {
2235        let buffer = buffer.read(cx);
2236        editor_edits
2237            .iter()
2238            .map(|(range, text)| {
2239                (
2240                    range.start.to_offset(buffer)..range.end.to_offset(buffer),
2241                    text.clone(),
2242                )
2243            })
2244            .collect()
2245    }
2246
2247    #[ctor::ctor]
2248    fn init_logger() {
2249        zlog::init_test();
2250    }
2251}