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