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