1use std::{cmp::Reverse, sync::Arc};
2
3use collections::{HashSet, IndexMap};
4use feature_flags::ZedProFeatureFlag;
5use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
6use gpui::{
7 Action, AnyElement, App, BackgroundExecutor, DismissEvent, Subscription, Task,
8 action_with_deprecated_aliases,
9};
10use language_model::{
11 AuthenticateError, ConfiguredModel, LanguageModel, LanguageModelProviderId,
12 LanguageModelRegistry,
13};
14use ordered_float::OrderedFloat;
15use picker::{Picker, PickerDelegate};
16use proto::Plan;
17use ui::{ListItem, ListItemSpacing, prelude::*};
18
19action_with_deprecated_aliases!(
20 agent,
21 ToggleModelSelector,
22 [
23 "assistant::ToggleModelSelector",
24 "assistant2::ToggleModelSelector"
25 ]
26);
27
28const TRY_ZED_PRO_URL: &str = "https://zed.dev/pro";
29
30type OnModelChanged = Arc<dyn Fn(Arc<dyn LanguageModel>, &mut App) + 'static>;
31type GetActiveModel = Arc<dyn Fn(&App) -> Option<ConfiguredModel> + 'static>;
32
33pub type LanguageModelSelector = Picker<LanguageModelPickerDelegate>;
34
35pub fn language_model_selector(
36 get_active_model: impl Fn(&App) -> Option<ConfiguredModel> + 'static,
37 on_model_changed: impl Fn(Arc<dyn LanguageModel>, &mut App) + 'static,
38 window: &mut Window,
39 cx: &mut Context<LanguageModelSelector>,
40) -> LanguageModelSelector {
41 let delegate = LanguageModelPickerDelegate::new(get_active_model, on_model_changed, window, cx);
42 Picker::list(delegate, window, cx)
43 .show_scrollbar(true)
44 .width(rems(20.))
45 .max_height(Some(rems(20.).into()))
46}
47
48fn all_models(cx: &App) -> GroupedModels {
49 let providers = LanguageModelRegistry::global(cx).read(cx).providers();
50
51 let recommended = providers
52 .iter()
53 .flat_map(|provider| {
54 provider
55 .recommended_models(cx)
56 .into_iter()
57 .map(|model| ModelInfo {
58 model,
59 icon: provider.icon(),
60 })
61 })
62 .collect();
63
64 let other = providers
65 .iter()
66 .flat_map(|provider| {
67 provider
68 .provided_models(cx)
69 .into_iter()
70 .map(|model| ModelInfo {
71 model,
72 icon: provider.icon(),
73 })
74 })
75 .collect();
76
77 GroupedModels::new(other, recommended)
78}
79
80#[derive(Clone)]
81struct ModelInfo {
82 model: Arc<dyn LanguageModel>,
83 icon: IconName,
84}
85
86pub struct LanguageModelPickerDelegate {
87 on_model_changed: OnModelChanged,
88 get_active_model: GetActiveModel,
89 all_models: Arc<GroupedModels>,
90 filtered_entries: Vec<LanguageModelPickerEntry>,
91 selected_index: usize,
92 _authenticate_all_providers_task: Task<()>,
93 _subscriptions: Vec<Subscription>,
94}
95
96impl LanguageModelPickerDelegate {
97 fn new(
98 get_active_model: impl Fn(&App) -> Option<ConfiguredModel> + 'static,
99 on_model_changed: impl Fn(Arc<dyn LanguageModel>, &mut App) + 'static,
100 window: &mut Window,
101 cx: &mut Context<Picker<Self>>,
102 ) -> Self {
103 let on_model_changed = Arc::new(on_model_changed);
104 let models = all_models(cx);
105 let entries = models.entries();
106
107 Self {
108 on_model_changed: on_model_changed.clone(),
109 all_models: Arc::new(models),
110 selected_index: Self::get_active_model_index(&entries, get_active_model(cx)),
111 filtered_entries: entries,
112 get_active_model: Arc::new(get_active_model),
113 _authenticate_all_providers_task: Self::authenticate_all_providers(cx),
114 _subscriptions: vec![cx.subscribe_in(
115 &LanguageModelRegistry::global(cx),
116 window,
117 |picker, _, event, window, cx| {
118 match event {
119 language_model::Event::ProviderStateChanged
120 | language_model::Event::AddedProvider(_)
121 | language_model::Event::RemovedProvider(_) => {
122 let query = picker.query(cx);
123 picker.delegate.all_models = Arc::new(all_models(cx));
124 // Update matches will automatically drop the previous task
125 // if we get a provider event again
126 picker.update_matches(query, window, cx)
127 }
128 _ => {}
129 }
130 },
131 )],
132 }
133 }
134
135 fn get_active_model_index(
136 entries: &[LanguageModelPickerEntry],
137 active_model: Option<ConfiguredModel>,
138 ) -> usize {
139 entries
140 .iter()
141 .position(|entry| {
142 if let LanguageModelPickerEntry::Model(model) = entry {
143 active_model
144 .as_ref()
145 .map(|active_model| {
146 active_model.model.id() == model.model.id()
147 && active_model.provider.id() == model.model.provider_id()
148 })
149 .unwrap_or_default()
150 } else {
151 false
152 }
153 })
154 .unwrap_or(0)
155 }
156
157 /// Authenticates all providers in the [`LanguageModelRegistry`].
158 ///
159 /// We do this so that we can populate the language selector with all of the
160 /// models from the configured providers.
161 fn authenticate_all_providers(cx: &mut App) -> Task<()> {
162 let authenticate_all_providers = LanguageModelRegistry::global(cx)
163 .read(cx)
164 .providers()
165 .iter()
166 .map(|provider| (provider.id(), provider.name(), provider.authenticate(cx)))
167 .collect::<Vec<_>>();
168
169 cx.spawn(async move |_cx| {
170 for (provider_id, provider_name, authenticate_task) in authenticate_all_providers {
171 if let Err(err) = authenticate_task.await {
172 if matches!(err, AuthenticateError::CredentialsNotFound) {
173 // Since we're authenticating these providers in the
174 // background for the purposes of populating the
175 // language selector, we don't care about providers
176 // where the credentials are not found.
177 } else {
178 // Some providers have noisy failure states that we
179 // don't want to spam the logs with every time the
180 // language model selector is initialized.
181 //
182 // Ideally these should have more clear failure modes
183 // that we know are safe to ignore here, like what we do
184 // with `CredentialsNotFound` above.
185 match provider_id.0.as_ref() {
186 "lmstudio" | "ollama" => {
187 // LM Studio and Ollama both make fetch requests to the local APIs to determine if they are "authenticated".
188 //
189 // These fail noisily, so we don't log them.
190 }
191 "copilot_chat" => {
192 // Copilot Chat returns an error if Copilot is not enabled, so we don't log those errors.
193 }
194 _ => {
195 log::error!(
196 "Failed to authenticate provider: {}: {err}",
197 provider_name.0
198 );
199 }
200 }
201 }
202 }
203 }
204 })
205 }
206
207 pub fn active_model(&self, cx: &App) -> Option<ConfiguredModel> {
208 (self.get_active_model)(cx)
209 }
210}
211
212struct GroupedModels {
213 recommended: Vec<ModelInfo>,
214 other: IndexMap<LanguageModelProviderId, Vec<ModelInfo>>,
215}
216
217impl GroupedModels {
218 pub fn new(other: Vec<ModelInfo>, recommended: Vec<ModelInfo>) -> Self {
219 let recommended_ids = recommended
220 .iter()
221 .map(|info| (info.model.provider_id(), info.model.id()))
222 .collect::<HashSet<_>>();
223
224 let mut other_by_provider: IndexMap<_, Vec<ModelInfo>> = IndexMap::default();
225 for model in other {
226 if recommended_ids.contains(&(model.model.provider_id(), model.model.id())) {
227 continue;
228 }
229
230 let provider = model.model.provider_id();
231 if let Some(models) = other_by_provider.get_mut(&provider) {
232 models.push(model);
233 } else {
234 other_by_provider.insert(provider, vec![model]);
235 }
236 }
237
238 Self {
239 recommended,
240 other: other_by_provider,
241 }
242 }
243
244 fn entries(&self) -> Vec<LanguageModelPickerEntry> {
245 let mut entries = Vec::new();
246
247 if !self.recommended.is_empty() {
248 entries.push(LanguageModelPickerEntry::Separator("Recommended".into()));
249 entries.extend(
250 self.recommended
251 .iter()
252 .map(|info| LanguageModelPickerEntry::Model(info.clone())),
253 );
254 }
255
256 for models in self.other.values() {
257 if models.is_empty() {
258 continue;
259 }
260 entries.push(LanguageModelPickerEntry::Separator(
261 models[0].model.provider_name().0,
262 ));
263 entries.extend(
264 models
265 .iter()
266 .map(|info| LanguageModelPickerEntry::Model(info.clone())),
267 );
268 }
269 entries
270 }
271
272 fn model_infos(&self) -> Vec<ModelInfo> {
273 let other = self
274 .other
275 .values()
276 .flat_map(|model| model.iter())
277 .cloned()
278 .collect::<Vec<_>>();
279 self.recommended
280 .iter()
281 .chain(&other)
282 .cloned()
283 .collect::<Vec<_>>()
284 }
285}
286
287enum LanguageModelPickerEntry {
288 Model(ModelInfo),
289 Separator(SharedString),
290}
291
292struct ModelMatcher {
293 models: Vec<ModelInfo>,
294 bg_executor: BackgroundExecutor,
295 candidates: Vec<StringMatchCandidate>,
296}
297
298impl ModelMatcher {
299 fn new(models: Vec<ModelInfo>, bg_executor: BackgroundExecutor) -> ModelMatcher {
300 let candidates = Self::make_match_candidates(&models);
301 Self {
302 models,
303 bg_executor,
304 candidates,
305 }
306 }
307
308 pub fn fuzzy_search(&self, query: &str) -> Vec<ModelInfo> {
309 let mut matches = self.bg_executor.block(match_strings(
310 &self.candidates,
311 &query,
312 false,
313 100,
314 &Default::default(),
315 self.bg_executor.clone(),
316 ));
317
318 let sorting_key = |mat: &StringMatch| {
319 let candidate = &self.candidates[mat.candidate_id];
320 (Reverse(OrderedFloat(mat.score)), candidate.id)
321 };
322 matches.sort_unstable_by_key(sorting_key);
323
324 let matched_models: Vec<_> = matches
325 .into_iter()
326 .map(|mat| self.models[mat.candidate_id].clone())
327 .collect();
328
329 matched_models
330 }
331
332 pub fn exact_search(&self, query: &str) -> Vec<ModelInfo> {
333 self.models
334 .iter()
335 .filter(|m| {
336 m.model
337 .name()
338 .0
339 .to_lowercase()
340 .contains(&query.to_lowercase())
341 })
342 .cloned()
343 .collect::<Vec<_>>()
344 }
345
346 fn make_match_candidates(model_infos: &Vec<ModelInfo>) -> Vec<StringMatchCandidate> {
347 model_infos
348 .iter()
349 .enumerate()
350 .map(|(index, model)| {
351 StringMatchCandidate::new(
352 index,
353 &format!(
354 "{}/{}",
355 &model.model.provider_name().0,
356 &model.model.name().0
357 ),
358 )
359 })
360 .collect::<Vec<_>>()
361 }
362}
363
364impl PickerDelegate for LanguageModelPickerDelegate {
365 type ListItem = AnyElement;
366
367 fn match_count(&self) -> usize {
368 self.filtered_entries.len()
369 }
370
371 fn selected_index(&self) -> usize {
372 self.selected_index
373 }
374
375 fn set_selected_index(&mut self, ix: usize, _: &mut Window, cx: &mut Context<Picker<Self>>) {
376 self.selected_index = ix.min(self.filtered_entries.len().saturating_sub(1));
377 cx.notify();
378 }
379
380 fn can_select(
381 &mut self,
382 ix: usize,
383 _window: &mut Window,
384 _cx: &mut Context<Picker<Self>>,
385 ) -> bool {
386 match self.filtered_entries.get(ix) {
387 Some(LanguageModelPickerEntry::Model(_)) => true,
388 Some(LanguageModelPickerEntry::Separator(_)) | None => false,
389 }
390 }
391
392 fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
393 "Select a model…".into()
394 }
395
396 fn update_matches(
397 &mut self,
398 query: String,
399 window: &mut Window,
400 cx: &mut Context<Picker<Self>>,
401 ) -> Task<()> {
402 let all_models = self.all_models.clone();
403 let current_index = self.selected_index;
404 let bg_executor = cx.background_executor();
405
406 let language_model_registry = LanguageModelRegistry::global(cx);
407
408 let configured_providers = language_model_registry
409 .read(cx)
410 .providers()
411 .into_iter()
412 .filter(|provider| provider.is_authenticated(cx))
413 .collect::<Vec<_>>();
414
415 let configured_provider_ids = configured_providers
416 .iter()
417 .map(|provider| provider.id())
418 .collect::<Vec<_>>();
419
420 let recommended_models = all_models
421 .recommended
422 .iter()
423 .filter(|m| configured_provider_ids.contains(&m.model.provider_id()))
424 .cloned()
425 .collect::<Vec<_>>();
426
427 let available_models = all_models
428 .model_infos()
429 .iter()
430 .filter(|m| configured_provider_ids.contains(&m.model.provider_id()))
431 .cloned()
432 .collect::<Vec<_>>();
433
434 let matcher_rec = ModelMatcher::new(recommended_models, bg_executor.clone());
435 let matcher_all = ModelMatcher::new(available_models, bg_executor.clone());
436
437 let recommended = matcher_rec.exact_search(&query);
438 let all = matcher_all.fuzzy_search(&query);
439
440 let filtered_models = GroupedModels::new(all, recommended);
441
442 cx.spawn_in(window, async move |this, cx| {
443 this.update_in(cx, |this, window, cx| {
444 this.delegate.filtered_entries = filtered_models.entries();
445 // Preserve selection focus
446 let new_index = if current_index >= this.delegate.filtered_entries.len() {
447 0
448 } else {
449 current_index
450 };
451 this.set_selected_index(new_index, Some(picker::Direction::Down), true, window, cx);
452 cx.notify();
453 })
454 .ok();
455 })
456 }
457
458 fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
459 if let Some(LanguageModelPickerEntry::Model(model_info)) =
460 self.filtered_entries.get(self.selected_index)
461 {
462 let model = model_info.model.clone();
463 (self.on_model_changed)(model.clone(), cx);
464
465 let current_index = self.selected_index;
466 self.set_selected_index(current_index, window, cx);
467
468 cx.emit(DismissEvent);
469 }
470 }
471
472 fn dismissed(&mut self, _: &mut Window, cx: &mut Context<Picker<Self>>) {
473 cx.emit(DismissEvent);
474 }
475
476 fn render_match(
477 &self,
478 ix: usize,
479 selected: bool,
480 _: &mut Window,
481 cx: &mut Context<Picker<Self>>,
482 ) -> Option<Self::ListItem> {
483 match self.filtered_entries.get(ix)? {
484 LanguageModelPickerEntry::Separator(title) => Some(
485 div()
486 .px_2()
487 .pb_1()
488 .when(ix > 1, |this| {
489 this.mt_1()
490 .pt_2()
491 .border_t_1()
492 .border_color(cx.theme().colors().border_variant)
493 })
494 .child(
495 Label::new(title)
496 .size(LabelSize::XSmall)
497 .color(Color::Muted),
498 )
499 .into_any_element(),
500 ),
501 LanguageModelPickerEntry::Model(model_info) => {
502 let active_model = (self.get_active_model)(cx);
503 let active_provider_id = active_model.as_ref().map(|m| m.provider.id());
504 let active_model_id = active_model.map(|m| m.model.id());
505
506 let is_selected = Some(model_info.model.provider_id()) == active_provider_id
507 && Some(model_info.model.id()) == active_model_id;
508
509 let model_icon_color = if is_selected {
510 Color::Accent
511 } else {
512 Color::Muted
513 };
514
515 Some(
516 ListItem::new(ix)
517 .inset(true)
518 .spacing(ListItemSpacing::Sparse)
519 .toggle_state(selected)
520 .start_slot(
521 Icon::new(model_info.icon)
522 .color(model_icon_color)
523 .size(IconSize::Small),
524 )
525 .child(
526 h_flex()
527 .w_full()
528 .pl_0p5()
529 .gap_1p5()
530 .w(px(240.))
531 .child(Label::new(model_info.model.name().0.clone()).truncate()),
532 )
533 .end_slot(div().pr_3().when(is_selected, |this| {
534 this.child(
535 Icon::new(IconName::Check)
536 .color(Color::Accent)
537 .size(IconSize::Small),
538 )
539 }))
540 .into_any_element(),
541 )
542 }
543 }
544 }
545
546 fn render_footer(
547 &self,
548 _: &mut Window,
549 cx: &mut Context<Picker<Self>>,
550 ) -> Option<gpui::AnyElement> {
551 use feature_flags::FeatureFlagAppExt;
552
553 let plan = proto::Plan::ZedPro;
554
555 Some(
556 h_flex()
557 .w_full()
558 .border_t_1()
559 .border_color(cx.theme().colors().border_variant)
560 .p_1()
561 .gap_4()
562 .justify_between()
563 .when(cx.has_flag::<ZedProFeatureFlag>(), |this| {
564 this.child(match plan {
565 Plan::ZedPro => Button::new("zed-pro", "Zed Pro")
566 .icon(IconName::ZedAssistant)
567 .icon_size(IconSize::Small)
568 .icon_color(Color::Muted)
569 .icon_position(IconPosition::Start)
570 .on_click(|_, window, cx| {
571 window
572 .dispatch_action(Box::new(zed_actions::OpenAccountSettings), cx)
573 }),
574 Plan::Free | Plan::ZedProTrial => Button::new(
575 "try-pro",
576 if plan == Plan::ZedProTrial {
577 "Upgrade to Pro"
578 } else {
579 "Try Pro"
580 },
581 )
582 .on_click(|_, _, cx| cx.open_url(TRY_ZED_PRO_URL)),
583 })
584 })
585 .child(
586 Button::new("configure", "Configure")
587 .icon(IconName::Settings)
588 .icon_size(IconSize::Small)
589 .icon_color(Color::Muted)
590 .icon_position(IconPosition::Start)
591 .on_click(|_, window, cx| {
592 window.dispatch_action(
593 zed_actions::agent::OpenConfiguration.boxed_clone(),
594 cx,
595 );
596 }),
597 )
598 .into_any(),
599 )
600 }
601}
602
603#[cfg(test)]
604mod tests {
605 use super::*;
606 use futures::{future::BoxFuture, stream::BoxStream};
607 use gpui::{AsyncApp, TestAppContext, http_client};
608 use language_model::{
609 LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId,
610 LanguageModelName, LanguageModelProviderId, LanguageModelProviderName,
611 LanguageModelRequest, LanguageModelToolChoice,
612 };
613 use ui::IconName;
614
615 #[derive(Clone)]
616 struct TestLanguageModel {
617 name: LanguageModelName,
618 id: LanguageModelId,
619 provider_id: LanguageModelProviderId,
620 provider_name: LanguageModelProviderName,
621 }
622
623 impl TestLanguageModel {
624 fn new(name: &str, provider: &str) -> Self {
625 Self {
626 name: LanguageModelName::from(name.to_string()),
627 id: LanguageModelId::from(name.to_string()),
628 provider_id: LanguageModelProviderId::from(provider.to_string()),
629 provider_name: LanguageModelProviderName::from(provider.to_string()),
630 }
631 }
632 }
633
634 impl LanguageModel for TestLanguageModel {
635 fn id(&self) -> LanguageModelId {
636 self.id.clone()
637 }
638
639 fn name(&self) -> LanguageModelName {
640 self.name.clone()
641 }
642
643 fn provider_id(&self) -> LanguageModelProviderId {
644 self.provider_id.clone()
645 }
646
647 fn provider_name(&self) -> LanguageModelProviderName {
648 self.provider_name.clone()
649 }
650
651 fn supports_tools(&self) -> bool {
652 false
653 }
654
655 fn supports_tool_choice(&self, _choice: LanguageModelToolChoice) -> bool {
656 false
657 }
658
659 fn supports_images(&self) -> bool {
660 false
661 }
662
663 fn telemetry_id(&self) -> String {
664 format!("{}/{}", self.provider_id.0, self.name.0)
665 }
666
667 fn max_token_count(&self) -> usize {
668 1000
669 }
670
671 fn count_tokens(
672 &self,
673 _: LanguageModelRequest,
674 _: &App,
675 ) -> BoxFuture<'static, http_client::Result<usize>> {
676 unimplemented!()
677 }
678
679 fn stream_completion(
680 &self,
681 _: LanguageModelRequest,
682 _: &AsyncApp,
683 ) -> BoxFuture<
684 'static,
685 http_client::Result<
686 BoxStream<
687 'static,
688 http_client::Result<LanguageModelCompletionEvent, LanguageModelCompletionError>,
689 >,
690 >,
691 > {
692 unimplemented!()
693 }
694 }
695
696 fn create_models(model_specs: Vec<(&str, &str)>) -> Vec<ModelInfo> {
697 model_specs
698 .into_iter()
699 .map(|(provider, name)| ModelInfo {
700 model: Arc::new(TestLanguageModel::new(name, provider)),
701 icon: IconName::Ai,
702 })
703 .collect()
704 }
705
706 fn assert_models_eq(result: Vec<ModelInfo>, expected: Vec<&str>) {
707 assert_eq!(
708 result.len(),
709 expected.len(),
710 "Number of models doesn't match"
711 );
712
713 for (i, expected_name) in expected.iter().enumerate() {
714 assert_eq!(
715 result[i].model.telemetry_id(),
716 *expected_name,
717 "Model at position {} doesn't match expected model",
718 i
719 );
720 }
721 }
722
723 #[gpui::test]
724 fn test_exact_match(cx: &mut TestAppContext) {
725 let models = create_models(vec![
726 ("zed", "Claude 3.7 Sonnet"),
727 ("zed", "Claude 3.7 Sonnet Thinking"),
728 ("zed", "gpt-4.1"),
729 ("zed", "gpt-4.1-nano"),
730 ("openai", "gpt-3.5-turbo"),
731 ("openai", "gpt-4.1"),
732 ("openai", "gpt-4.1-nano"),
733 ("ollama", "mistral"),
734 ("ollama", "deepseek"),
735 ]);
736 let matcher = ModelMatcher::new(models, cx.background_executor.clone());
737
738 // The order of models should be maintained, case doesn't matter
739 let results = matcher.exact_search("GPT-4.1");
740 assert_models_eq(
741 results,
742 vec![
743 "zed/gpt-4.1",
744 "zed/gpt-4.1-nano",
745 "openai/gpt-4.1",
746 "openai/gpt-4.1-nano",
747 ],
748 );
749 }
750
751 #[gpui::test]
752 fn test_fuzzy_match(cx: &mut TestAppContext) {
753 let models = create_models(vec![
754 ("zed", "Claude 3.7 Sonnet"),
755 ("zed", "Claude 3.7 Sonnet Thinking"),
756 ("zed", "gpt-4.1"),
757 ("zed", "gpt-4.1-nano"),
758 ("openai", "gpt-3.5-turbo"),
759 ("openai", "gpt-4.1"),
760 ("openai", "gpt-4.1-nano"),
761 ("ollama", "mistral"),
762 ("ollama", "deepseek"),
763 ]);
764 let matcher = ModelMatcher::new(models, cx.background_executor.clone());
765
766 // Results should preserve models order whenever possible.
767 // In the case below, `zed/gpt-4.1` and `openai/gpt-4.1` have identical
768 // similarity scores, but `zed/gpt-4.1` was higher in the models list,
769 // so it should appear first in the results.
770 let results = matcher.fuzzy_search("41");
771 assert_models_eq(
772 results,
773 vec![
774 "zed/gpt-4.1",
775 "openai/gpt-4.1",
776 "zed/gpt-4.1-nano",
777 "openai/gpt-4.1-nano",
778 ],
779 );
780
781 // Model provider should be searchable as well
782 let results = matcher.fuzzy_search("ol"); // meaning "ollama"
783 assert_models_eq(results, vec!["ollama/mistral", "ollama/deepseek"]);
784
785 // Fuzzy search
786 let results = matcher.fuzzy_search("z4n");
787 assert_models_eq(results, vec!["zed/gpt-4.1-nano"]);
788 }
789
790 #[gpui::test]
791 fn test_exclude_recommended_models(_cx: &mut TestAppContext) {
792 let recommended_models = create_models(vec![("zed", "claude")]);
793 let all_models = create_models(vec![
794 ("zed", "claude"), // Should be filtered out from "other"
795 ("zed", "gemini"),
796 ("copilot", "o3"),
797 ]);
798
799 let grouped_models = GroupedModels::new(all_models, recommended_models);
800
801 let actual_other_models = grouped_models
802 .other
803 .values()
804 .flatten()
805 .cloned()
806 .collect::<Vec<_>>();
807
808 // Recommended models should not appear in "other"
809 assert_models_eq(actual_other_models, vec!["zed/gemini", "copilot/o3"]);
810 }
811
812 #[gpui::test]
813 fn test_dont_exclude_models_from_other_providers(_cx: &mut TestAppContext) {
814 let recommended_models = create_models(vec![("zed", "claude")]);
815 let all_models = create_models(vec![
816 ("zed", "claude"), // Should be filtered out from "other"
817 ("zed", "gemini"),
818 ("copilot", "claude"), // Should not be filtered out from "other"
819 ]);
820
821 let grouped_models = GroupedModels::new(all_models, recommended_models);
822
823 let actual_other_models = grouped_models
824 .other
825 .values()
826 .flatten()
827 .cloned()
828 .collect::<Vec<_>>();
829
830 // Recommended models should not appear in "other"
831 assert_models_eq(actual_other_models, vec!["zed/gemini", "copilot/claude"]);
832 }
833}