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