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 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: &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>) -> HashSet<ModelId> {
576 models
577 .into_iter()
578 .map(|m| ModelId::new(m.to_string()))
579 .collect()
580 }
581
582 fn get_entry_model_ids(entries: &[AcpModelPickerEntry]) -> Vec<&str> {
583 entries
584 .iter()
585 .filter_map(|entry| match entry {
586 AcpModelPickerEntry::Model(info, _) => Some(info.id.0.as_ref()),
587 _ => None,
588 })
589 .collect()
590 }
591
592 fn get_entry_labels(entries: &[AcpModelPickerEntry]) -> Vec<&str> {
593 entries
594 .iter()
595 .map(|entry| match entry {
596 AcpModelPickerEntry::Model(info, _) => info.id.0.as_ref(),
597 AcpModelPickerEntry::Separator(s) => &s,
598 })
599 .collect()
600 }
601
602 #[gpui::test]
603 fn test_favorites_section_appears_when_favorites_exist(_cx: &mut TestAppContext) {
604 let models = create_model_list(vec![
605 ("zed", vec!["zed/claude", "zed/gemini"]),
606 ("openai", vec!["openai/gpt-5"]),
607 ]);
608 let favorites = create_favorites(vec!["zed/gemini"]);
609
610 let entries = info_list_to_picker_entries(models, &favorites);
611
612 assert!(matches!(
613 entries.first(),
614 Some(AcpModelPickerEntry::Separator(s)) if s == "Favorite"
615 ));
616
617 let model_ids = get_entry_model_ids(&entries);
618 assert_eq!(model_ids[0], "zed/gemini");
619 }
620
621 #[gpui::test]
622 fn test_no_favorites_section_when_no_favorites(_cx: &mut TestAppContext) {
623 let models = create_model_list(vec![("zed", vec!["zed/claude", "zed/gemini"])]);
624 let favorites = create_favorites(vec![]);
625
626 let entries = info_list_to_picker_entries(models, &favorites);
627
628 assert!(matches!(
629 entries.first(),
630 Some(AcpModelPickerEntry::Separator(s)) if s == "zed"
631 ));
632 }
633
634 #[gpui::test]
635 fn test_models_have_correct_actions(_cx: &mut TestAppContext) {
636 let models = create_model_list(vec![
637 ("zed", vec!["zed/claude", "zed/gemini"]),
638 ("openai", vec!["openai/gpt-5"]),
639 ]);
640 let favorites = create_favorites(vec!["zed/claude"]);
641
642 let entries = info_list_to_picker_entries(models, &favorites);
643
644 for entry in &entries {
645 if let AcpModelPickerEntry::Model(info, is_favorite) = entry {
646 if info.id.0.as_ref() == "zed/claude" {
647 assert!(is_favorite, "zed/claude should be a favorite");
648 } else {
649 assert!(!is_favorite, "{} should not be a favorite", info.id.0);
650 }
651 }
652 }
653 }
654
655 #[gpui::test]
656 fn test_favorites_appear_in_both_sections(_cx: &mut TestAppContext) {
657 let models = create_model_list(vec![
658 ("zed", vec!["zed/claude", "zed/gemini"]),
659 ("openai", vec!["openai/gpt-5", "openai/gpt-4"]),
660 ]);
661 let favorites = create_favorites(vec!["zed/gemini", "openai/gpt-5"]);
662
663 let entries = info_list_to_picker_entries(models, &favorites);
664 let model_ids = get_entry_model_ids(&entries);
665
666 assert_eq!(model_ids[0], "zed/gemini");
667 assert_eq!(model_ids[1], "openai/gpt-5");
668
669 assert!(model_ids[2..].contains(&"zed/gemini"));
670 assert!(model_ids[2..].contains(&"openai/gpt-5"));
671 }
672
673 #[gpui::test]
674 fn test_favorites_are_not_duplicated_when_repeated_in_other_sections(_cx: &mut TestAppContext) {
675 let models = create_model_list(vec![
676 ("Recommended", vec!["zed/claude", "anthropic/claude"]),
677 ("Zed", vec!["zed/claude", "zed/gpt-5"]),
678 ("Antropic", vec!["anthropic/claude"]),
679 ("OpenAI", vec!["openai/gpt-5"]),
680 ]);
681
682 let favorites = create_favorites(vec!["zed/claude"]);
683
684 let entries = info_list_to_picker_entries(models, &favorites);
685 let labels = get_entry_labels(&entries);
686
687 assert_eq!(
688 labels,
689 vec![
690 "Favorite",
691 "zed/claude",
692 "Recommended",
693 "zed/claude",
694 "anthropic/claude",
695 "Zed",
696 "zed/claude",
697 "zed/gpt-5",
698 "Antropic",
699 "anthropic/claude",
700 "OpenAI",
701 "openai/gpt-5"
702 ]
703 );
704 }
705
706 #[gpui::test]
707 fn test_flat_model_list_with_favorites(_cx: &mut TestAppContext) {
708 let models = AgentModelList::Flat(vec![
709 acp_thread::AgentModelInfo {
710 id: acp::ModelId::new("zed/claude".to_string()),
711 name: "Claude".into(),
712 description: None,
713 icon: None,
714 },
715 acp_thread::AgentModelInfo {
716 id: acp::ModelId::new("zed/gemini".to_string()),
717 name: "Gemini".into(),
718 description: None,
719 icon: None,
720 },
721 ]);
722 let favorites = create_favorites(vec!["zed/gemini"]);
723
724 let entries = info_list_to_picker_entries(models, &favorites);
725
726 assert!(matches!(
727 entries.first(),
728 Some(AcpModelPickerEntry::Separator(s)) if s == "Favorite"
729 ));
730
731 assert!(entries.iter().any(|e| matches!(
732 e,
733 AcpModelPickerEntry::Separator(s) if s == "All"
734 )));
735 }
736
737 #[gpui::test]
738 async fn test_fuzzy_match(cx: &mut TestAppContext) {
739 let models = create_model_list(vec![
740 (
741 "zed",
742 vec![
743 "Claude 3.7 Sonnet",
744 "Claude 3.7 Sonnet Thinking",
745 "gpt-4.1",
746 "gpt-4.1-nano",
747 ],
748 ),
749 ("openai", vec!["gpt-3.5-turbo", "gpt-4.1", "gpt-4.1-nano"]),
750 ("ollama", vec!["mistral", "deepseek"]),
751 ]);
752
753 // Results should preserve models order whenever possible.
754 // In the case below, `zed/gpt-4.1` and `openai/gpt-4.1` have identical
755 // similarity scores, but `zed/gpt-4.1` was higher in the models list,
756 // so it should appear first in the results.
757 let results = fuzzy_search(models.clone(), "41".into(), cx.executor()).await;
758 assert_models_eq(
759 results,
760 vec![
761 ("zed", vec!["gpt-4.1", "gpt-4.1-nano"]),
762 ("openai", vec!["gpt-4.1", "gpt-4.1-nano"]),
763 ],
764 );
765
766 // Fuzzy search
767 let results = fuzzy_search(models.clone(), "4n".into(), cx.executor()).await;
768 assert_models_eq(
769 results,
770 vec![
771 ("zed", vec!["gpt-4.1-nano"]),
772 ("openai", vec!["gpt-4.1-nano"]),
773 ],
774 );
775 }
776}