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