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