Skip to content

armgit / zed

Public Imported from GitHub
0

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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>);