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