From b36b283021c48f1712714b8a0e2ad6ffb578920b Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Fri, 23 Oct 2026 10:32:56 +0000 Subject: [PATCH] Do not read LLM credentials when disable_ai is true (#66029) Closes https://github.com/zed-industries/zed/issues/65735 Release Notes: - Fixed LLM credentials being read despite disable_ai being true --- Cargo.lock | 6 + crates/agent/src/agent.rs | 63 +--- crates/codestral/src/codestral.rs | 6 +- crates/copilot_chat/Cargo.toml | 2 + crates/copilot_chat/src/copilot_chat.rs | 70 +++- crates/credentials_provider/Cargo.toml | 5 + .../src/credentials_provider.rs | 3 + .../credentials_provider/src/test_support.rs | 124 +++++++ crates/edit_prediction/src/mercury.rs | 14 +- .../edit_prediction/src/open_ai_compatible.rs | 2 +- crates/edit_prediction_ui/Cargo.toml | 3 + .../src/edit_prediction_button.rs | 113 +++++- crates/language_model/Cargo.toml | 1 + crates/language_model/src/api_key.rs | 323 +++++++++++++++--- crates/language_model/src/language_model.rs | 3 +- crates/language_model/src/registry.rs | 102 +++++- crates/language_models/Cargo.toml | 1 + crates/language_models/src/language_models.rs | 11 + .../language_models/src/provider/anthropic.rs | 8 + .../language_models/src/provider/bedrock.rs | 8 +- crates/language_models/src/provider/google.rs | 5 + .../language_models/src/provider/llama_cpp.rs | 133 +++++--- .../language_models/src/provider/lmstudio.rs | 113 ++++-- crates/language_models/src/provider/ollama.rs | 5 + .../src/provider/open_router.rs | 5 + .../language_models/src/provider/opencode.rs | 5 + .../src/provider/vercel_ai_gateway.rs | 5 + .../src/openai_subscribed.rs | 33 +- crates/settings_ui/Cargo.toml | 1 + crates/settings_ui/src/settings_ui.rs | 88 ++++- crates/x_ai_subscribed/src/x_ai_subscribed.rs | 37 +- 31 files changed, 1063 insertions(+), 235 deletions(-) create mode 100644 crates/credentials_provider/src/test_support.rs diff --git a/Cargo.lock b/Cargo.lock index 9139202ba7c..7118c571199 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4237,7 +4237,9 @@ name = "credentials_provider" version = "0.1.0" dependencies = [ "anyhow", + "futures 0.3.34", "gpui", + "parking_lot", ] [[package]] @@ -5472,6 +5474,7 @@ dependencies = [ "command_palette_hooks", "copilot", "copilot_ui", + "credentials_provider", "edit_prediction", "edit_prediction_types", "editor", @@ -5481,6 +5484,7 @@ dependencies = [ "gpui", "indoc", "language", + "language_model", "markdown", "menu", "multi_buffer", @@ -5494,6 +5498,7 @@ dependencies = [ "util", "workspace", "zed_actions", + "zed_credentials_provider", "zeta_prompt", ] @@ -16543,6 +16548,7 @@ dependencies = [ "copilot", "copilot_ui", "cpal", + "credentials_provider", "edit_prediction", "edit_prediction_ui", "editor", diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rs index 32b2fb95101..8ed0fae5968 100644 --- a/crates/agent/src/agent.rs +++ b/crates/agent/src/agent.rs @@ -419,19 +419,19 @@ pub struct LanguageModels { model_list: acp_thread::AgentModelList, refresh_models_rx: watch::Receiver<()>, refresh_models_tx: watch::Sender<()>, - _authenticate_all_providers_task: Task<()>, } impl LanguageModels { fn new(cx: &mut App) -> Self { let (refresh_models_tx, refresh_models_rx) = watch::channel(()); + LanguageModelRegistry::global(cx) + .update(cx, |registry, cx| registry.authenticate_providers(cx)); let mut this = Self { models: HashMap::default(), model_list: acp_thread::AgentModelList::Grouped(IndexMap::default()), refresh_models_rx, refresh_models_tx, - _authenticate_all_providers_task: Self::authenticate_all_language_model_providers(cx), }; this.refresh_list(cx); this @@ -517,65 +517,6 @@ impl LanguageModels { fn model_id(model: &LanguageModel) -> AgentModelId { AgentModelId::new(format!("{}/{}", model.provider_id().0, model.id().0)) } - - fn authenticate_all_language_model_providers(cx: &mut App) -> Task<()> { - let authenticate_all_providers = LanguageModelRegistry::global(cx) - .read(cx) - .visible_providers() - .iter() - .map(|provider| (provider.id(), provider.name(), provider.authenticate(cx))) - .collect::>(); - - cx.spawn(async move |cx| { - for (provider_id, provider_name, authenticate_task) in authenticate_all_providers { - if let Err(err) = authenticate_task.await { - match err { - language_model::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. - } - language_model::AuthenticateError::ConnectionRefused => { - // Not logging connection refused errors as they are mostly from LM Studio's noisy auth failures. - // LM Studio only has one auth method (endpoint call) which fails for users who haven't enabled it. - // TODO: Better manage LM Studio auth logic to avoid these noisy failures. - } - _ => { - // 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 - ); - } - } - } - } - } - } - - cx.update(|cx| { - LanguageModelRegistry::global(cx) - .update(cx, |registry, cx| registry.refresh_fallback_model(cx)) - }); - }) - } } /// Implemented by the UI layer to provide the ability for agent tools to create diff --git a/crates/codestral/src/codestral.rs b/crates/codestral/src/codestral.rs index 917e8a54525..c67da8cd9ae 100644 --- a/crates/codestral/src/codestral.rs +++ b/crates/codestral/src/codestral.rs @@ -51,7 +51,7 @@ pub fn load_codestral_api_key(cx: &mut App) -> Task, diff --git a/crates/copilot_chat/Cargo.toml b/crates/copilot_chat/Cargo.toml index 87ded3a486e..ee5e8bd30f8 100644 --- a/crates/copilot_chat/Cargo.toml +++ b/crates/copilot_chat/Cargo.toml @@ -31,5 +31,7 @@ serde_json.workspace = true util.workspace = true [dev-dependencies] +credentials_provider = { workspace = true, features = ["test-support"] } gpui = { workspace = true, features = ["test-support"] } +http_client = { workspace = true, features = ["test-support"] } serde_json.workspace = true diff --git a/crates/copilot_chat/src/copilot_chat.rs b/crates/copilot_chat/src/copilot_chat.rs index c56bee14dbe..b47690a87b9 100644 --- a/crates/copilot_chat/src/copilot_chat.rs +++ b/crates/copilot_chat/src/copilot_chat.rs @@ -538,6 +538,7 @@ pub struct CopilotChat { models: Option>, client: Arc, credentials_provider: Arc, + load_task: Option>>, sign_in_task: Option>, } @@ -563,11 +564,14 @@ async fn load_stored_token( configuration: &CopilotChatConfiguration, cx: &AsyncApp, ) -> Option { - let (_, token) = credentials_provider - .read_credentials(&configuration.credentials_url(), cx) - .await - .ok() - .flatten()?; + let (_, token) = language_model::read_credentials( + credentials_provider.as_ref(), + &configuration.credentials_url(), + cx, + ) + .await + .ok() + .flatten()?; String::from_utf8(token).ok() } @@ -587,7 +591,7 @@ impl CopilotChat { // Load a previously-stored token (or the one from the environment) and // fetch models if we end up authenticated. - cx.spawn(async move |this, cx| { + let load_task = cx.spawn(async move |this, cx| { let (env_token, credentials_provider, configuration) = this.read_with(cx, |this, _| { ( @@ -620,8 +624,7 @@ impl CopilotChat { Self::update_models(&this, cx).await?; } anyhow::Ok(()) - }) - .detach(); + }); Self { status: CopilotChatStatus::Starting, @@ -631,6 +634,7 @@ impl CopilotChat { configuration, client, credentials_provider, + load_task: Some(load_task), sign_in_task: None, } } @@ -649,6 +653,7 @@ impl CopilotChat { return; } + self.load_task = None; let client = self.client.clone(); let configuration = self.configuration.clone(); let credentials_url = configuration.credentials_url(); @@ -711,6 +716,7 @@ impl CopilotChat { self.oauth_token = None; self.api_endpoint = None; self.models = None; + self.load_task = None; self.sign_in_task = None; self.status = CopilotChatStatus::SignedOut; cx.notify(); @@ -901,7 +907,7 @@ impl CopilotChat { let credentials_provider = self.credentials_provider.clone(); let configuration = self.configuration.clone(); - cx.spawn(async move |this, cx| { + self.load_task = Some(cx.spawn(async move |this, cx| { let token = load_stored_token(&credentials_provider, &configuration, cx).await; let configuration_is_current = this.update(cx, |this, cx| { if this.configuration != configuration { @@ -926,8 +932,7 @@ impl CopilotChat { } } Ok::<_, anyhow::Error>(()) - }) - .detach_and_log_err(cx); + })); } } } @@ -1228,6 +1233,9 @@ async fn stream_messages( #[cfg(test)] mod tests { use super::*; + use credentials_provider::test_support::FakeCredentialsProvider; + use gpui::TestAppContext; + use http_client::FakeHttpClient; #[test] fn test_github_urls() { @@ -1928,4 +1936,44 @@ mod tests { "\"none\"" ); } + + #[gpui::test] + async fn test_disabled_credential_load_configuration_and_signout(cx: &mut TestAppContext) { + cx.update(|cx| { + language_model::set_credentials_read_gate::( + |cx| cx.global::().0, + cx, + ); + }); + for sign_out in [false, true] { + cx.update(|cx| cx.set_global(DisabledAi(true))); + let credentials = Arc::new(FakeCredentialsProvider::default()); + let client = FakeHttpClient::create(|_| async { panic!("unexpected HTTP request") }); + let mut configuration = CopilotChatConfiguration::default(); + let chat = cx.new(|cx| { + let mut chat = + CopilotChat::new(client, credentials.clone(), configuration.clone(), cx); + chat.oauth_token = None; + chat + }); + cx.run_until_parked(); + configuration.enterprise_uri = Some("https://enterprise.example".to_string()); + chat.update(cx, |chat, cx| chat.set_configuration(configuration, cx)); + cx.run_until_parked(); + assert_eq!(credentials.take_reads(), Vec::::new()); + if sign_out { + chat.update(cx, |chat, cx| chat.sign_out(cx)) + .await + .expect("sign out"); + } + cx.update(|cx| cx.set_global(DisabledAi(false))); + cx.run_until_parked(); + let expected = vec!["https://enterprise.example/copilot-agent"; usize::from(!sign_out)]; + assert_eq!(credentials.take_reads(), expected); + } + } + + struct DisabledAi(bool); + + impl Global for DisabledAi {} } diff --git a/crates/credentials_provider/Cargo.toml b/crates/credentials_provider/Cargo.toml index 36f059911e1..8ea5b3f5801 100644 --- a/crates/credentials_provider/Cargo.toml +++ b/crates/credentials_provider/Cargo.toml @@ -13,6 +13,11 @@ path = "src/credentials_provider.rs" test = false doctest = false +[features] +test-support = ["dep:futures", "dep:parking_lot"] + [dependencies] anyhow.workspace = true +futures = { workspace = true, optional = true } gpui.workspace = true +parking_lot = { workspace = true, optional = true } diff --git a/crates/credentials_provider/src/credentials_provider.rs b/crates/credentials_provider/src/credentials_provider.rs index b98e97673cc..38dd769166a 100644 --- a/crates/credentials_provider/src/credentials_provider.rs +++ b/crates/credentials_provider/src/credentials_provider.rs @@ -1,3 +1,6 @@ +#[cfg(feature = "test-support")] +pub mod test_support; + use std::future::Future; use std::pin::Pin; diff --git a/crates/credentials_provider/src/test_support.rs b/crates/credentials_provider/src/test_support.rs new file mode 100644 index 00000000000..836040a63d2 --- /dev/null +++ b/crates/credentials_provider/src/test_support.rs @@ -0,0 +1,124 @@ +use crate::CredentialsProvider; +use anyhow::{Result, anyhow}; +use futures::{FutureExt, channel::oneshot, future::LocalBoxFuture}; +use gpui::AsyncApp; +use parking_lot::Mutex; +use std::collections::HashMap; + +#[derive(Default)] +pub struct FakeCredentialsProvider { + pub state: Mutex, +} + +#[derive(Default)] +pub struct FakeCredentials { + pub keys: HashMap>, + pub reads: Vec, + pub fail_reads: bool, + + delayed_reads: HashMap>, + delayed_mutation: Option>, +} + +impl FakeCredentialsProvider { + pub fn defer_read(&self, url: &str) -> oneshot::Sender<()> { + let (sender, receiver) = oneshot::channel(); + assert!( + self.state + .lock() + .delayed_reads + .insert(url.to_string(), receiver) + .is_none() + ); + sender + } + + pub fn defer_next_mutation(&self) -> oneshot::Sender<()> { + let (sender, receiver) = oneshot::channel(); + assert!( + self.state + .lock() + .delayed_mutation + .replace(receiver) + .is_none() + ); + sender + } + + pub fn assert_reads(&self, urls: &[&str]) { + assert_eq!(self.state.lock().reads, urls); + } + + pub fn take_reads(&self) -> Vec { + let mut reads = std::mem::take(&mut self.state.lock().reads); + reads.sort(); + reads + } +} + +impl CredentialsProvider for FakeCredentialsProvider { + fn read_credentials<'a>( + &'a self, + url: &'a str, + _cx: &'a AsyncApp, + ) -> LocalBoxFuture<'a, Result)>>> { + async move { + let (result, delayed_read) = { + let mut state = self.state.lock(); + state.reads.push(url.to_string()); + let result = if state.fail_reads { + Err(anyhow!("keyring unavailable")) + } else { + Ok(state + .keys + .get(url) + .cloned() + .map(|key| (String::from("Bearer"), key))) + }; + (result, state.delayed_reads.remove(url)) + }; + if let Some(delayed_read) = delayed_read { + delayed_read.await?; + } + result + } + .boxed_local() + } + + fn write_credentials<'a>( + &'a self, + url: &'a str, + _username: &'a str, + password: &'a [u8], + _cx: &'a AsyncApp, + ) -> LocalBoxFuture<'a, Result<()>> { + let delayed_mutation = self.state.lock().delayed_mutation.take(); + async move { + if let Some(delayed_mutation) = delayed_mutation { + delayed_mutation.await?; + } + self.state + .lock() + .keys + .insert(url.to_string(), password.to_vec()); + Ok(()) + } + .boxed_local() + } + + fn delete_credentials<'a>( + &'a self, + url: &'a str, + _cx: &'a AsyncApp, + ) -> LocalBoxFuture<'a, Result<()>> { + let delayed_mutation = self.state.lock().delayed_mutation.take(); + async move { + if let Some(delayed_mutation) = delayed_mutation { + delayed_mutation.await?; + } + self.state.lock().keys.remove(url); + Ok(()) + } + .boxed_local() + } +} diff --git a/crates/edit_prediction/src/mercury.rs b/crates/edit_prediction/src/mercury.rs index 26e0b5ef24e..604d668d507 100644 --- a/crates/edit_prediction/src/mercury.rs +++ b/crates/edit_prediction/src/mercury.rs @@ -59,7 +59,12 @@ impl Mercury { cx: &mut Context, ) -> Task>> { self.api_token.update(cx, |key_state, cx| { - _ = key_state.load_if_needed(MERCURY_CREDENTIALS_URL, |s| s, credentials_provider, cx); + _ = key_state.load_cached( + MERCURY_CREDENTIALS_URL, + |key_state| key_state, + credentials_provider, + cx, + ); }); let Some(api_token) = self.api_token.read(cx).key(&MERCURY_CREDENTIALS_URL) else { return Task::ready(Ok(None)); @@ -399,7 +404,12 @@ pub fn mercury_api_token(cx: &mut App) -> Entity { pub fn load_mercury_api_token(cx: &mut App) -> Task> { let credentials_provider = zed_credentials_provider::global(cx); mercury_api_token(cx).update(cx, |key_state, cx| { - key_state.load_if_needed(MERCURY_CREDENTIALS_URL, |s| s, credentials_provider, cx) + key_state.load_cached( + MERCURY_CREDENTIALS_URL, + |key_state| key_state, + credentials_provider, + cx, + ) }) } diff --git a/crates/edit_prediction/src/open_ai_compatible.rs b/crates/edit_prediction/src/open_ai_compatible.rs index 9a111648228..abcb4b19182 100644 --- a/crates/edit_prediction/src/open_ai_compatible.rs +++ b/crates/edit_prediction/src/open_ai_compatible.rs @@ -45,7 +45,7 @@ pub fn load_open_ai_compatible_api_token( let credentials_provider = zed_credentials_provider::global(cx); let api_url = open_ai_compatible_api_url(cx); open_ai_compatible_api_token(cx).update(cx, |key_state, cx| { - key_state.load_if_needed(api_url, |s| s, credentials_provider, cx) + key_state.load_cached(api_url, |key_state| key_state, credentials_provider, cx) }) } diff --git a/crates/edit_prediction_ui/Cargo.toml b/crates/edit_prediction_ui/Cargo.toml index b2ff528f329..d4fe39aa56f 100644 --- a/crates/edit_prediction_ui/Cargo.toml +++ b/crates/edit_prediction_ui/Cargo.toml @@ -47,10 +47,13 @@ zeta_prompt.workspace = true [dev-dependencies] copilot = { workspace = true, features = ["test-support"] } +credentials_provider = { workspace = true, features = ["test-support"] } editor = { workspace = true, features = ["test-support"] } futures.workspace = true indoc.workspace = true +language_model.workspace = true project = { workspace = true, features = ["test-support"] } workspace = { workspace = true, features = ["test-support"] } +zed_credentials_provider.workspace = true diff --git a/crates/edit_prediction_ui/src/edit_prediction_button.rs b/crates/edit_prediction_ui/src/edit_prediction_button.rs index a9eb5733cbb..bab6962eafe 100644 --- a/crates/edit_prediction_ui/src/edit_prediction_button.rs +++ b/crates/edit_prediction_ui/src/edit_prediction_button.rs @@ -1,7 +1,6 @@ use anyhow::Result; use client::{Client, UserStore, zed_urls}; use cloud_llm_client::UsageLimit; -use codestral::{self, CodestralEditPredictionDelegate}; use copilot::Status; use edit_prediction::EditPredictionStore; use edit_prediction_types::EditPredictionDelegateHandle; @@ -575,28 +574,25 @@ impl EditPredictionButton { cx.observe(&copilot, |_, _, cx| cx.notify()).detach() } - cx.observe_global::(move |_, cx| cx.notify()) - .detach(); + cx.observe_global::(move |_, cx| { + load_provider_credentials(cx); + cx.notify(); + }) + .detach(); cx.observe_global::(move |_, cx| cx.notify()) .detach(); cx.observe(&user_store, |_, _, cx| cx.notify()).detach(); - let mercury_api_token_task = edit_prediction::mercury::load_mercury_api_token(cx); - let open_ai_compatible_api_token_task = - edit_prediction::open_ai_compatible::load_open_ai_compatible_api_token(cx); - - cx.spawn(async move |this, cx| { - _ = futures::join!(mercury_api_token_task, open_ai_compatible_api_token_task); - this.update(cx, |_, cx| { - cx.notify(); - }) - .ok(); - }) - .detach(); - - CodestralEditPredictionDelegate::ensure_api_key_loaded(cx); + load_provider_credentials(cx); + for key_state in [ + edit_prediction::mercury::mercury_api_token(cx), + edit_prediction::open_ai_compatible::open_ai_compatible_api_token(cx), + codestral::codestral_api_key_state(cx), + ] { + cx.observe(&key_state, |_, _, cx| cx.notify()).detach(); + } Self { editor_subscription: None, @@ -1767,6 +1763,13 @@ fn emit_edit_prediction_menu_opened( ); } +fn load_provider_credentials(cx: &mut App) { + let _mercury_task = edit_prediction::mercury::load_mercury_api_token(cx); + let _open_ai_compatible_task = + edit_prediction::open_ai_compatible::load_open_ai_compatible_api_token(cx); + let _codestral_task = codestral::load_codestral_api_key(cx); +} + fn copilot_settings_url(enterprise_uri: Option<&str>) -> Arc { match enterprise_uri { Some(uri) => format!("{}{}", uri.trim_end_matches('/'), COPILOT_SETTINGS_PATH).into(), @@ -1778,8 +1781,84 @@ fn copilot_settings_url(enterprise_uri: Option<&str>) -> Arc { mod tests { use super::*; use anyhow::Context as _; + use credentials_provider::test_support::FakeCredentialsProvider; use gpui::TestAppContext; + use language_model::{ApiKeyState, EnvVar}; use settings::RootUserSettings; + use workspace::AppState; + use zed_credentials_provider::ZedCredentialsProvider; + + #[gpui::test] + async fn test_credentials_survive_button_recreation(cx: &mut TestAppContext) { + let app_state = cx.update(AppState::test); + let project = Project::test(app_state.fs.clone(), [], cx).await; + let credentials = Arc::new(FakeCredentialsProvider::default()); + + cx.update(|cx| { + cx.set_global(ZedCredentialsProvider(credentials.clone())); + language_model::set_credentials_read_gate::( + |cx| DisableAiSettings::get_global(cx).disable_ai, + cx, + ); + let settings = r#"{"disable_ai":true,"edit_predictions":{ + "open_ai_compatible_api":{"api_url":"https://edit.example","model":"test"} + }}"#; + cx.update_global::(|store, cx| { + store + .set_user_settings(settings, cx) + .expect("edit prediction settings"); + }); + let env_var = EnvVar { + name: SharedString::from("TEST_API_KEY"), + value: None, + }; + for key_state in [ + edit_prediction::mercury::mercury_api_token(cx), + edit_prediction::open_ai_compatible::open_ai_compatible_api_token(cx), + codestral::codestral_api_key_state(cx), + ] { + key_state.update(cx, |state, _| { + *state = ApiKeyState::new(state.url.clone(), env_var.clone()); + }); + } + }); + let new_button = |cx: &mut TestAppContext| { + cx.new(|cx| { + EditPredictionButton::new( + app_state.fs.clone(), + app_state.user_store.clone(), + PopoverMenuHandle::default(), + project.clone(), + cx, + ) + }) + }; + let button = new_button(cx); + cx.run_until_parked(); + assert_eq!(credentials.take_reads(), Vec::::new()); + drop(button); + let button = new_button(cx); + cx.run_until_parked(); + assert_eq!(credentials.take_reads(), Vec::::new()); + cx.update_global::(|store, cx| { + store.update_user_settings(cx, |settings| { + settings.project.disable_ai = Some(false.into()); + }); + }); + cx.run_until_parked(); + assert_eq!( + credentials.take_reads(), + [ + "https://api.inceptionlabs.ai/v1/edit/completions", + "https://codestral.mistral.ai", + "https://edit.example", + ] + ); + drop(button); + let _button = new_button(cx); + cx.run_until_parked(); + assert_eq!(credentials.take_reads(), Vec::::new()); + } #[test] fn test_disabled_globs_selection_and_replacement() -> Result<()> { diff --git a/crates/language_model/Cargo.toml b/crates/language_model/Cargo.toml index da9c036fa57..5993dcdedc2 100644 --- a/crates/language_model/Cargo.toml +++ b/crates/language_model/Cargo.toml @@ -34,4 +34,5 @@ serde_json.workspace = true thiserror.workspace = true [dev-dependencies] +credentials_provider = { workspace = true, features = ["test-support"] } gpui = { workspace = true, features = ["test-support"] } diff --git a/crates/language_model/src/api_key.rs b/crates/language_model/src/api_key.rs index e2645d37f0d..a3ea730e32b 100644 --- a/crates/language_model/src/api_key.rs +++ b/crates/language_model/src/api_key.rs @@ -1,8 +1,8 @@ use anyhow::{Result, anyhow}; use credentials_provider::CredentialsProvider; use env_var::EnvVar; -use futures::{FutureExt, future}; -use gpui::{AsyncApp, Context, SharedString, Task}; +use futures::{FutureExt, channel::oneshot, future}; +use gpui::{App, AppContext, AsyncApp, Context, Global, SharedString, Subscription, Task}; use gpui_util::ResultExt as _; use std::{ fmt::{Display, Formatter}, @@ -20,11 +20,12 @@ pub struct ApiKeyState { pub url: SharedString, env_var: EnvVar, load_status: LoadStatus, - load_task: Option>>, + load_task: Option, } #[derive(Debug, Clone)] pub enum LoadStatus { + NotLoaded, NotPresent, Error(String), Loaded(ApiKey), @@ -36,12 +37,47 @@ pub struct ApiKey { key: Arc, } +pub fn set_credentials_read_gate(is_disabled: fn(&App) -> bool, cx: &mut App) { + cx.set_global(CredentialsReadGate { + is_disabled, + subscribe: |cx, is_disabled, sender| { + let mut sender = Some(sender); + cx.observe_global::(move |cx| { + if !is_disabled(cx) + && let Some(sender) = sender.take() + { + sender.send(()).ok(); + } + }) + }, + }); +} + +pub async fn read_credentials( + provider: &dyn CredentialsProvider, + url: &str, + cx: &AsyncApp, +) -> Result)>> { + while let Some((receiver, _subscription)) = cx.update(|cx| { + let gate = *cx.try_global::()?; + if !(gate.is_disabled)(cx) { + return None; + } + let (sender, receiver) = oneshot::channel(); + let subscription = (gate.subscribe)(cx, gate.is_disabled, sender); + Some((receiver, subscription)) + }) { + receiver.await?; + } + provider.read_credentials(url, cx).await +} + impl ApiKeyState { pub fn new(url: SharedString, env_var: EnvVar) -> Self { Self { url, env_var, - load_status: LoadStatus::NotPresent, + load_status: LoadStatus::NotLoaded, load_task: None, } } @@ -102,13 +138,20 @@ impl ApiKeyState { key: Option, get_this: impl Fn(&mut Ent) -> &mut Self + 'static, provider: Arc, - cx: &Context, + cx: &mut Context, ) -> Task> { if self.is_from_env_var() { return Task::ready(Err(anyhow!( "bug: attempted to store API key in system keychain when API key is from env var", ))); } + if self.url != url { + self.url = url.clone(); + self.load_status = LoadStatus::NotLoaded; + self.load_task = None; + cx.notify(); + } + cx.spawn(async move |ent, cx| { if let Some(key) = &key { provider @@ -119,9 +162,12 @@ impl ApiKeyState { provider.delete_credentials(&url, cx).await.log_err(); } ent.update(cx, |ent, cx| { - let this = get_this(ent); - this.url = url; - this.load_status = match &key { + let key_state = get_this(ent); + if key_state.url != url { + return; + } + key_state.load_task = None; + key_state.load_status = match &key { Some(key) => LoadStatus::Loaded(ApiKey { source: ApiKeySource::SystemKeychain, key: key.as_str().into(), @@ -140,7 +186,7 @@ impl ApiKeyState { pub fn handle_url_change( &mut self, url: SharedString, - get_this: impl Fn(&mut Ent) -> &mut Self + Clone + 'static, + get_this: impl Fn(&mut Ent) -> &mut Self + 'static, provider: Arc, cx: &mut Context, ) { @@ -152,6 +198,22 @@ impl ApiKeyState { } } + pub fn load_cached( + &mut self, + url: SharedString, + get_this: impl Fn(&mut Ent) -> &mut Self + 'static, + provider: Arc, + cx: &mut Context, + ) -> Task> { + if let LoadStatus::NotPresent | LoadStatus::Error(_) = &self.load_status + && self.url == url + { + return Task::ready(Ok(())); + } + + self.load_if_needed(url, get_this, provider, cx) + } + /// If needed, loads the API key associated with the given URL from the system keychain. When a /// non-empty environment variable is provided, it will be used instead. If called when an API /// key was already loaded for a different URL, that key will be cleared before loading. @@ -160,7 +222,7 @@ impl ApiKeyState { pub fn load_if_needed( &mut self, url: SharedString, - get_this: impl Fn(&mut Ent) -> &mut Self + Clone + 'static, + get_this: impl Fn(&mut Ent) -> &mut Self + 'static, provider: Arc, cx: &mut Context, ) -> Task> { @@ -181,23 +243,22 @@ impl ApiKeyState { return Task::ready(Ok(())); } - let task = if let Some(load_task) = &self.load_task { - load_task.clone() + let completion = if let Some(load_task) = &self.load_task + && self.url == url + { + load_task.completion.clone() } else { - let load_task = Self::load(url.clone(), get_this.clone(), provider, cx).shared(); + let load_task = Self::load(url.clone(), get_this, provider, cx); + let completion = load_task.completion.clone(); self.url = url; - self.load_status = LoadStatus::NotPresent; - self.load_task = Some(load_task.clone()); + self.load_status = LoadStatus::NotLoaded; + self.load_task = Some(load_task); cx.notify(); - load_task + completion }; - cx.spawn(async move |ent, cx| { - task.await; - ent.update(cx, |ent, _cx| { - get_this(ent).load_status.clone().into_authenticate_result() - }) - .ok(); + cx.background_spawn(async move { + completion.await.ok(); Ok(()) }) } @@ -207,21 +268,25 @@ impl ApiKeyState { get_this: impl Fn(&mut Ent) -> &mut Self + 'static, provider: Arc, cx: &Context, - ) -> Task<()> { - cx.spawn({ - async move |ent, cx| { - let load_status = - ApiKey::load_from_system_keychain_impl(&url, provider.as_ref(), cx).await; - ent.update(cx, |ent, cx| { - let this = get_this(ent); - this.url = url; - this.load_status = load_status; - this.load_task = None; - cx.notify(); - }) - .ok(); - } - }) + ) -> ApiKeyLoad { + let (sender, completion) = oneshot::channel(); + let task = cx.spawn(async move |ent, cx| { + let load_status = + ApiKey::load_from_system_keychain_impl(&url, provider.as_ref(), cx).await; + ent.update(cx, |ent, cx| { + let key_state = get_this(ent); + key_state.url = url; + key_state.load_status = load_status; + key_state.load_task = None; + cx.notify(); + }) + .ok(); + sender.send(()).ok(); + }); + ApiKeyLoad { + _task: task, + completion: completion.shared(), + } } } @@ -255,7 +320,7 @@ impl ApiKey { if url.is_empty() { return LoadStatus::NotPresent; } - let read_result = credentials_provider.read_credentials(&url, cx).await; + let read_result = read_credentials(credentials_provider, url, cx).await; let api_key = match read_result { Ok(Some((_, api_key))) => api_key, Ok(None) => return LoadStatus::NotPresent, @@ -276,12 +341,27 @@ impl LoadStatus { fn into_authenticate_result(self) -> Result { match self { LoadStatus::Loaded(api_key) => Ok(api_key), - LoadStatus::NotPresent => Err(AuthenticateError::CredentialsNotFound), + LoadStatus::NotLoaded | LoadStatus::NotPresent => { + Err(AuthenticateError::CredentialsNotFound) + } LoadStatus::Error(err) => Err(AuthenticateError::Other(anyhow!(err))), } } } +#[derive(Clone, Copy)] +struct CredentialsReadGate { + is_disabled: fn(&App) -> bool, + subscribe: fn(&mut App, fn(&App) -> bool, oneshot::Sender<()>) -> Subscription, +} + +impl Global for CredentialsReadGate {} + +struct ApiKeyLoad { + _task: Task<()>, + completion: future::Shared>, +} + #[derive(Debug, Clone)] enum ApiKeySource { EnvVar(SharedString), @@ -296,3 +376,168 @@ impl Display for ApiKeySource { } } } + +#[cfg(test)] +mod tests { + use super::*; + use credentials_provider::test_support::FakeCredentialsProvider; + use gpui::{Entity, TestAppContext}; + + const URL: &str = "provider"; + const OTHER_URL: &str = "other-provider"; + + #[gpui::test] + async fn test_cached_miss_and_explicit_retry(cx: &mut TestAppContext) { + for fail_reads in [false, true] { + let test = KeyTest::new(&[], cx); + test.provider.state.lock().fail_reads = fail_reads; + test.load(URL, cx).await.expect("initial load"); + { + let mut credentials = test.provider.state.lock(); + credentials.fail_reads = false; + credentials + .keys + .insert(URL.to_string(), b"late-key".to_vec()); + } + test.load(URL, cx).await.expect("cached miss"); + assert_eq!(test.key(URL, cx), None); + test.provider.assert_reads(&[URL]); + let url = SharedString::from(URL); + let retry = test.state.update(cx, |state, cx| { + state.load_if_needed(url, |state| state, test.provider.clone(), cx) + }); + retry.await.expect("explicit retry"); + assert_eq!(test.key(URL, cx).as_deref(), Some("late-key")); + test.load(URL, cx).await.expect("cached key"); + test.provider.assert_reads(&[URL, URL]); + } + } + + #[gpui::test] + async fn test_disabled_gate_and_superseded_loads(cx: &mut TestAppContext) { + cx.update(|cx| { + set_credentials_read_gate::(|cx| cx.global::().0, cx); + }); + let test = KeyTest::new(&[(OTHER_URL, "latest-key")], cx); + set_disabled_ai(true, cx); + let superseded = test.load(URL, cx); + cx.run_until_parked(); + drop(test.load(OTHER_URL, cx)); + cx.run_until_parked(); + test.provider.assert_reads(&[]); + set_disabled_ai(false, cx); + set_disabled_ai(true, cx); + cx.run_until_parked(); + test.provider.assert_reads(&[]); + let release = test.provider.defer_read(OTHER_URL); + set_disabled_ai(false, cx); + cx.run_until_parked(); + drop(test.load(OTHER_URL, cx)); + set_disabled_ai(true, cx); + cx.run_until_parked(); + test.provider.assert_reads(&[OTHER_URL]); + release.send(()).expect("started read remains live"); + cx.run_until_parked(); + superseded.await.expect("superseded load completes"); + assert_eq!(test.key(OTHER_URL, cx).as_deref(), Some("latest-key")); + test.provider.assert_reads(&[OTHER_URL]); + } + + #[gpui::test] + async fn test_store_cancels_stale_read(cx: &mut TestAppContext) { + for stored_key in [Some("saved-key"), None] { + let test = KeyTest::new(&[(URL, "old-key")], cx); + let release = test.provider.defer_read(URL); + let load = test.load(URL, cx); + cx.run_until_parked(); + test.store(stored_key, cx).await.expect("mutation"); + cx.run_until_parked(); + assert_eq!(release.send(()), Err(())); + load.await.expect("cancelled read completes"); + test.load(URL, cx).await.expect("cached mutation"); + assert_eq!(test.key(URL, cx).as_deref(), stored_key); + test.provider.assert_reads(&[URL]); + } + } + + #[gpui::test] + async fn test_deferred_mutations_follow_url_identity(cx: &mut TestAppContext) { + for stored_key in [Some("saved-key"), None] { + let test = KeyTest::new(&[(URL, "old-key"), (OTHER_URL, "other-key")], cx); + test.load(URL, cx).await.expect("initial load"); + let release = test.provider.defer_next_mutation(); + let mutation = test.store(stored_key, cx); + cx.run_until_parked(); + let release_read = test.provider.defer_read(OTHER_URL); + let load = test.load(OTHER_URL, cx); + cx.run_until_parked(); + release.send(()).expect("pending mutation"); + mutation.await.expect("mutation for inactive URL"); + drop(test.load(OTHER_URL, cx)); + cx.run_until_parked(); + assert_eq!(test.key(OTHER_URL, cx), None); + release_read.send(()).expect("other URL read remains live"); + load.await.expect("other URL load"); + assert_eq!(test.key(OTHER_URL, cx).as_deref(), Some("other-key")); + assert_eq!( + test.provider.state.lock().keys.get(URL).map(Vec::as_slice), + stored_key.map(str::as_bytes) + ); + test.provider.assert_reads(&[URL, OTHER_URL]); + } + } + + type LoadTask = Task>; + + struct DisabledAi(bool); + + impl Global for DisabledAi {} + + struct KeyTest { + state: Entity, + provider: Arc, + } + + impl KeyTest { + fn new(keys: &[(&str, &str)], cx: &mut TestAppContext) -> Self { + let provider = Arc::new(FakeCredentialsProvider::default()); + provider.state.lock().keys.extend( + keys.iter() + .map(|(url, key)| (url.to_string(), key.as_bytes().to_vec())), + ); + let state = cx.new(|_| { + ApiKeyState::new( + SharedString::default(), + EnvVar { + name: SharedString::new_static("TEST_API_KEY"), + value: None, + }, + ) + }); + Self { state, provider } + } + + fn load(&self, url: &'static str, cx: &mut TestAppContext) -> LoadTask { + let url = SharedString::from(url); + self.state.update(cx, |state, cx| { + state.load_cached(url, |state| state, self.provider.clone(), cx) + }) + } + + fn store(&self, key: Option<&str>, cx: &mut TestAppContext) -> Task> { + let url = SharedString::from(URL); + let key = key.map(String::from); + self.state.update(cx, |state, cx| { + state.store(url, key, |state| state, self.provider.clone(), cx) + }) + } + + fn key(&self, url: &str, cx: &TestAppContext) -> Option> { + self.state.read_with(cx, |state, _| state.key(url)) + } + } + + fn set_disabled_ai(disabled: bool, cx: &mut TestAppContext) { + cx.update(|cx| cx.set_global(DisabledAi(disabled))); + } +} diff --git a/crates/language_model/src/language_model.rs b/crates/language_model/src/language_model.rs index 67f2cdeaf75..679cd8b6569 100644 --- a/crates/language_model/src/language_model.rs +++ b/crates/language_model/src/language_model.rs @@ -17,7 +17,7 @@ use std::sync::Arc; pub type CreateProviderSettingsView = Arc AnyView + 'static>; -pub use crate::api_key::{ApiKey, ApiKeyState}; +pub use crate::api_key::{ApiKey, ApiKeyState, read_credentials, set_credentials_read_gate}; pub use crate::registry::*; pub use crate::request::{LanguageModelImageExt, gpui_size_to_image_size, image_size_to_gpui}; pub use env_var::{EnvVar, env_var}; @@ -559,6 +559,7 @@ pub trait LanguageModelProvider: LanguageModelClient { fn is_authenticated(&self, cx: &App) -> bool; fn authenticate(&self, cx: &mut App) -> Task>; + fn refresh_models(&self, _cx: &mut App) {} fn settings_view(&self, cx: &mut App) -> Option; fn set_api_key(&self, _key: Option, _cx: &mut App) -> Task> { diff --git a/crates/language_model/src/registry.rs b/crates/language_model/src/registry.rs index 011a1d4efb3..a53cdd46b58 100644 --- a/crates/language_model/src/registry.rs +++ b/crates/language_model/src/registry.rs @@ -1,9 +1,10 @@ use crate::{ - LanguageModel, LanguageModelCompletionError, LanguageModelId, LanguageModelProvider, - LanguageModelProviderId, LanguageModelProviderState, ZED_CLOUD_PROVIDER_ID, unavailable_error, + AuthenticateError, LanguageModel, LanguageModelCompletionError, LanguageModelId, + LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderState, + ZED_CLOUD_PROVIDER_ID, unavailable_error, }; use collections::{BTreeMap, HashSet}; -use gpui::{App, Context, Entity, EventEmitter, Global, prelude::*}; +use gpui::{App, Context, Entity, EventEmitter, Global, Task, prelude::*}; use std::{str::FromStr, sync::Arc}; use thiserror::Error; @@ -55,6 +56,7 @@ pub struct LanguageModelRegistry { thread_summary_model: Option, compaction_model: Option, providers: BTreeMap>, + authentication_tasks: BTreeMap>, inline_alternatives: Vec, /// Set of installed extension IDs that provide language models. /// Used to determine which built-in providers should be hidden. @@ -164,16 +166,33 @@ impl LanguageModelRegistry { subscription.detach(); } + let provider: Arc = provider; + if self + .providers + .get(&id) + .is_none_or(|registered| !Arc::ptr_eq(registered, &provider)) + { + self.authentication_tasks.remove(&id); + } self.providers.insert(id.clone(), provider); cx.emit(Event::AddedProvider(id)); } pub fn unregister_provider(&mut self, id: LanguageModelProviderId, cx: &mut Context) { if self.providers.remove(&id).is_some() { + self.authentication_tasks.remove(&id); cx.emit(Event::RemovedProvider(id)); } } + pub fn authenticate_providers(&mut self, cx: &mut Context) { + self.authenticate_providers_with_retry(false, cx); + } + + pub fn retry_authentication(&mut self, cx: &mut Context) { + self.authenticate_providers_with_retry(true, cx); + } + pub fn providers(&self) -> Vec> { let zed_provider_id = LanguageModelProviderId("zed.dev".into()); let mut providers = Vec::with_capacity(self.providers.len()); @@ -522,6 +541,83 @@ impl LanguageModelRegistry { pub fn inline_alternative_models(&self) -> &[LanguageModel] { &self.inline_alternatives } + + fn authenticate_providers_with_retry(&mut self, retry: bool, cx: &mut Context) { + for provider in self.visible_providers() { + let provider_id = provider.id(); + if let Some(task) = self.authentication_tasks.get(&provider_id) { + if !retry { + let registry = cx.weak_entity(); + cx.defer(move |cx| { + if registry + .read_with(cx, |registry, _| { + registry + .providers + .get(&provider_id) + .is_some_and(|registered| Arc::ptr_eq(registered, &provider)) + }) + .unwrap_or(false) + { + provider.refresh_models(cx); + } + }); + continue; + } + if !task.is_ready() { + continue; + } + } + if retry && provider.is_authenticated(cx) { + continue; + } + self.authentication_tasks.insert( + provider_id.clone(), + cx.spawn(async move |registry, cx| { + if let Err(error) = cx.update(|cx| provider.authenticate(cx)).await { + match error { + 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. + } + AuthenticateError::ConnectionRefused => { + // Not logging connection refused errors as they are mostly from LM Studio's noisy auth failures. + // LM Studio only has one auth method (endpoint call) which fails for users who haven't enabled it. + // TODO: Better manage LM Studio auth logic to avoid these noisy failures. + } + _ => { + // 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: {}: {error:#}", + provider.name().0 + ), + } + } + } + } + registry + .update(cx, |registry, cx| registry.refresh_fallback_model(cx)) + .ok(); + }), + ); + } + } } #[cfg(test)] diff --git a/crates/language_models/Cargo.toml b/crates/language_models/Cargo.toml index 2f686eda178..f29a2908c1b 100644 --- a/crates/language_models/Cargo.toml +++ b/crates/language_models/Cargo.toml @@ -74,6 +74,7 @@ x_ai_subscribed.workspace = true client = { workspace = true, features = ["test-support"] } clock = { workspace = true, features = ["test-support"] } cloud_llm_client.workspace = true +credentials_provider = { workspace = true, features = ["test-support"] } db = { workspace = true, features = ["test-support"] } feature_flags.workspace = true gpui = { workspace = true, features = ["test-support"] } diff --git a/crates/language_models/src/language_models.rs b/crates/language_models/src/language_models.rs index 5d064f486c6..0432a9785f5 100644 --- a/crates/language_models/src/language_models.rs +++ b/crates/language_models/src/language_models.rs @@ -35,6 +35,7 @@ use crate::provider::x_ai_subscribed::XAiSubscribedProvider; pub use crate::settings::*; pub fn init(user_store: Entity, client: Arc, cx: &mut App) { + language_model::set_credentials_read_gate::(ai_disabled, cx); let credentials_provider = client.credentials_provider(); let registry = LanguageModelRegistry::global(cx); registry.update(cx, |registry, cx| { @@ -139,6 +140,16 @@ pub fn init(user_store: Entity, client: Arc, cx: &mut App) { .detach(); } +fn ai_disabled(cx: &App) -> bool { + cx.try_global::().is_some_and(|store| { + store + .merged_settings() + .project + .disable_ai + .is_some_and(|disabled| disabled.0) + }) +} + #[derive(Default, PartialEq, Eq)] struct CompatibleProviders(HashMap, CompatibleProviderKind>); diff --git a/crates/language_models/src/provider/anthropic.rs b/crates/language_models/src/provider/anthropic.rs index 1fb61688745..01249518357 100644 --- a/crates/language_models/src/provider/anthropic.rs +++ b/crates/language_models/src/provider/anthropic.rs @@ -350,6 +350,14 @@ impl LanguageModelProvider for AnthropicLanguageModelProvider { self.state.update(cx, |state, cx| state.authenticate(cx)) } + fn refresh_models(&self, cx: &mut App) { + self.state.update(cx, |state, cx| { + if state.is_authenticated() { + state.restart_fetch_models_task(cx); + } + }); + } + fn settings_view(&self, cx: &mut App) -> Option { let state = self.state.read(cx); Some(ProviderSettingsView::ApiKey(ApiKeyConfiguration::new( diff --git a/crates/language_models/src/provider/bedrock.rs b/crates/language_models/src/provider/bedrock.rs index a05b1f31c60..e76d20f7b1a 100644 --- a/crates/language_models/src/provider/bedrock.rs +++ b/crates/language_models/src/provider/bedrock.rs @@ -564,10 +564,10 @@ impl State { } // Try keychain - let (_, credentials_bytes) = credentials_provider - .read_credentials(AMAZON_AWS_URL, cx) - .await? - .ok_or(AuthenticateError::CredentialsNotFound)?; + let (_, credentials_bytes) = + language_model::read_credentials(credentials_provider.as_ref(), AMAZON_AWS_URL, cx) + .await? + .ok_or(AuthenticateError::CredentialsNotFound)?; let credentials_str = String::from_utf8(credentials_bytes) .with_context(|| format!("invalid {PROVIDER_NAME} credentials"))?; diff --git a/crates/language_models/src/provider/google.rs b/crates/language_models/src/provider/google.rs index e202f00e07b..f1d79bec5af 100644 --- a/crates/language_models/src/provider/google.rs +++ b/crates/language_models/src/provider/google.rs @@ -339,6 +339,11 @@ impl LanguageModelProvider for GoogleLanguageModelProvider { self.state.update(cx, |state, cx| state.authenticate(cx)) } + fn refresh_models(&self, cx: &mut App) { + self.state + .update(cx, |state, cx| state.restart_fetch_models_task(cx)); + } + fn settings_view(&self, cx: &mut App) -> Option { let state = self.state.read(cx); Some(ProviderSettingsView::ApiKey(ApiKeyConfiguration::new( diff --git a/crates/language_models/src/provider/llama_cpp.rs b/crates/language_models/src/provider/llama_cpp.rs index dc8238b950a..fe2caefead3 100644 --- a/crates/language_models/src/provider/llama_cpp.rs +++ b/crates/language_models/src/provider/llama_cpp.rs @@ -691,6 +691,11 @@ impl LanguageModelProvider for LlamaCppLanguageModelProvider { self.state.update(cx, |state, cx| state.authenticate(cx)) } + fn refresh_models(&self, cx: &mut App) { + self.state + .update(cx, |state, cx| state.restart_fetch_models_task(cx)); + } + fn settings_view(&self, _cx: &mut App) -> Option { let state = self.state.clone(); Some(ProviderSettingsView::SubPage( @@ -1470,47 +1475,13 @@ impl Render for ConfigurationView { #[cfg(test)] mod tests { use super::*; + use credentials_provider::test_support::FakeCredentialsProvider; use gpui::TestAppContext; use http_client::FakeHttpClient; - use language_model::LanguageModelToolUse; + use language_model::{LanguageModelRegistry, LanguageModelToolUse}; use parking_lot::Mutex; use std::sync::atomic::{AtomicUsize, Ordering}; - struct FakeCredentialsProvider { - api_key: Vec, - } - - impl CredentialsProvider for FakeCredentialsProvider { - fn read_credentials<'a>( - &'a self, - _url: &'a str, - _cx: &'a AsyncApp, - ) -> std::pin::Pin< - Box)>>> + 'a>, - > { - let api_key = self.api_key.clone(); - Box::pin(async move { Ok(Some(("Bearer".to_string(), api_key))) }) - } - - fn write_credentials<'a>( - &'a self, - _url: &'a str, - _username: &'a str, - _password: &'a [u8], - _cx: &'a AsyncApp, - ) -> std::pin::Pin> + 'a>> { - Box::pin(async { Ok(()) }) - } - - fn delete_credentials<'a>( - &'a self, - _url: &'a str, - _cx: &'a AsyncApp, - ) -> std::pin::Pin> + 'a>> { - Box::pin(async { Ok(()) }) - } - } - fn entry(id: &str, n_ctx: Option, n_ctx_train: Option) -> ModelEntry { ModelEntry { id: id.to_string(), @@ -1816,9 +1787,7 @@ mod tests { let provider = cx.update(|cx| { LlamaCppLanguageModelProvider::new( FakeHttpClient::with_404_response(), - Arc::new(FakeCredentialsProvider { - api_key: Vec::new(), - }), + Arc::new(FakeCredentialsProvider::default()), cx, ) }); @@ -1881,6 +1850,79 @@ mod tests { )); } + #[gpui::test] + fn registry_refreshes_models_while_credentials_are_pending(cx: &mut TestAppContext) { + cx.update(|cx| { + let settings_store = SettingsStore::test(cx); + cx.set_global(settings_store); + }); + let request_count = AtomicUsize::new(0); + let http_client = FakeHttpClient::create(move |request| { + let first_request = request_count.fetch_add(1, Ordering::SeqCst) == 0; + async move { + let (status, body) = match request.uri().path() { + "/v1/models" if first_request => (503, "not ready"), + "/v1/models" => (200, r#"{"data":[{"id":"refreshed-model"}]}"#), + "/props" => (200, "{}"), + path => anyhow::bail!("unexpected request: {path}"), + }; + Ok(http_client::Response::builder() + .status(status) + .body(http_client::AsyncBody::from(body))?) + } + }); + let credentials = Arc::new(FakeCredentialsProvider::default()); + let pending_credentials = credentials.defer_read(LLAMA_CPP_API_URL); + let provider = cx.update(|cx| { + let provider = Arc::new(LlamaCppLanguageModelProvider::new( + http_client, + credentials.clone(), + cx, + )); + provider.state.update(cx, |state, cx| { + state.api_key_state = ApiKeyState::new( + LlamaCppLanguageModelProvider::api_url(cx), + EnvVar { + name: SharedString::from(API_KEY_ENV_VAR_NAME), + value: None, + }, + ); + }); + provider + }); + cx.run_until_parked(); + let registry = cx.new(|_| LanguageModelRegistry::default()); + registry.update(cx, |registry, cx| { + registry.register_provider(provider.clone(), cx); + registry.authenticate_providers(cx); + }); + cx.run_until_parked(); + assert!(cx.update(|cx| provider.provided_models(cx).is_empty())); + credentials.assert_reads(&[LLAMA_CPP_API_URL]); + + registry.update(cx, |registry, cx| registry.authenticate_providers(cx)); + cx.run_until_parked(); + assert_eq!( + cx.update(|cx| provider + .provided_models(cx) + .into_iter() + .map(|model| model.id.0.to_string()) + .collect::>()), + ["refreshed-model"] + ); + credentials.assert_reads(&[LLAMA_CPP_API_URL]); + assert!(!pending_credentials.is_canceled()); + let provider_id = provider.id(); + drop(provider); + registry.update(cx, |registry, cx| { + registry.unregister_provider(provider_id, cx) + }); + cx.run_until_parked(); + cx.update(|_| ()); + cx.run_until_parked(); + assert!(pending_credentials.is_canceled()); + } + #[gpui::test] async fn authenticate_fetches_models_after_loading_api_key(cx: &mut TestAppContext) { cx.update(|cx| { @@ -1932,9 +1974,12 @@ mod tests { } } }); - let credentials_provider = Arc::new(FakeCredentialsProvider { - api_key: b"loaded-key".to_vec(), - }); + let credentials_provider = Arc::new(FakeCredentialsProvider::default()); + credentials_provider + .state + .lock() + .keys + .insert(LLAMA_CPP_API_URL.to_string(), b"loaded-key".to_vec()); let provider = cx .update(|cx| LlamaCppLanguageModelProvider::new(http_client, credentials_provider, cx)); @@ -1963,9 +2008,7 @@ mod tests { .status(500) .body(http_client::AsyncBody::from("server error"))?) }); - let credentials_provider = Arc::new(FakeCredentialsProvider { - api_key: b"test-key".to_vec(), - }); + let credentials_provider = Arc::new(FakeCredentialsProvider::default()); let provider = cx .update(|cx| LlamaCppLanguageModelProvider::new(http_client, credentials_provider, cx)); cx.run_until_parked(); diff --git a/crates/language_models/src/provider/lmstudio.rs b/crates/language_models/src/provider/lmstudio.rs index 1676c43d53a..4712c9075ee 100644 --- a/crates/language_models/src/provider/lmstudio.rs +++ b/crates/language_models/src/provider/lmstudio.rs @@ -140,7 +140,7 @@ impl State { fn authenticate(&mut self, cx: &mut Context) -> Task> { let credentials_provider = self.credentials_provider.clone(); let api_url = LmStudioLanguageModelProvider::api_url(cx).into(); - let _task = self.api_key_state.load_if_needed( + let load_key = self.api_key_state.load_if_needed( api_url, |this| &mut this.api_key_state, credentials_provider, @@ -151,8 +151,9 @@ impl State { return Task::ready(Ok(())); } - let fetch_models_task = self.fetch_models(cx); - cx.spawn(async move |_this, _cx| { + cx.spawn(async move |state, cx| { + load_key.await?; + let fetch_models_task = state.update(cx, |state, cx| state.fetch_models(cx))?; match fetch_models_task.await { Ok(()) => Ok(()), Err(err) => { @@ -329,6 +330,11 @@ impl LanguageModelProvider for LmStudioLanguageModelProvider { self.state.update(cx, |state, cx| state.authenticate(cx)) } + fn refresh_models(&self, cx: &mut App) { + self.state + .update(cx, |state, cx| state.restart_fetch_models_task(cx)); + } + fn settings_view(&self, _cx: &mut App) -> Option { let state = self.state.clone(); Some(ProviderSettingsView::SubPage( @@ -911,39 +917,72 @@ impl Render for ConfigurationView { #[cfg(test)] mod tests { use super::*; + use credentials_provider::test_support::FakeCredentialsProvider; use gpui::TestAppContext; - use http_client::FakeHttpClient; + use http_client::{AsyncBody, FakeHttpClient, Response}; - struct TestCredentialsProvider; - - impl CredentialsProvider for TestCredentialsProvider { - fn read_credentials<'a>( - &'a self, - _url: &'a str, - _cx: &'a AsyncApp, - ) -> std::pin::Pin< - Box)>>> + 'a>, - > { - Box::pin(async { Ok(None) }) - } - - fn write_credentials<'a>( - &'a self, - _url: &'a str, - _username: &'a str, - _password: &'a [u8], - _cx: &'a AsyncApp, - ) -> std::pin::Pin> + 'a>> { - Box::pin(async { Ok(()) }) - } - - fn delete_credentials<'a>( - &'a self, - _url: &'a str, - _cx: &'a AsyncApp, - ) -> std::pin::Pin> + 'a>> { - Box::pin(async { Ok(()) }) - } + #[gpui::test] + async fn enabling_ai_discovers_models_with_stored_credentials(cx: &mut TestAppContext) { + cx.update(|cx| { + let mut store = SettingsStore::test(cx); + store.update_user_settings(cx, |settings| { + settings.project.disable_ai = Some(true.into()); + }); + cx.set_global(store); + language_model::set_credentials_read_gate::(crate::ai_disabled, cx); + }); + let credentials = Arc::new(FakeCredentialsProvider::default()); + credentials + .state + .lock() + .keys + .insert(LMSTUDIO_API_URL.to_string(), b"stored-key".to_vec()); + let client = FakeHttpClient::create(|request| async move { + if request + .headers() + .get("Authorization") + .and_then(|value| value.to_str().ok()) + != Some("Bearer stored-key") + { + return Ok(Response::builder().status(401).body(AsyncBody::default())?); + } + Ok(Response::builder().status(200).body(AsyncBody::from( + r#"{"data":[{"id":"stored-model","object":"model","type":"llm","publisher":"test","compatibility_type":"gguf","state":"loaded"}]}"#, + ))?) + }); + let provider = cx.update(|cx| { + let provider = LmStudioLanguageModelProvider::new(client, credentials.clone(), cx); + provider.state.update(cx, |state, _| { + state.api_key_state = ApiKeyState::new( + SharedString::from(LMSTUDIO_API_URL), + EnvVar { + name: SharedString::from("TEST_API_KEY"), + value: None, + }, + ); + }); + provider + }); + let authentication = cx.update(|cx| provider.authenticate(cx)); + cx.run_until_parked(); + credentials.assert_reads(&[]); + cx.update_global::(|store, cx| { + store.update_user_settings(cx, |settings| { + settings.project.disable_ai = Some(false.into()); + }); + }); + authentication + .await + .expect("authentication after enabling AI"); + assert_eq!( + cx.update(|cx| provider + .provided_models(cx) + .into_iter() + .map(|model| model.id.0.to_string()) + .collect::>()), + ["stored-model"] + ); + credentials.assert_reads(&[LMSTUDIO_API_URL]); } #[gpui::test] @@ -959,7 +998,11 @@ mod tests { .body(http_client::AsyncBody::from("server error"))?) }); let provider = cx.update(|cx| { - LmStudioLanguageModelProvider::new(http_client, Arc::new(TestCredentialsProvider), cx) + LmStudioLanguageModelProvider::new( + http_client, + Arc::new(FakeCredentialsProvider::default()), + cx, + ) }); cx.run_until_parked(); diff --git a/crates/language_models/src/provider/ollama.rs b/crates/language_models/src/provider/ollama.rs index 59eb2be05ba..88348ac4ea2 100644 --- a/crates/language_models/src/provider/ollama.rs +++ b/crates/language_models/src/provider/ollama.rs @@ -501,6 +501,11 @@ impl LanguageModelProvider for OllamaLanguageModelProvider { self.state.update(cx, |state, cx| state.authenticate(cx)) } + fn refresh_models(&self, cx: &mut App) { + self.state + .update(cx, |state, cx| state.restart_fetch_models_task(cx)); + } + fn settings_view(&self, _cx: &mut App) -> Option { let state = self.state.clone(); Some(ProviderSettingsView::SubPage( diff --git a/crates/language_models/src/provider/open_router.rs b/crates/language_models/src/provider/open_router.rs index 7d77650f233..9d71eecc277 100644 --- a/crates/language_models/src/provider/open_router.rs +++ b/crates/language_models/src/provider/open_router.rs @@ -350,6 +350,11 @@ impl LanguageModelProvider for OpenRouterLanguageModelProvider { self.state.update(cx, |state, cx| state.authenticate(cx)) } + fn refresh_models(&self, cx: &mut App) { + self.state + .update(cx, |state, cx| state.restart_fetch_models_task(cx)); + } + fn settings_view(&self, cx: &mut App) -> Option { let state = self.state.read(cx); Some(ProviderSettingsView::ApiKey(ApiKeyConfiguration::new( diff --git a/crates/language_models/src/provider/opencode.rs b/crates/language_models/src/provider/opencode.rs index 2b3cc4495d5..93660b28a55 100644 --- a/crates/language_models/src/provider/opencode.rs +++ b/crates/language_models/src/provider/opencode.rs @@ -528,6 +528,11 @@ impl LanguageModelProvider for OpenCodeLanguageModelProvider { self.state.update(cx, |state, cx| state.authenticate(cx)) } + fn refresh_models(&self, cx: &mut App) { + self.state + .update(cx, |state, cx| state.restart_fetch_models_task(cx)); + } + fn settings_view(&self, _cx: &mut App) -> Option { let state = self.state.clone(); Some(ProviderSettingsView::SubPage( diff --git a/crates/language_models/src/provider/vercel_ai_gateway.rs b/crates/language_models/src/provider/vercel_ai_gateway.rs index 91dc463d205..8e23f16a2a9 100644 --- a/crates/language_models/src/provider/vercel_ai_gateway.rs +++ b/crates/language_models/src/provider/vercel_ai_gateway.rs @@ -313,6 +313,11 @@ impl LanguageModelProvider for VercelAiGatewayLanguageModelProvider { self.state.update(cx, |state, cx| state.authenticate(cx)) } + fn refresh_models(&self, cx: &mut App) { + self.state + .update(cx, |state, cx| state.restart_fetch_models_task(cx)); + } + fn settings_view(&self, cx: &mut App) -> Option { let state = self.state.read(cx); Some(ProviderSettingsView::ApiKey(ApiKeyConfiguration::new( diff --git a/crates/openai_subscribed/src/openai_subscribed.rs b/crates/openai_subscribed/src/openai_subscribed.rs index 439fd3fdf97..c65cdcf6191 100644 --- a/crates/openai_subscribed/src/openai_subscribed.rs +++ b/crates/openai_subscribed/src/openai_subscribed.rs @@ -120,10 +120,16 @@ impl State { .spawn({ let credentials_provider = credentials_provider.clone(); async move |this, cx| { - let result = credentials_provider - .read_credentials(CREDENTIALS_KEY, cx) - .await; + let result = language_model::read_credentials( + credentials_provider.as_ref(), + CREDENTIALS_KEY, + cx, + ) + .await; let refresh_models_task = this.update(cx, |state, cx| { + if state.auth_generation != 0 { + return None; + } match result { Ok(Some((_, bytes))) => { match serde_json::from_slice::(&bytes) { @@ -1715,7 +1721,7 @@ mod tests { ))?) }); - let state = cx.new(|cx| State::new(http, creds_provider, cx)); + let state = cx.new(|cx| State::new(http.clone(), creds_provider.clone(), cx)); let load_task = cx .read(|cx| state.read(cx).load_task()) @@ -1733,6 +1739,25 @@ mod tests { Some("gpt-account-default") ); }); + + let state = cx.new(|cx| State::new(http, creds_provider, cx)); + state.update(cx, |state, _| state.auth_generation += 1); + let load_task = cx + .read(|cx| state.read(cx).load_task()) + .expect("constructor should start the credentials load"); + cx.run_until_parked(); + load_task.await.expect("stale load should complete"); + cx.read(|cx| { + let state = state.read(cx); + assert_eq!( + state + .credentials + .as_ref() + .map(|creds| creds.access_token.as_str()), + None + ); + assert!(state.load_task().is_none()); + }); } #[gpui::test] diff --git a/crates/settings_ui/Cargo.toml b/crates/settings_ui/Cargo.toml index 861b71e221c..b0b2f7c00fd 100644 --- a/crates/settings_ui/Cargo.toml +++ b/crates/settings_ui/Cargo.toml @@ -76,6 +76,7 @@ zed_actions.workspace = true zed_credentials_provider.workspace = true [dev-dependencies] +credentials_provider = { workspace = true, features = ["test-support"] } fs = { workspace = true, features = ["test-support"] } futures.workspace = true gpui = { workspace = true, features = ["test-support"] } diff --git a/crates/settings_ui/src/settings_ui.rs b/crates/settings_ui/src/settings_ui.rs index a4299ce1dd6..96371f98a15 100644 --- a/crates/settings_ui/src/settings_ui.rs +++ b/crates/settings_ui/src/settings_ui.rs @@ -18,7 +18,7 @@ use gpui::{ use language::Buffer; use platform_title_bar::PlatformTitleBar; -use project::{Project, ProjectPath, Worktree, WorktreeId}; +use project::{DisableAiSettings, Project, ProjectPath, Worktree, WorktreeId}; use release_channel::ReleaseChannel; use schemars::JsonSchema; use serde::Deserialize; @@ -4349,6 +4349,7 @@ impl SettingsWindow { self.sandbox_host_validation_error = None; self.sub_page_stack .push(SubPage::new(sub_page_link, section_header)); + self.retry_llm_provider_authentication(cx); self.content_focus_handle.focus_handle(cx).focus(window, cx); cx.notify(); } @@ -4559,10 +4560,22 @@ impl SettingsWindow { { self.skill_creator_page = None; } + self.retry_llm_provider_authentication(cx); self.content_focus_handle.focus_handle(cx).focus(window, cx); cx.notify(); } + fn retry_llm_provider_authentication(&self, cx: &mut Context) { + if self.sub_page_stack.last().is_some_and(|sub_page| { + sub_page.link.json_path == Some("llm_providers") + && sub_page.link.title.as_ref() == "LLM Providers" + }) && !DisableAiSettings::get_global(cx).disable_ai + { + language_model::LanguageModelRegistry::global(cx) + .update(cx, |registry, cx| registry.retry_authentication(cx)); + } + } + pub(crate) fn active_project(&self, cx: &App) -> Option> { let original_window = self.original_window.as_ref()?; let multi_workspace = original_window.read(cx).ok()?; @@ -5427,6 +5440,9 @@ fn render_icon_theme_picker( pub mod test { use super::*; + use credentials_provider::test_support::FakeCredentialsProvider; + use language_model::{ApiKeyState, EnvVar, LanguageModelProviderState, LanguageModelRegistry}; + use language_models::provider::open_ai_compatible::OpenAiCompatibleLanguageModelProvider; impl SettingsWindow { fn navbar_entry(&self) -> usize { @@ -7286,6 +7302,76 @@ pub mod test { .unwrap(); } + #[gpui::test] + fn test_llm_provider_authentication_and_settings_retry(cx: &mut gpui::TestAppContext) { + let url = "https://settings-provider.example/v1"; + let credentials = Arc::new(FakeCredentialsProvider::default()); + let release = credentials.defer_read(url); + let provider = cx.update(|cx| { + register_settings(cx); + let app_state = AppState::test(cx); + AppState::set_global(app_state.clone(), cx); + let settings = r#"{"language_models":{"openai_compatible":{ + "settings-retry":{"api_url":"https://settings-provider.example/v1", + "available_models":[]} + }}}"#; + cx.update_global::(|store, cx| { + store + .set_user_settings(settings, cx) + .expect("provider settings"); + }); + let provider = Arc::new(OpenAiCompatibleLanguageModelProvider::new( + Arc::from("settings-retry"), + app_state.client.http_client(), + credentials.clone(), + cx, + )); + let env_var = EnvVar { + name: SharedString::from("TEST_SETTINGS_API_KEY"), + value: None, + }; + let state = provider.observable_entity().expect("provider state"); + state.update(cx, |state, _| { + state.api_key_state = ApiKeyState::new(SharedString::from(url), env_var); + }); + LanguageModelRegistry::global(cx).update(cx, |registry, cx| { + registry.register_provider(provider.clone(), cx); + registry.authenticate_providers(cx); + }); + provider + }); + let (settings_window, cx) = + cx.add_window_view(|window, cx| SettingsWindow::new(None, window, cx)); + cx.run_until_parked(); + for release in [None, Some(release)] { + if let Some(release) = release { + release.send(()).expect("authentication remains live"); + cx.run_until_parked(); + } + cx.cx.update(|cx| { + LanguageModelRegistry::global(cx).update(cx, |registry, cx| { + registry.register_provider(provider.clone(), cx); + registry.authenticate_providers(cx); + registry.authenticate_providers(cx); + }); + }); + cx.run_until_parked(); + credentials.assert_reads(&[url]); + } + cx.cx + .update(|cx| open_settings_editor(Some("llm_providers"), None, None, cx)); + cx.run_until_parked(); + credentials.assert_reads(&[url; 2]); + settings_window.update(cx, |_, cx| cx.notify()); + cx.draw( + point(px(0.), px(0.)), + gpui::size(px(1000.), px(700.)), + |_, _| settings_window.clone().into_any_element(), + ); + cx.run_until_parked(); + credentials.assert_reads(&[url; 2]); + } + fn settings_window_with_items( items: Vec, window: &mut Window, diff --git a/crates/x_ai_subscribed/src/x_ai_subscribed.rs b/crates/x_ai_subscribed/src/x_ai_subscribed.rs index 88610c9a9ad..2c7604daf63 100644 --- a/crates/x_ai_subscribed/src/x_ai_subscribed.rs +++ b/crates/x_ai_subscribed/src/x_ai_subscribed.rs @@ -92,10 +92,18 @@ impl State { .spawn({ let credentials_provider = credentials_provider.clone(); async move |this, cx| { - let result = credentials_provider - .read_credentials(CREDENTIALS_KEY, cx) - .await; + let result = language_model::read_credentials( + credentials_provider.as_ref(), + CREDENTIALS_KEY, + cx, + ) + .await; this.update(cx, |state, cx| { + state.load_task = None; + cx.notify(); + if state.auth_generation != 0 { + return; + } match result { Ok(Some((_, bytes))) => { match serde_json::from_slice::(&bytes) { @@ -116,8 +124,6 @@ impl State { log::error!("Failed to load SuperGrok credentials: {error:#}"); } } - state.load_task = None; - cx.notify(); })?; Ok::<(), Arc>(()) } @@ -1321,7 +1327,7 @@ mod tests { .status(200) .body(http_client::AsyncBody::default())?) }); - let state = cx.new(|cx| State::new(http, creds_provider, cx)); + let state = cx.new(|cx| State::new(http.clone(), creds_provider.clone(), cx)); let load_task = cx .read(|cx| state.read(cx).load_task()) .expect("constructor should start the credentials load"); @@ -1334,6 +1340,25 @@ mod tests { assert!(state.is_authenticated()); assert!(state.load_task().is_none()); }); + + let state = cx.new(|cx| State::new(http, creds_provider, cx)); + state.update(cx, |state, _| state.auth_generation += 1); + let load_task = cx + .read(|cx| state.read(cx).load_task()) + .expect("constructor should start the credentials load"); + cx.run_until_parked(); + load_task.await.expect("stale load should complete"); + cx.read(|cx| { + let state = state.read(cx); + assert_eq!( + state + .credentials + .as_ref() + .map(|creds| creds.access_token.as_str()), + None + ); + assert!(state.load_task().is_none()); + }); } struct FakeCredentialsProvider {