Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
agent: Show errors when provider is not authenticated but model is configured (#60417)
Bennet Bo Fenner69664ab9d335
diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rsindex 75e52207f27..381af5e2fa3 100644--- a/crates/agent/src/agent.rs+++ b/crates/agent/src/agent.rs@@ -374,7 +374,10 @@ impl LanguageModels {}}- cx.update(language_models::update_environment_fallback_model);+ cx.update(|cx| {+ LanguageModelRegistry::global(cx)+ .update(cx, |registry, cx| registry.refresh_fallback_model(cx))+ });})}}diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rsindex fb2b277a634..48b86de73b9 100644--- a/crates/agent/src/thread.rs+++ b/crates/agent/src/thread.rs@@ -35,7 +35,8 @@ use futures::{};use futures::{StreamExt, stream};use gpui::{- App, AppContext, AsyncApp, Context, Entity, EventEmitter, SharedString, Task, WeakEntity,+ App, AppContext, AsyncApp, Context, Entity, EventEmitter, ReadGlobal as _, SharedString, Task,+ WeakEntity,};use heck::ToSnakeCase as _;use language_model::{@@ -1181,7 +1182,7 @@ enum CompletionError {Other(#[from] anyhow::Error),}-pub(crate) enum ThreadModel {+pub enum ThreadModel {Ready(Arc<dyn LanguageModel>),Unresolved(SelectedModel),Unset,@@ -1357,7 +1358,11 @@ impl Thread {.and_then(|model| model.speed);let (prompt_capabilities_tx, prompt_capabilities_rx) =watch::channel(Self::prompt_capabilities(model.as_deref()));- let model = model.map_or(ThreadModel::Unset, ThreadModel::Ready);+ let model = match model {+ Some(model) => ThreadModel::Ready(model),+ None => Self::user_configured_model_selection(cx)+ .map_or(ThreadModel::Unset, ThreadModel::Unresolved),+ };Self {id: acp::SessionId::new(uuid::Uuid::new_v4().to_string()),prompt_id: PromptId::new(),@@ -1946,6 +1951,10 @@ impl Thread {self.model.as_model()}+ pub fn thread_model(&self) -> &ThreadModel {+ &self.model+ }+pub(crate) fn ensure_model(&mut self,default_model: Option<&Arc<dyn LanguageModel>>,@@ -1977,6 +1986,7 @@ impl Thread {cx.emit(TokenUsageUpdated(new_usage));}self.prompt_capabilities_tx.send(new_caps).log_err();+ cx.emit(ModelChanged);for subagent in &self.running_subagents {subagent@@ -2395,6 +2405,20 @@ impl Thread {Self::resolve_model_from_selection(&selection, cx)}+ fn user_configured_model_selection(cx: &App) -> Option<SelectedModel> {+ let selection = SettingsStore::global(cx)+ .raw_user_settings()?+ .content+ .agent+ .as_ref()?+ .default_model+ .as_ref()?;+ Some(SelectedModel {+ provider: LanguageModelProviderId::from(selection.provider.0.clone()),+ model: LanguageModelId::from(selection.model.clone()),+ })+ }+/// Translate a stored model selection into the configured model from the registry.fn resolve_model_from_selection(selection: &LanguageModelSelection,@@ -4767,6 +4791,10 @@ pub struct TitleUpdated;impl EventEmitter<TitleUpdated> for Thread {}+pub struct ModelChanged;++impl EventEmitter<ModelChanged> for Thread {}+/// A channel-based wrapper that delivers tool input to a running tool.////// For non-streaming tools, created via `ToolInput::ready()` so `.recv()` resolves immediately.diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rsindex ccaf59f72b0..1640a90297f 100644--- a/crates/agent_ui/src/agent_ui.rs+++ b/crates/agent_ui/src/agent_ui.rs@@ -47,8 +47,8 @@ use editor::{Editor, SelectionEffects, scroll::Autoscroll};use feature_flags::FeatureFlagAppExt as _;use fs::Fs;use gpui::{- Action, App, Context, Entity, ImageSource, Resource, SharedString, SharedUri, TaskExt, Window,- actions,+ Action, App, Context, Entity, ImageSource, ReadGlobal as _, Resource, SharedString, SharedUri,+ TaskExt, Window, actions,};use language::{LanguageRegistry,@@ -885,11 +885,12 @@ fn init_language_model_settings(cx: &mut App) {.detach();cx.subscribe(&LanguageModelRegistry::global(cx),- |_, event: &language_model::Event, cx| match event {+ |registry, event: &language_model::Event, cx| match event {language_model::Event::ProviderStateChanged(_)| language_model::Event::AddedProvider(_)| language_model::Event::RemovedProvider(_)| language_model::Event::ProvidersChanged => {+ registry.update(cx, |registry, cx| registry.refresh_fallback_model(cx));update_active_language_model_from_settings(cx);}_ => {}@@ -908,6 +909,12 @@ fn update_active_language_model_from_settings(cx: &mut App) {}}+ let should_use_fallback = SettingsStore::global(cx)+ .raw_user_settings()+ .and_then(|user| user.content.agent.as_ref())+ .and_then(|agent| agent.default_model.as_ref())+ .is_none();+let default = settings.default_model.as_ref().map(to_selected_model);let inline_assistant = settings.inline_assistant_model@@ -933,6 +940,7 @@ fn update_active_language_model_from_settings(cx: &mut App) {registry.select_commit_message_model(commit_message.as_ref(), cx);registry.select_thread_summary_model(thread_summary.as_ref(), cx);registry.select_inline_alternative_models(inline_alternatives, cx);+ registry.set_should_use_fallback(should_use_fallback);});}diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rsindex 2d7c6b6ca40..c2f06da5261 100644--- a/crates/agent_ui/src/conversation_view/thread_view.rs+++ b/crates/agent_ui/src/conversation_view/thread_view.rs@@ -924,6 +924,20 @@ impl ThreadView {cx.notify();},));++ // A "no model selected" error is stale as soon as the thread has a+ // usable model+ if let Some(native_thread) = native_connection.thread(thread.read(cx).session_id(), cx)+ {+ subscriptions.push(cx.subscribe(+ &native_thread,+ |this: &mut Self, _thread, _event: &agent::ModelChanged, cx| {+ if matches!(this.thread_error, Some(ThreadError::NoModelSelected)) {+ this.clear_thread_error(cx);+ }+ },+ ));+ }}subscriptions.push(cx.observe(&message_editor, |this, editor, cx| {@@ -10643,13 +10657,17 @@ impl ThreadView {false,cx,),- ThreadError::NoModelSelected => self.render_error_callout(- "No Model Selected",- "Select a model from the model picker below to get started.".into(),- false,- false,- cx,- ),+ ThreadError::NoModelSelected => self+ .render_model_not_available_error(cx)+ .unwrap_or_else(|| {+ self.render_error_callout(+ "No Model Selected",+ "Select a model from the model picker below to get started.".into(),+ false,+ false,+ cx,+ )+ }),ThreadError::ApiError { provider } => self.render_error_callout("API Error",format!(@@ -10750,6 +10768,101 @@ impl ThreadView {.dismiss_action(self.dismiss_error_button(cx))}+ fn render_model_not_available_error(&self, cx: &mut Context<Self>) -> Option<Callout> {+ let thread = self.as_native_thread(cx)?;++ let has_authenticated_provider =+ LanguageModelRegistry::read_global(cx).has_authenticated_provider(cx);++ let (title, description): (SharedString, SharedString) =+ match thread.read(cx).thread_model() {+ agent::ThreadModel::Ready(_) => return None,+ agent::ThreadModel::Unresolved(selected_model) => {+ if let Some(provider) = LanguageModelRegistry::global(cx)+ .read(cx)+ .provider(&&selected_model.provider)+ {+ if !provider.is_authenticated(cx) {+ (+ format!("Failed to authenticate with {} provider", provider.name())+ .into(),+ "Open the settings to configure the selected provider".into(),+ )+ } else {+ (+ format!("Model {} was not found", selected_model.model.0).into(),+ "You may need to reconfigure authentication for this provider"+ .into(),+ )+ }+ } else {+ (+ format!("Provider {} was not found", selected_model.provider).into(),+ "Open the settings to configure providers".into(),+ )+ }+ }+ agent::ThreadModel::Unset => {+ if has_authenticated_provider {+ (+ "No model selected".into(),+ "Choose a different model or configure other providers to get started"+ .into(),+ )+ } else {+ (+ "No model selected".into(),+ "Configure a provider to get started".into(),+ )+ }+ }+ };++ let callout = Callout::new()+ .severity(Severity::Error)+ .icon(IconName::XCircle)+ .title(title)+ .description(description)+ .actions_slot(+ h_flex()+ .gap_1()+ .child(self.open_llm_providers_settings_button(cx))+ .when(has_authenticated_provider, |this| {+ this.child(self.open_model_selector_button(cx))+ }),+ )+ .dismiss_action(self.dismiss_error_button(cx));++ Some(callout)+ }++ fn open_llm_providers_settings_button(&self, cx: &mut Context<Self>) -> impl IntoElement {+ Button::new("configure-llm-provider", "Configure Provider")+ .label_size(LabelSize::Small)+ .style(ButtonStyle::Filled)+ .on_click(cx.listener(|this, _, window, cx| {+ this.clear_thread_error(cx);+ window.dispatch_action(+ Box::new(zed_actions::OpenSettingsAt {+ path: "llm_providers".to_string(),+ target: None,+ }),+ cx,+ );+ }))+ }++ fn open_model_selector_button(&self, cx: &mut Context<Self>) -> impl IntoElement {+ Button::new("open-model-selector", "Select Model")+ .label_size(LabelSize::Small)+ .style(ButtonStyle::Filled)+ .key_binding(KeyBinding::for_action(&ToggleModelSelector, cx))+ .on_click(cx.listener(|this, _, window, cx| {+ this.clear_thread_error(cx);+ window.dispatch_action(ToggleModelSelector.boxed_clone(), cx);+ }))+ }+fn render_prompt_too_large_error(&self, cx: &mut Context<Self>) -> Callout {const MESSAGE: &str = "This conversation is too long for the model's context window. \Start a new thread or remove some attached files to continue.";diff --git a/crates/language_model/src/registry.rs b/crates/language_model/src/registry.rsindex ddc30b5d30a..28033e482f3 100644--- a/crates/language_model/src/registry.rs+++ b/crates/language_model/src/registry.rs@@ -44,6 +44,8 @@ impl std::fmt::Debug for ConfigurationError {#[derive(Default)]pub struct LanguageModelRegistry {+ /// True if the user has *NO* default model configured in settings+ should_use_fallback: bool,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 set.@@ -151,6 +153,10 @@ impl LanguageModelRegistry {self.default_model.as_ref().unwrap().model.clone()}+ pub fn set_should_use_fallback(&mut self, value: bool) {+ self.should_use_fallback = value;+ }+pub fn register_provider<T: LanguageModelProvider + LanguageModelProviderState>(&mut self,provider: Arc<T>,@@ -357,11 +363,30 @@ impl LanguageModelRegistry {self.default_model = model;}- pub fn set_environment_fallback_model(- &mut self,- model: Option<ConfiguredModel>,- cx: &mut Context<Self>,- ) {+ pub fn refresh_fallback_model(&mut self, cx: &mut Context<Self>) {+ // If the fallback model was already set or we don't want to use it, do nothing+ if !self.should_use_fallback || self.available_fallback_model.is_some() {+ return;+ }++ let fallback_model = self+ .providers()+ .iter()+ .filter(|provider| provider.is_authenticated(cx))+ .find_map(|provider| {+ let model = provider+ .default_model(cx)+ .or_else(|| provider.recommended_models(cx).first().cloned())?;+ Some(ConfiguredModel {+ provider: provider.clone(),+ model,+ })+ });++ self.set_fallback_model(fallback_model, cx);+ }++ fn set_fallback_model(&mut self, model: Option<ConfiguredModel>, cx: &mut Context<Self>) {if self.default_model.is_none() {match (self.available_fallback_model.as_ref(), model.as_ref()) {(Some(old), Some(new)) if old.is_same_as(new) => {}@@ -417,9 +442,13 @@ impl LanguageModelRegistry {return None;}- self.default_model- .clone()- .or_else(|| self.available_fallback_model.clone())+ self.default_model.clone().or_else(|| {+ if self.should_use_fallback {+ self.available_fallback_model.clone()+ } else {+ None+ }+ })}pub fn default_fast_model(&self, cx: &App) -> Option<ConfiguredModel> {@@ -617,7 +646,7 @@ mod tests {}#[gpui::test]- async fn test_configure_environment_fallback_model(cx: &mut gpui::TestAppContext) {+ async fn test_configure_fallback_model(cx: &mut gpui::TestAppContext) {let registry = cx.new(|_| LanguageModelRegistry::default());let provider = Arc::new(FakeLanguageModelProvider::default());@@ -631,7 +660,7 @@ mod tests {let provider = registry.provider(&provider.id()).unwrap();let model = provider.default_model(cx).unwrap();- registry.set_environment_fallback_model(+ registry.set_fallback_model(Some(ConfiguredModel {provider: provider.clone(),model: model.clone(),@@ -639,6 +668,10 @@ mod tests {cx,);+ assert!(registry.default_model().is_none());++ registry.set_should_use_fallback(true);+let default_model = registry.default_model().unwrap();assert_eq!(default_model.model.id(), model.id());assert_eq!(default_model.provider.id(), provider.id());diff --git a/crates/language_models/src/language_models.rs b/crates/language_models/src/language_models.rsindex a9ec2b028ff..ce968e3d611 100644--- a/crates/language_models/src/language_models.rs+++ b/crates/language_models/src/language_models.rs@@ -5,9 +5,7 @@ use client::{Client, UserStore};use collections::{HashMap, HashSet};use credentials_provider::CredentialsProvider;use gpui::{App, Context, Entity};-use language_model::{- ConfiguredModel, LanguageModelProviderId, LanguageModelRegistry, ZED_CLOUD_PROVIDER_ID,-};+use language_model::{LanguageModelProviderId, LanguageModelRegistry};use provider::deepseek::DeepSeekLanguageModelProvider;pub mod extension;@@ -140,50 +138,6 @@ pub fn init(user_store: Entity<UserStore>, client: Arc<Client>, cx: &mut App) {.detach();}-/// Recomputes and sets the [`LanguageModelRegistry`]'s environment fallback-/// model based on currently authenticated providers.-///-/// Prefers the Zed cloud provider so that, once the user is signed in, we-/// always pick a Zed-hosted model over models from other authenticated-/// providers in the environment. If the Zed cloud provider is authenticated-/// but hasn't finished loading its models yet, we don't fall back to another-/// provider to avoid flickering between providers during sign in.-pub fn update_environment_fallback_model(cx: &mut App) {- let registry = LanguageModelRegistry::global(cx);- let fallback_model = {- let registry = registry.read(cx);- let cloud_provider = registry.provider(&ZED_CLOUD_PROVIDER_ID);- if cloud_provider- .as_ref()- .is_some_and(|provider| provider.is_authenticated(cx))- {- cloud_provider.and_then(|provider| {- let model = provider- .default_model(cx)- .or_else(|| provider.recommended_models(cx).first().cloned())?;- Some(ConfiguredModel { provider, model })- })- } else {- registry- .providers()- .iter()- .filter(|provider| provider.is_authenticated(cx))- .find_map(|provider| {- let model = provider- .default_model(cx)- .or_else(|| provider.recommended_models(cx).first().cloned())?;- Some(ConfiguredModel {- provider: provider.clone(),- model,- })- })- }- };- registry.update(cx, |registry, cx| {- registry.set_environment_fallback_model(fallback_model, cx);- });-}-#[derive(Default, PartialEq, Eq)]struct CompatibleProviders(HashMap<Arc<str>, CompatibleProviderKind>);