Distinguish between missing models and registries in error messages (#32678)

Consolidates configuration error handling by moving the error type and
logic from assistant_context_editor to language_model::registry.

The registry now provides a single method to check for configuration
errors, making the error handling more consistent across the agent panel
and context editor.

This also now checks if the issue is that we don't have any providers,
or if we just can't find the model.

Previously, an incorrect model name showed up as having no providers,
which is very confusing.

Release Notes:

- N/A

crates/language_model/src/registry.rs

@@ -5,6 +5,7 @@ use crate::{
 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) {
@@ -16,6 +17,34 @@ struct GlobalLanguageModelRegistry(Entity<LanguageModelRegistry>);
 
 impl Global for GlobalLanguageModelRegistry {}
 
+#[derive(Error)]
+pub enum ConfigurationError {
+    #[error("Configure at least one LLM provider to start using the panel.")]
+    NoProvider,
+    #[error("LLM Provider is not configured or does not support the configured model.")]
+    ModelNotFound,
+    #[error("{} LLM provider is not configured.", .0.name().0)]
+    ProviderNotAuthenticated(Arc<dyn LanguageModelProvider>),
+    #[error("Using the {} LLM provider requires accepting the Terms of Service.",
+    .0.name().0)]
+    ProviderPendingTermsAcceptance(Arc<dyn LanguageModelProvider>),
+}
+
+impl std::fmt::Debug for ConfigurationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::NoProvider => write!(f, "NoProvider"),
+            Self::ModelNotFound => write!(f, "ModelNotFound"),
+            Self::ProviderNotAuthenticated(provider) => {
+                write!(f, "ProviderNotAuthenticated({})", provider.id())
+            }
+            Self::ProviderPendingTermsAcceptance(provider) => {
+                write!(f, "ProviderPendingTermsAcceptance({})", provider.id())
+            }
+        }
+    }
+}
+
 #[derive(Default)]
 pub struct LanguageModelRegistry {
     default_model: Option<ConfiguredModel>,
@@ -152,6 +181,36 @@ impl LanguageModelRegistry {
         providers
     }
 
+    pub fn configuration_error(
+        &self,
+        model: Option<ConfiguredModel>,
+        cx: &App,
+    ) -> Option<ConfigurationError> {
+        let Some(model) = model else {
+            if !self.has_authenticated_provider(cx) {
+                return Some(ConfigurationError::NoProvider);
+            }
+            return Some(ConfigurationError::ModelNotFound);
+        };
+
+        if !model.provider.is_authenticated(cx) {
+            return Some(ConfigurationError::ProviderNotAuthenticated(model.provider));
+        }
+
+        if model.provider.must_accept_terms(cx) {
+            return Some(ConfigurationError::ProviderPendingTermsAcceptance(
+                model.provider,
+            ));
+        }
+
+        None
+    }
+
+    /// Check that we have at least one provider that is authenticated.
+    fn has_authenticated_provider(&self, cx: &App) -> bool {
+        self.providers.values().any(|p| p.is_authenticated(cx))
+    }
+
     pub fn available_models<'a>(
         &'a self,
         cx: &'a App,