1use std::{cmp::Reverse, rc::Rc, sync::Arc};
2
3use acp_thread::{AgentModelInfo, AgentModelList, AgentModelSelector};
4use agent_client_protocol::ModelId;
5use agent_servers::AgentServer;
6use agent_settings::AgentSettings;
7use anyhow::Result;
8use collections::{HashSet, IndexMap};
9use fs::Fs;
10use futures::FutureExt;
11use fuzzy::{StringMatchCandidate, match_strings};
12use gpui::{
13 Action, AsyncWindowContext, BackgroundExecutor, DismissEvent, FocusHandle, Task, WeakEntity,
14};
15use itertools::Itertools;
16use ordered_float::OrderedFloat;
17use picker::{Picker, PickerDelegate};
18use settings::Settings;
19use ui::{DocumentationAside, DocumentationEdge, DocumentationSide, IntoElement, prelude::*};
20use util::ResultExt;
21use zed_actions::agent::OpenSettings;
22
23use crate::ui::{HoldForDefault, ModelSelectorFooter, ModelSelectorHeader, ModelSelectorListItem};
24
25pub type AcpModelSelector = Picker<AcpModelPickerDelegate>;
26
27pub fn acp_model_selector(
28 selector: Rc<dyn AgentModelSelector>,
29 agent_server: Rc<dyn AgentServer>,
30 fs: Arc<dyn Fs>,
31 focus_handle: FocusHandle,
32 window: &mut Window,
33 cx: &mut Context<AcpModelSelector>,
34) -> AcpModelSelector {
35 let delegate =
36 AcpModelPickerDelegate::new(selector, agent_server, fs, focus_handle, window, cx);
37 Picker::list(delegate, window, cx)
38 .show_scrollbar(true)
39 .width(rems(20.))
40 .max_height(Some(rems(20.).into()))
41}
42
43enum AcpModelPickerEntry {
44 Separator(SharedString),
45 Model(AgentModelInfo, bool),
46}
47
48pub struct AcpModelPickerDelegate {
49 selector: Rc<dyn AgentModelSelector>,
50 agent_server: Rc<dyn AgentServer>,
51 fs: Arc<dyn Fs>,
52 filtered_entries: Vec<AcpModelPickerEntry>,
53 models: Option<AgentModelList>,
54 selected_index: usize,
55 selected_description: Option<(usize, SharedString, bool)>,
56 selected_model: Option<AgentModelInfo>,
57 _refresh_models_task: Task<()>,
58 focus_handle: FocusHandle,
59}
60
61impl AcpModelPickerDelegate {
62 fn new(
63 selector: Rc<dyn AgentModelSelector>,
64 agent_server: Rc<dyn AgentServer>,
65 fs: Arc<dyn Fs>,
66 focus_handle: FocusHandle,
67 window: &mut Window,
68 cx: &mut Context<AcpModelSelector>,
69 ) -> Self {
70 let rx = selector.watch(cx);
71 let refresh_models_task = {
72 cx.spawn_in(window, {
73 async move |this, cx| {
74 async fn refresh(
75 this: &WeakEntity<Picker<AcpModelPickerDelegate>>,
76 cx: &mut AsyncWindowContext,
77 ) -> Result<()> {
78 let (models_task, selected_model_task) = this.update(cx, |this, cx| {
79 (
80 this.delegate.selector.list_models(cx),
81 this.delegate.selector.selected_model(cx),
82 )
83 })?;
84
85 let (models, selected_model) =
86 futures::join!(models_task, selected_model_task);
87
88 this.update_in(cx, |this, window, cx| {
89 this.delegate.models = models.ok();
90 this.delegate.selected_model = selected_model.ok();
91 this.refresh(window, cx)
92 })
93 }
94
95 refresh(&this, cx).await.log_err();
96 if let Some(mut rx) = rx {
97 while let Ok(()) = rx.recv().await {
98 refresh(&this, cx).await.log_err();
99 }
100 }
101 }
102 })
103 };
104
105 Self {
106 selector,
107 agent_server,
108 fs,
109 filtered_entries: Vec::new(),
110 models: None,
111 selected_model: None,
112 selected_index: 0,
113 selected_description: None,
114 _refresh_models_task: refresh_models_task,
115 focus_handle,
116 }
117 }
118
119 pub fn active_model(&self) -> Option<&AgentModelInfo> {
120 self.selected_model.as_ref()
121 }
122
123 pub fn cycle_favorite_models(&mut self, window: &mut Window, cx: &mut Context<Picker<Self>>) {
124 if !self.selector.supports_favorites() {
125 return;
126 }
127
128 let favorites = AgentSettings::get_global(cx).favorite_model_ids();
129
130 if favorites.is_empty() {
131 return;
132 }
133
134 let Some(models) = self.models.clone() else {
135 return;
136 };
137
138 let all_models: Vec<AgentModelInfo> = match models {
139 AgentModelList::Flat(list) => list,
140 AgentModelList::Grouped(index_map) => index_map
141 .into_values()
142 .flatten()
143 .collect::<Vec<AgentModelInfo>>(),
144 };
145
146 let favorite_models = all_models
147 .iter()
148 .filter(|model| favorites.contains(&model.id))
149 .unique_by(|model| &model.id)
150 .cloned()
151 .collect::<Vec<_>>();
152
153 let current_id = self.selected_model.as_ref().map(|m| m.id.clone());
154
155 let current_index_in_favorites = current_id
156 .as_ref()
157 .and_then(|id| favorite_models.iter().position(|m| &m.id == id))
158 .unwrap_or(usize::MAX);
159
160 let next_index = if current_index_in_favorites == usize::MAX {
161 0
162 } else {
163 (current_index_in_favorites + 1) % favorite_models.len()
164 };
165
166 let next_model = favorite_models[next_index].clone();
167
168 self.selector
169 .select_model(next_model.id.clone(), cx)
170 .detach_and_log_err(cx);
171
172 self.selected_model = Some(next_model);
173
174 // Keep the picker selection aligned with the newly-selected model
175 if let Some(new_index) = self.filtered_entries.iter().position(|entry| {
176 matches!(entry, AcpModelPickerEntry::Model(model_info, _) if self.selected_model.as_ref().is_some_and(|selected| model_info.id == selected.id))
177 }) {
178 self.set_selected_index(new_index, window, cx);
179 } else {
180 cx.notify();
181 }
182 }
183}
184
185impl PickerDelegate for AcpModelPickerDelegate {
186 type ListItem = AnyElement;
187
188 fn match_count(&self) -> usize {
189 self.filtered_entries.len()
190 }
191
192 fn selected_index(&self) -> usize {
193 self.selected_index
194 }
195
196 fn set_selected_index(&mut self, ix: usize, _: &mut Window, cx: &mut Context<Picker<Self>>) {
197 self.selected_index = ix.min(self.filtered_entries.len().saturating_sub(1));
198 cx.notify();
199 }
200
201 fn can_select(
202 &mut self,
203 ix: usize,
204 _window: &mut Window,
205 _cx: &mut Context<Picker<Self>>,
206 ) -> bool {
207 match self.filtered_entries.get(ix) {
208 Some(AcpModelPickerEntry::Model(_, _)) => true,
209 Some(AcpModelPickerEntry::Separator(_)) | None => false,
210 }
211 }
212
213 fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
214 "Select a model…".into()
215 }
216
217 fn update_matches(
218 &mut self,
219 query: String,
220 window: &mut Window,
221 cx: &mut Context<Picker<Self>>,
222 ) -> Task<()> {
223 let favorites = if self.selector.supports_favorites() {
224 Arc::new(AgentSettings::get_global(cx).favorite_model_ids())
225 } else {
226 Default::default()
227 };
228
229 cx.spawn_in(window, async move |this, cx| {
230 let filtered_models = match this
231 .read_with(cx, |this, cx| {
232 this.delegate.models.clone().map(move |models| {
233 fuzzy_search(models, query, cx.background_executor().clone())
234 })
235 })
236 .ok()
237 .flatten()
238 {
239 Some(task) => task.await,
240 None => AgentModelList::Flat(vec![]),
241 };
242
243 this.update_in(cx, |this, window, cx| {
244 this.delegate.filtered_entries =
245 info_list_to_picker_entries(filtered_models, favorites);
246 // Finds the currently selected model in the list
247 let new_index = this
248 .delegate
249 .selected_model
250 .as_ref()
251 .and_then(|selected| {
252 this.delegate.filtered_entries.iter().position(|entry| {
253 if let AcpModelPickerEntry::Model(model_info, _) = entry {
254 model_info.id == selected.id
255 } else {
256 false
257 }
258 })
259 })
260 .unwrap_or(0);
261 this.set_selected_index(new_index, Some(picker::Direction::Down), true, window, cx);
262 cx.notify();
263 })
264 .ok();
265 })
266 }
267
268 fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
269 if let Some(AcpModelPickerEntry::Model(model_info, _)) =
270 self.filtered_entries.get(self.selected_index)
271 {
272 if window.modifiers().secondary() {
273 let default_model = self.agent_server.default_model(cx);
274 let is_default = default_model.as_ref() == Some(&model_info.id);
275
276 self.agent_server.set_default_model(
277 if is_default {
278 None
279 } else {
280 Some(model_info.id.clone())
281 },
282 self.fs.clone(),
283 cx,
284 );
285 }
286
287 self.selector
288 .select_model(model_info.id.clone(), cx)
289 .detach_and_log_err(cx);
290 self.selected_model = Some(model_info.clone());
291 let current_index = self.selected_index;
292 self.set_selected_index(current_index, window, cx);
293
294 cx.emit(DismissEvent);
295 }
296 }
297
298 fn dismissed(&mut self, window: &mut Window, cx: &mut Context<Picker<Self>>) {
299 cx.defer_in(window, |picker, window, cx| {
300 picker.set_query("", window, cx);
301 });
302 }
303
304 fn render_match(
305 &self,
306 ix: usize,
307 selected: bool,
308 _: &mut Window,
309 cx: &mut Context<Picker<Self>>,
310 ) -> Option<Self::ListItem> {
311 match self.filtered_entries.get(ix)? {
312 AcpModelPickerEntry::Separator(title) => {
313 Some(ModelSelectorHeader::new(title, ix > 1).into_any_element())
314 }
315 AcpModelPickerEntry::Model(model_info, is_favorite) => {
316 let is_selected = Some(model_info) == self.selected_model.as_ref();
317 let default_model = self.agent_server.default_model(cx);
318 let is_default = default_model.as_ref() == Some(&model_info.id);
319
320 let supports_favorites = self.selector.supports_favorites();
321
322 let is_favorite = *is_favorite;
323 let handle_action_click = {
324 let model_id = model_info.id.clone();
325 let fs = self.fs.clone();
326
327 move |cx: &App| {
328 crate::favorite_models::toggle_model_id_in_settings(
329 model_id.clone(),
330 !is_favorite,
331 fs.clone(),
332 cx,
333 );
334 }
335 };
336
337 Some(
338 div()
339 .id(("model-picker-menu-child", ix))
340 .when_some(model_info.description.clone(), |this, description| {
341 this.on_hover(cx.listener(move |menu, hovered, _, cx| {
342 if *hovered {
343 menu.delegate.selected_description =
344 Some((ix, description.clone(), is_default));
345 } else if matches!(menu.delegate.selected_description, Some((id, _, _)) if id == ix) {
346 menu.delegate.selected_description = None;
347 }
348 cx.notify();
349 }))
350 })
351 .child(
352 ModelSelectorListItem::new(ix, model_info.name.clone())
353 .when_some(model_info.icon, |this, icon| this.icon(icon))
354 .is_selected(is_selected)
355 .is_focused(selected)
356 .when(supports_favorites, |this| {
357 this.is_favorite(is_favorite)
358 .on_toggle_favorite(handle_action_click)
359 }),
360 )
361 .into_any_element(),
362 )
363 }
364 }
365 }
366
367 fn documentation_aside(
368 &self,
369 _window: &mut Window,
370 _cx: &mut Context<Picker<Self>>,
371 ) -> Option<ui::DocumentationAside> {
372 self.selected_description
373 .as_ref()
374 .map(|(_, description, is_default)| {
375 let description = description.clone();
376 let is_default = *is_default;
377
378 DocumentationAside::new(
379 DocumentationSide::Left,
380 DocumentationEdge::Top,
381 Rc::new(move |_| {
382 v_flex()
383 .gap_1()
384 .child(Label::new(description.clone()))
385 .child(HoldForDefault::new(is_default))
386 .into_any_element()
387 }),
388 )
389 })
390 }
391
392 fn render_footer(
393 &self,
394 _window: &mut Window,
395 _cx: &mut Context<Picker<Self>>,
396 ) -> Option<AnyElement> {
397 let focus_handle = self.focus_handle.clone();
398
399 if !self.selector.should_render_footer() {
400 return None;
401 }
402
403 Some(ModelSelectorFooter::new(OpenSettings.boxed_clone(), focus_handle).into_any_element())
404 }
405}
406
407fn info_list_to_picker_entries(
408 model_list: AgentModelList,
409 favorites: Arc<HashSet<ModelId>>,
410) -> Vec<AcpModelPickerEntry> {
411 let mut entries = Vec::new();
412
413 let all_models: Vec<_> = match &model_list {
414 AgentModelList::Flat(list) => list.iter().collect(),
415 AgentModelList::Grouped(index_map) => index_map.values().flatten().collect(),
416 };
417
418 let favorite_models: Vec<_> = all_models
419 .iter()
420 .filter(|m| favorites.contains(&m.id))
421 .unique_by(|m| &m.id)
422 .collect();
423
424 let has_favorites = !favorite_models.is_empty();
425 if has_favorites {
426 entries.push(AcpModelPickerEntry::Separator("Favorite".into()));
427 for model in favorite_models {
428 entries.push(AcpModelPickerEntry::Model((*model).clone(), true));
429 }
430 }
431
432 match model_list {
433 AgentModelList::Flat(list) => {
434 if has_favorites {
435 entries.push(AcpModelPickerEntry::Separator("All".into()));
436 }
437 for model in list {
438 let is_favorite = favorites.contains(&model.id);
439 entries.push(AcpModelPickerEntry::Model(model, is_favorite));
440 }
441 }
442 AgentModelList::Grouped(index_map) => {
443 for (group_name, models) in index_map {
444 entries.push(AcpModelPickerEntry::Separator(group_name.0));
445 for model in models {
446 let is_favorite = favorites.contains(&model.id);
447 entries.push(AcpModelPickerEntry::Model(model, is_favorite));
448 }
449 }
450 }
451 }
452
453 entries
454}
455
456async fn fuzzy_search(
457 model_list: AgentModelList,
458 query: String,
459 executor: BackgroundExecutor,
460) -> AgentModelList {
461 async fn fuzzy_search_list(
462 model_list: Vec<AgentModelInfo>,
463 query: &str,
464 executor: BackgroundExecutor,
465 ) -> Vec<AgentModelInfo> {
466 let candidates = model_list
467 .iter()
468 .enumerate()
469 .map(|(ix, model)| StringMatchCandidate::new(ix, model.name.as_ref()))
470 .collect::<Vec<_>>();
471 let mut matches = match_strings(
472 &candidates,
473 query,
474 false,
475 true,
476 100,
477 &Default::default(),
478 executor,
479 )
480 .await;
481
482 matches.sort_unstable_by_key(|mat| {
483 let candidate = &candidates[mat.candidate_id];
484 (Reverse(OrderedFloat(mat.score)), candidate.id)
485 });
486
487 matches
488 .into_iter()
489 .map(|mat| model_list[mat.candidate_id].clone())
490 .collect()
491 }
492
493 match model_list {
494 AgentModelList::Flat(model_list) => {
495 AgentModelList::Flat(fuzzy_search_list(model_list, &query, executor).await)
496 }
497 AgentModelList::Grouped(index_map) => {
498 let groups =
499 futures::future::join_all(index_map.into_iter().map(|(group_name, models)| {
500 fuzzy_search_list(models, &query, executor.clone())
501 .map(|results| (group_name, results))
502 }))
503 .await;
504 AgentModelList::Grouped(IndexMap::from_iter(
505 groups
506 .into_iter()
507 .filter(|(_, results)| !results.is_empty()),
508 ))
509 }
510 }
511}
512
513#[cfg(test)]
514mod tests {
515 use agent_client_protocol as acp;
516 use gpui::TestAppContext;
517
518 use super::*;
519
520 fn create_model_list(grouped_models: Vec<(&str, Vec<&str>)>) -> AgentModelList {
521 AgentModelList::Grouped(IndexMap::from_iter(grouped_models.into_iter().map(
522 |(group, models)| {
523 (
524 acp_thread::AgentModelGroupName(group.to_string().into()),
525 models
526 .into_iter()
527 .map(|model| acp_thread::AgentModelInfo {
528 id: acp::ModelId::new(model.to_string()),
529 name: model.to_string().into(),
530 description: None,
531 icon: None,
532 })
533 .collect::<Vec<_>>(),
534 )
535 },
536 )))
537 }
538
539 fn assert_models_eq(result: AgentModelList, expected: Vec<(&str, Vec<&str>)>) {
540 let AgentModelList::Grouped(groups) = result else {
541 panic!("Expected LanguageModelInfoList::Grouped, got {:?}", result);
542 };
543
544 assert_eq!(
545 groups.len(),
546 expected.len(),
547 "Number of groups doesn't match"
548 );
549
550 for (i, (expected_group, expected_models)) in expected.iter().enumerate() {
551 let (actual_group, actual_models) = groups.get_index(i).unwrap();
552 assert_eq!(
553 actual_group.0.as_ref(),
554 *expected_group,
555 "Group at position {} doesn't match expected group",
556 i
557 );
558 assert_eq!(
559 actual_models.len(),
560 expected_models.len(),
561 "Number of models in group {} doesn't match",
562 expected_group
563 );
564
565 for (j, expected_model_name) in expected_models.iter().enumerate() {
566 assert_eq!(
567 actual_models[j].name, *expected_model_name,
568 "Model at position {} in group {} doesn't match expected model",
569 j, expected_group
570 );
571 }
572 }
573 }
574
575 fn create_favorites(models: Vec<&str>) -> Arc<HashSet<ModelId>> {
576 Arc::new(
577 models
578 .into_iter()
579 .map(|m| ModelId::new(m.to_string()))
580 .collect(),
581 )
582 }
583
584 fn get_entry_model_ids(entries: &[AcpModelPickerEntry]) -> Vec<&str> {
585 entries
586 .iter()
587 .filter_map(|entry| match entry {
588 AcpModelPickerEntry::Model(info, _) => Some(info.id.0.as_ref()),
589 _ => None,
590 })
591 .collect()
592 }
593
594 fn get_entry_labels(entries: &[AcpModelPickerEntry]) -> Vec<&str> {
595 entries
596 .iter()
597 .map(|entry| match entry {
598 AcpModelPickerEntry::Model(info, _) => info.id.0.as_ref(),
599 AcpModelPickerEntry::Separator(s) => &s,
600 })
601 .collect()
602 }
603
604 #[gpui::test]
605 fn test_favorites_section_appears_when_favorites_exist(_cx: &mut TestAppContext) {
606 let models = create_model_list(vec![
607 ("zed", vec!["zed/claude", "zed/gemini"]),
608 ("openai", vec!["openai/gpt-5"]),
609 ]);
610 let favorites = create_favorites(vec!["zed/gemini"]);
611
612 let entries = info_list_to_picker_entries(models, favorites);
613
614 assert!(matches!(
615 entries.first(),
616 Some(AcpModelPickerEntry::Separator(s)) if s == "Favorite"
617 ));
618
619 let model_ids = get_entry_model_ids(&entries);
620 assert_eq!(model_ids[0], "zed/gemini");
621 }
622
623 #[gpui::test]
624 fn test_no_favorites_section_when_no_favorites(_cx: &mut TestAppContext) {
625 let models = create_model_list(vec![("zed", vec!["zed/claude", "zed/gemini"])]);
626 let favorites = create_favorites(vec![]);
627
628 let entries = info_list_to_picker_entries(models, favorites);
629
630 assert!(matches!(
631 entries.first(),
632 Some(AcpModelPickerEntry::Separator(s)) if s == "zed"
633 ));
634 }
635
636 #[gpui::test]
637 fn test_models_have_correct_actions(_cx: &mut TestAppContext) {
638 let models = create_model_list(vec![
639 ("zed", vec!["zed/claude", "zed/gemini"]),
640 ("openai", vec!["openai/gpt-5"]),
641 ]);
642 let favorites = create_favorites(vec!["zed/claude"]);
643
644 let entries = info_list_to_picker_entries(models, favorites);
645
646 for entry in &entries {
647 if let AcpModelPickerEntry::Model(info, is_favorite) = entry {
648 if info.id.0.as_ref() == "zed/claude" {
649 assert!(is_favorite, "zed/claude should be a favorite");
650 } else {
651 assert!(!is_favorite, "{} should not be a favorite", info.id.0);
652 }
653 }
654 }
655 }
656
657 #[gpui::test]
658 fn test_favorites_appear_in_both_sections(_cx: &mut TestAppContext) {
659 let models = create_model_list(vec![
660 ("zed", vec!["zed/claude", "zed/gemini"]),
661 ("openai", vec!["openai/gpt-5", "openai/gpt-4"]),
662 ]);
663 let favorites = create_favorites(vec!["zed/gemini", "openai/gpt-5"]);
664
665 let entries = info_list_to_picker_entries(models, favorites);
666 let model_ids = get_entry_model_ids(&entries);
667
668 assert_eq!(model_ids[0], "zed/gemini");
669 assert_eq!(model_ids[1], "openai/gpt-5");
670
671 assert!(model_ids[2..].contains(&"zed/gemini"));
672 assert!(model_ids[2..].contains(&"openai/gpt-5"));
673 }
674
675 #[gpui::test]
676 fn test_favorites_are_not_duplicated_when_repeated_in_other_sections(_cx: &mut TestAppContext) {
677 let models = create_model_list(vec![
678 ("Recommended", vec!["zed/claude", "anthropic/claude"]),
679 ("Zed", vec!["zed/claude", "zed/gpt-5"]),
680 ("Antropic", vec!["anthropic/claude"]),
681 ("OpenAI", vec!["openai/gpt-5"]),
682 ]);
683
684 let favorites = create_favorites(vec!["zed/claude"]);
685
686 let entries = info_list_to_picker_entries(models, favorites);
687 let labels = get_entry_labels(&entries);
688
689 assert_eq!(
690 labels,
691 vec![
692 "Favorite",
693 "zed/claude",
694 "Recommended",
695 "zed/claude",
696 "anthropic/claude",
697 "Zed",
698 "zed/claude",
699 "zed/gpt-5",
700 "Antropic",
701 "anthropic/claude",
702 "OpenAI",
703 "openai/gpt-5"
704 ]
705 );
706 }
707
708 #[gpui::test]
709 fn test_flat_model_list_with_favorites(_cx: &mut TestAppContext) {
710 let models = AgentModelList::Flat(vec![
711 acp_thread::AgentModelInfo {
712 id: acp::ModelId::new("zed/claude".to_string()),
713 name: "Claude".into(),
714 description: None,
715 icon: None,
716 },
717 acp_thread::AgentModelInfo {
718 id: acp::ModelId::new("zed/gemini".to_string()),
719 name: "Gemini".into(),
720 description: None,
721 icon: None,
722 },
723 ]);
724 let favorites = create_favorites(vec!["zed/gemini"]);
725
726 let entries = info_list_to_picker_entries(models, favorites);
727
728 assert!(matches!(
729 entries.first(),
730 Some(AcpModelPickerEntry::Separator(s)) if s == "Favorite"
731 ));
732
733 assert!(entries.iter().any(|e| matches!(
734 e,
735 AcpModelPickerEntry::Separator(s) if s == "All"
736 )));
737 }
738
739 #[gpui::test]
740 async fn test_fuzzy_match(cx: &mut TestAppContext) {
741 let models = create_model_list(vec![
742 (
743 "zed",
744 vec![
745 "Claude 3.7 Sonnet",
746 "Claude 3.7 Sonnet Thinking",
747 "gpt-4.1",
748 "gpt-4.1-nano",
749 ],
750 ),
751 ("openai", vec!["gpt-3.5-turbo", "gpt-4.1", "gpt-4.1-nano"]),
752 ("ollama", vec!["mistral", "deepseek"]),
753 ]);
754
755 // Results should preserve models order whenever possible.
756 // In the case below, `zed/gpt-4.1` and `openai/gpt-4.1` have identical
757 // similarity scores, but `zed/gpt-4.1` was higher in the models list,
758 // so it should appear first in the results.
759 let results = fuzzy_search(models.clone(), "41".into(), cx.executor()).await;
760 assert_models_eq(
761 results,
762 vec![
763 ("zed", vec!["gpt-4.1", "gpt-4.1-nano"]),
764 ("openai", vec!["gpt-4.1", "gpt-4.1-nano"]),
765 ],
766 );
767
768 // Fuzzy search
769 let results = fuzzy_search(models.clone(), "4n".into(), cx.executor()).await;
770 assert_models_eq(
771 results,
772 vec![
773 ("zed", vec!["gpt-4.1-nano"]),
774 ("openai", vec!["gpt-4.1-nano"]),
775 ],
776 );
777 }
778}