Revert "ai: Auto select user model when there's no default" (zed-industries#36932)

bennetbo · tidely · commit 1f7fce88b31a · 2025-09-10T18:12:30.000+03:00
Reverts zed-industries#36722 Release Notes: - N/A
diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs
@@ -664,7 +664,7 @@ impl Thread {
     }
 
     pub fn get_or_init_configured_model(&mut self, cx: &App) -> Option<ConfiguredModel> {
-        if self.configured_model.is_none() || self.messages.is_empty() {
+        if self.configured_model.is_none() {
             self.configured_model = LanguageModelRegistry::read_global(cx).default_model();
         }
         self.configured_model.clone()
@@ -2097,7 +2097,7 @@ impl Thread {
     }
 
     pub fn summarize(&mut self, cx: &mut Context<Self>) {
-        let Some(model) = LanguageModelRegistry::read_global(cx).thread_summary_model(cx) else {
+        let Some(model) = LanguageModelRegistry::read_global(cx).thread_summary_model() else {
             println!("No thread summary model");
             return;
         };
@@ -2416,7 +2416,7 @@ impl Thread {
         }
 
         let Some(ConfiguredModel { model, provider }) =
-            LanguageModelRegistry::read_global(cx).thread_summary_model(cx)
+            LanguageModelRegistry::read_global(cx).thread_summary_model()
         else {
             return;
         };
@@ -5410,10 +5410,13 @@ fn main() {{
                     }),
                     cx,
                 );
-                registry.set_thread_summary_model(Some(ConfiguredModel {
-                    provider,
-                    model: model.clone(),
-                }));
+                registry.set_thread_summary_model(
+                    Some(ConfiguredModel {
+                        provider,
+                        model: model.clone(),
+                    }),
+                    cx,
+                );
             })
         });
 
diff --git a/crates/agent2/src/agent.rs b/crates/agent2/src/agent.rs
@@ -228,7 +228,7 @@ impl NativeAgent {
     ) -> Entity<AcpThread> {
         let connection = Rc::new(NativeAgentConnection(cx.entity()));
         let registry = LanguageModelRegistry::read_global(cx);
-        let summarization_model = registry.thread_summary_model(cx).map(|c| c.model);
+        let summarization_model = registry.thread_summary_model().map(|c| c.model);
 
         thread_handle.update(cx, |thread, cx| {
             thread.set_summarization_model(summarization_model, cx);
@@ -524,7 +524,7 @@ impl NativeAgent {
 
         let registry = LanguageModelRegistry::read_global(cx);
         let default_model = registry.default_model().map(|m| m.model);
-        let summarization_model = registry.thread_summary_model(cx).map(|m| m.model);
+        let summarization_model = registry.thread_summary_model().map(|m| m.model);
 
         for session in self.sessions.values_mut() {
             session.thread.update(cx, |thread, cx| {
diff --git a/crates/agent2/src/tests/mod.rs b/crates/agent2/src/tests/mod.rs
@@ -1822,11 +1822,11 @@ async fn test_agent_connection(cx: &mut TestAppContext) {
         let clock = Arc::new(clock::FakeSystemClock::new());
         let client = Client::new(clock, http_client, cx);
         let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));
-        Project::init_settings(cx);
-        agent_settings::init(cx);
         language_model::init(client.clone(), cx);
         language_models::init(user_store, client.clone(), cx);
+        Project::init_settings(cx);
         LanguageModelRegistry::test(cx);
+        agent_settings::init(cx);
     });
     cx.executor().forbid_parking();
 
diff --git a/crates/agent_ui/src/language_model_selector.rs b/crates/agent_ui/src/language_model_selector.rs
@@ -6,7 +6,8 @@ use feature_flags::ZedProFeatureFlag;
 use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
 use gpui::{Action, AnyElement, App, BackgroundExecutor, DismissEvent, Subscription, Task};
 use language_model::{
-    ConfiguredModel, LanguageModel, LanguageModelProviderId, LanguageModelRegistry,
+    AuthenticateError, ConfiguredModel, LanguageModel, LanguageModelProviderId,
+    LanguageModelRegistry,
 };
 use ordered_float::OrderedFloat;
 use picker::{Picker, PickerDelegate};
@@ -76,6 +77,7 @@ pub struct LanguageModelPickerDelegate {
     all_models: Arc<GroupedModels>,
     filtered_entries: Vec<LanguageModelPickerEntry>,
     selected_index: usize,
+    _authenticate_all_providers_task: Task<()>,
     _subscriptions: Vec<Subscription>,
 }
 
@@ -96,6 +98,7 @@ impl LanguageModelPickerDelegate {
             selected_index: Self::get_active_model_index(&entries, get_active_model(cx)),
             filtered_entries: entries,
             get_active_model: Arc::new(get_active_model),
+            _authenticate_all_providers_task: Self::authenticate_all_providers(cx),
             _subscriptions: vec![cx.subscribe_in(
                 &LanguageModelRegistry::global(cx),
                 window,
@@ -139,6 +142,56 @@ impl LanguageModelPickerDelegate {
             .unwrap_or(0)
     }
 
+    /// Authenticates all providers in the [`LanguageModelRegistry`].
+    ///
+    /// We do this so that we can populate the language selector with all of the
+    /// models from the configured providers.
+    fn authenticate_all_providers(cx: &mut App) -> Task<()> {
+        let authenticate_all_providers = LanguageModelRegistry::global(cx)
+            .read(cx)
+            .providers()
+            .iter()
+            .map(|provider| (provider.id(), provider.name(), provider.authenticate(cx)))
+            .collect::<Vec<_>>();
+
+        cx.spawn(async move |_cx| {
+            for (provider_id, provider_name, authenticate_task) in authenticate_all_providers {
+                if let Err(err) = authenticate_task.await {
+                    if matches!(err, AuthenticateError::CredentialsNotFound) {
+                        // Since we're authenticating these providers in the
+                        // background for the purposes of populating the
+                        // language selector, we don't care about providers
+                        // where the credentials are not found.
+                    } else {
+                        // Some providers have noisy failure states that we
+                        // don't want to spam the logs with every time the
+                        // language model selector is initialized.
+                        //
+                        // Ideally these should have more clear failure modes
+                        // that we know are safe to ignore here, like what we do
+                        // with `CredentialsNotFound` above.
+                        match provider_id.0.as_ref() {
+                            "lmstudio" | "ollama" => {
+                                // LM Studio and Ollama both make fetch requests to the local APIs to determine if they are "authenticated".
+                                //
+                                // These fail noisily, so we don't log them.
+                            }
+                            "copilot_chat" => {
+                                // Copilot Chat returns an error if Copilot is not enabled, so we don't log those errors.
+                            }
+                            _ => {
+                                log::error!(
+                                    "Failed to authenticate provider: {}: {err}",
+                                    provider_name.0
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+        })
+    }
+
     pub fn active_model(&self, cx: &App) -> Option<ConfiguredModel> {
         (self.get_active_model)(cx)
     }
diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs
@@ -4466,7 +4466,7 @@ fn current_language_model(cx: &Context<'_, GitPanel>) -> Option<Arc<dyn Language
     is_enabled
         .then(|| {
             let ConfiguredModel { provider, model } =
-                LanguageModelRegistry::read_global(cx).commit_message_model(cx)?;
+                LanguageModelRegistry::read_global(cx).commit_message_model()?;
 
             provider.is_authenticated(cx).then(|| model)
         })
diff --git a/crates/language_model/src/registry.rs b/crates/language_model/src/registry.rs
@@ -6,6 +6,7 @@ use collections::BTreeMap;
 use gpui::{App, Context, Entity, EventEmitter, Global, prelude::*};
 use std::{str::FromStr, sync::Arc};
 use thiserror::Error;
+use util::maybe;
 
 pub fn init(cx: &mut App) {
     let registry = cx.new(|_cx| LanguageModelRegistry::default());
@@ -41,9 +42,7 @@ impl std::fmt::Debug for ConfigurationError {
 #[derive(Default)]
 pub struct LanguageModelRegistry {
     default_model: Option<ConfiguredModel>,
-    /// This model is automatically configured by a user's environment after
-    /// authenticating all providers. It's only used when default_model is not available.
-    environment_fallback_model: Option<ConfiguredModel>,
+    default_fast_model: Option<ConfiguredModel>,
     inline_assistant_model: Option<ConfiguredModel>,
     commit_message_model: Option<ConfiguredModel>,
     thread_summary_model: Option<ConfiguredModel>,
@@ -99,6 +98,9 @@ impl ConfiguredModel {
 
 pub enum Event {
     DefaultModelChanged,
+    InlineAssistantModelChanged,
+    CommitMessageModelChanged,
+    ThreadSummaryModelChanged,
     ProviderStateChanged(LanguageModelProviderId),
     AddedProvider(LanguageModelProviderId),
     RemovedProvider(LanguageModelProviderId),
@@ -224,7 +226,7 @@ impl LanguageModelRegistry {
         cx: &mut Context<Self>,
     ) {
         let configured_model = model.and_then(|model| self.select_model(model, cx));
-        self.set_inline_assistant_model(configured_model);
+        self.set_inline_assistant_model(configured_model, cx);
     }
 
     pub fn select_commit_message_model(
@@ -233,7 +235,7 @@ impl LanguageModelRegistry {
         cx: &mut Context<Self>,
     ) {
         let configured_model = model.and_then(|model| self.select_model(model, cx));
-        self.set_commit_message_model(configured_model);
+        self.set_commit_message_model(configured_model, cx);
     }
 
     pub fn select_thread_summary_model(
@@ -242,7 +244,7 @@ impl LanguageModelRegistry {
         cx: &mut Context<Self>,
     ) {
         let configured_model = model.and_then(|model| self.select_model(model, cx));
-        self.set_thread_summary_model(configured_model);
+        self.set_thread_summary_model(configured_model, cx);
     }
 
     /// Selects and sets the inline alternatives for language models based on
@@ -276,60 +278,68 @@ impl LanguageModelRegistry {
     }
 
     pub fn set_default_model(&mut self, model: Option<ConfiguredModel>, cx: &mut Context<Self>) {
-        match (self.default_model(), model.as_ref()) {
+        match (self.default_model.as_ref(), model.as_ref()) {
             (Some(old), Some(new)) if old.is_same_as(new) => {}
             (None, None) => {}
             _ => cx.emit(Event::DefaultModelChanged),
         }
+        self.default_fast_model = maybe!({
+            let provider = &model.as_ref()?.provider;
+            let fast_model = provider.default_fast_model(cx)?;
+            Some(ConfiguredModel {
+                provider: provider.clone(),
+                model: fast_model,
+            })
+        });
         self.default_model = model;
     }
 
-    pub fn set_environment_fallback_model(
+    pub fn set_inline_assistant_model(
         &mut self,
         model: Option<ConfiguredModel>,
         cx: &mut Context<Self>,
     ) {
-        if self.default_model.is_none() {
-            match (self.environment_fallback_model.as_ref(), model.as_ref()) {
-                (Some(old), Some(new)) if old.is_same_as(new) => {}
-                (None, None) => {}
-                _ => cx.emit(Event::DefaultModelChanged),
-            }
+        match (self.inline_assistant_model.as_ref(), model.as_ref()) {
+            (Some(old), Some(new)) if old.is_same_as(new) => {}
+            (None, None) => {}
+            _ => cx.emit(Event::InlineAssistantModelChanged),
         }
-        self.environment_fallback_model = model;
-    }
-
-    pub fn set_inline_assistant_model(&mut self, model: Option<ConfiguredModel>) {
         self.inline_assistant_model = model;
     }
 
-    pub fn set_commit_message_model(&mut self, model: Option<ConfiguredModel>) {
+    pub fn set_commit_message_model(
+        &mut self,
+        model: Option<ConfiguredModel>,
+        cx: &mut Context<Self>,
+    ) {
+        match (self.commit_message_model.as_ref(), model.as_ref()) {
+            (Some(old), Some(new)) if old.is_same_as(new) => {}
+            (None, None) => {}
+            _ => cx.emit(Event::CommitMessageModelChanged),
+        }
         self.commit_message_model = model;
     }
 
-    pub fn set_thread_summary_model(&mut self, model: Option<ConfiguredModel>) {
+    pub fn set_thread_summary_model(
+        &mut self,
+        model: Option<ConfiguredModel>,
+        cx: &mut Context<Self>,
+    ) {
+        match (self.thread_summary_model.as_ref(), model.as_ref()) {
+            (Some(old), Some(new)) if old.is_same_as(new) => {}
+            (None, None) => {}
+            _ => cx.emit(Event::ThreadSummaryModelChanged),
+        }
         self.thread_summary_model = model;
     }
 
-    #[track_caller]
     pub fn default_model(&self) -> Option<ConfiguredModel> {
         #[cfg(debug_assertions)]
         if std::env::var("ZED_SIMULATE_NO_LLM_PROVIDER").is_ok() {
             return None;
         }
 
-        self.default_model
-            .clone()
-            .or_else(|| self.environment_fallback_model.clone())
-    }
-
-    pub fn default_fast_model(&self, cx: &App) -> Option<ConfiguredModel> {
-        let provider = self.default_model()?.provider;
-        let fast_model = provider.default_fast_model(cx)?;
-        Some(ConfiguredModel {
-            provider,
-            model: fast_model,
-        })
+        self.default_model.clone()
     }
 
     pub fn inline_assistant_model(&self) -> Option<ConfiguredModel> {
@@ -343,27 +353,27 @@ impl LanguageModelRegistry {
             .or_else(|| self.default_model.clone())
     }
 
-    pub fn commit_message_model(&self, cx: &App) -> Option<ConfiguredModel> {
+    pub fn commit_message_model(&self) -> Option<ConfiguredModel> {
         #[cfg(debug_assertions)]
         if std::env::var("ZED_SIMULATE_NO_LLM_PROVIDER").is_ok() {
             return None;
         }
 
         self.commit_message_model
             .clone()
-            .or_else(|| self.default_fast_model(cx))
+            .or_else(|| self.default_fast_model.clone())
             .or_else(|| self.default_model.clone())
     }
 
-    pub fn thread_summary_model(&self, cx: &App) -> Option<ConfiguredModel> {
+    pub fn thread_summary_model(&self) -> Option<ConfiguredModel> {
         #[cfg(debug_assertions)]
         if std::env::var("ZED_SIMULATE_NO_LLM_PROVIDER").is_ok() {
             return None;
         }
 
         self.thread_summary_model
             .clone()
-            .or_else(|| self.default_fast_model(cx))
+            .or_else(|| self.default_fast_model.clone())
             .or_else(|| self.default_model.clone())
     }
 
@@ -400,34 +410,4 @@ mod tests {
         let providers = registry.read(cx).providers();
         assert!(providers.is_empty());
     }
-
-    #[gpui::test]
-    async fn test_configure_environment_fallback_model(cx: &mut gpui::TestAppContext) {
-        let registry = cx.new(|_| LanguageModelRegistry::default());
-
-        let provider = FakeLanguageModelProvider::default();
-        registry.update(cx, |registry, cx| {
-            registry.register_provider(provider.clone(), cx);
-        });
-
-        cx.update(|cx| provider.authenticate(cx)).await.unwrap();
-
-        registry.update(cx, |registry, cx| {
-            let provider = registry.provider(&provider.id()).unwrap();
-
-            registry.set_environment_fallback_model(
-                Some(ConfiguredModel {
-                    provider: provider.clone(),
-                    model: provider.default_model(cx).unwrap(),
-                }),
-                cx,
-            );
-
-            let default_model = registry.default_model().unwrap();
-            let fallback_model = registry.environment_fallback_model.clone().unwrap();
-
-            assert_eq!(default_model.model.id(), fallback_model.model.id());
-            assert_eq!(default_model.provider.id(), fallback_model.provider.id());
-        });
-    }
 }
diff --git a/crates/language_models/Cargo.toml b/crates/language_models/Cargo.toml
@@ -44,7 +44,6 @@ ollama = { workspace = true, features = ["schemars"] }
 open_ai = { workspace = true, features = ["schemars"] }
 open_router = { workspace = true, features = ["schemars"] }
 partial-json-fixer.workspace = true
-project.workspace = true
 release_channel.workspace = true
 schemars.workspace = true
 serde.workspace = true
diff --git a/crates/language_models/src/language_models.rs b/crates/language_models/src/language_models.rs
diff --git a/crates/language_models/src/provider/cloud.rs b/crates/language_models/src/provider/cloud.rs
