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