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