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