Delete fetch_fallible for now

Co-authored-by: Mikayla Maki <mikayla.c.maki@gmail.com>

crates/acp_thread/src/connection.rs

@@ -3,11 +3,11 @@ use agent_client_protocol::{self as acp};
 use anyhow::Result;
 use collections::IndexMap;
 use gpui::{Entity, SharedString, Task};
-use language_model::LanguageModelProviderId;
+use language_model::{IconOrSvg, LanguageModelProviderId};
 use project::Project;
 use serde::{Deserialize, Serialize};
 use std::{any::Any, error::Error, fmt, path::Path, rc::Rc, sync::Arc};
-use ui::{App, IconName};
+use ui::App;
 use uuid::Uuid;
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
@@ -210,21 +210,12 @@ pub trait AgentModelSelector: 'static {
     }
 }
 
-/// Icon for a model in the model selector.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum AgentModelIcon {
-    /// A built-in icon from Zed's icon set.
-    Named(IconName),
-    /// Path to a custom SVG icon file.
-    Path(SharedString),
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct AgentModelInfo {
     pub id: acp::ModelId,
     pub name: SharedString,
     pub description: Option<SharedString>,
-    pub icon: Option<AgentModelIcon>,
+    pub icon: Option<IconOrSvg>,
 }
 
 impl From<acp::ModelInfo> for AgentModelInfo {

crates/agent/src/agent.rs

@@ -30,7 +30,7 @@ use futures::{StreamExt, future};
 use gpui::{
     App, AppContext, AsyncApp, Context, Entity, SharedString, Subscription, Task, WeakEntity,
 };
-use language_model::{IconOrSvg, LanguageModel, LanguageModelProvider, LanguageModelRegistry};
+use language_model::{LanguageModel, LanguageModelProvider, LanguageModelRegistry};
 use project::{Project, ProjectItem, ProjectPath, Worktree};
 use prompt_store::{
     ProjectContext, PromptStore, RULES_FILE_NAMES, RulesFileContext, UserRulesContext,
@@ -153,10 +153,7 @@ impl LanguageModels {
             id: Self::model_id(model),
             name: model.name().0,
             description: None,
-            icon: Some(match provider.icon() {
-                IconOrSvg::Svg(path) => acp_thread::AgentModelIcon::Path(path),
-                IconOrSvg::Icon(name) => acp_thread::AgentModelIcon::Named(name),
-            }),
+            icon: Some(provider.icon()),
         }
     }
 
@@ -1633,9 +1630,7 @@ mod internal_tests {
                     id: acp::ModelId::new("fake/fake"),
                     name: "Fake".into(),
                     description: None,
-                    icon: Some(acp_thread::AgentModelIcon::Named(
-                        ui::IconName::ZedAssistant
-                    )),
+                    icon: Some(language_model::IconOrSvg::Icon(ui::IconName::ZedAssistant)),
                 }]
             )])
         );

crates/agent_ui/src/acp/model_selector.rs

@@ -1,6 +1,6 @@
 use std::{cmp::Reverse, rc::Rc, sync::Arc};
 
-use acp_thread::{AgentModelIcon, AgentModelInfo, AgentModelList, AgentModelSelector};
+use acp_thread::{AgentModelInfo, AgentModelList, AgentModelSelector};
 use agent_client_protocol::ModelId;
 use agent_servers::AgentServer;
 use agent_settings::AgentSettings;
@@ -13,6 +13,7 @@ use gpui::{
     Action, AsyncWindowContext, BackgroundExecutor, DismissEvent, FocusHandle, Task, WeakEntity,
 };
 use itertools::Itertools;
+use language_model::IconOrSvg;
 use ordered_float::OrderedFloat;
 use picker::{Picker, PickerDelegate};
 use settings::Settings;
@@ -351,8 +352,8 @@ impl PickerDelegate for AcpModelPickerDelegate {
                         .child(
                             ModelSelectorListItem::new(ix, model_info.name.clone())
                                 .map(|this| match &model_info.icon {
-                                    Some(AgentModelIcon::Path(path)) => this.icon_path(path.clone()),
-                                    Some(AgentModelIcon::Named(icon)) => this.icon(*icon),
+                                    Some(IconOrSvg::Svg(path)) => this.icon_path(path.clone()),
+                                    Some(IconOrSvg::Icon(icon)) => this.icon(*icon),
                                     None => this,
                                 })
                                 .is_selected(is_selected)

crates/agent_ui/src/acp/model_selector_popover.rs

@@ -1,11 +1,12 @@
 use std::rc::Rc;
 use std::sync::Arc;
 
-use acp_thread::{AgentModelIcon, AgentModelInfo, AgentModelSelector};
+use acp_thread::{AgentModelInfo, AgentModelSelector};
 use agent_servers::AgentServer;
 use agent_settings::AgentSettings;
 use fs::Fs;
 use gpui::{Entity, FocusHandle};
+use language_model::IconOrSvg;
 use picker::popover_menu::PickerPopoverMenu;
 use settings::Settings as _;
 use ui::{ButtonLike, KeyBinding, PopoverMenuHandle, TintColor, Tooltip, prelude::*};
@@ -127,8 +128,8 @@ impl Render for AcpModelSelectorPopover {
                 .when_some(model_icon, |this, icon| {
                     this.child(
                         match icon {
-                            AgentModelIcon::Path(path) => Icon::from_external_svg(path),
-                            AgentModelIcon::Named(icon_name) => Icon::new(icon_name),
+                            IconOrSvg::Svg(path) => Icon::from_external_svg(path),
+                            IconOrSvg::Icon(icon_name) => Icon::new(icon_name),
                         }
                         .color(color)
                         .size(IconSize::XSmall),

crates/agent_ui/src/agent_ui.rs

@@ -361,33 +361,52 @@ fn init_language_model_settings(cx: &mut App) {
 fn update_active_language_model_from_settings(cx: &mut App) {
     let settings = AgentSettings::get_global(cx);
 
-    fn to_selected_model(selection: &LanguageModelSelection) -> language_model::SelectedModel {
-        language_model::SelectedModel {
-            provider: LanguageModelProviderId::from(selection.provider.0.clone()),
-            model: LanguageModelId::from(selection.model.clone()),
+    fn to_selected_model(
+        selection: &LanguageModelSelection,
+        registry: &LanguageModelRegistry,
+        cx: &App,
+    ) -> Option<language_model::SelectedModel> {
+        let provider_id = LanguageModelProviderId::from(selection.provider.0.clone());
+
+        if registry
+            .provider(&provider_id)
+            .map_or(false, |provider| provider.is_authenticated(cx))
+        {
+            Some(language_model::SelectedModel {
+                provider: LanguageModelProviderId::from(selection.provider.0.clone()),
+                model: LanguageModelId::from(selection.model.clone()),
+            })
+        } else {
+            None
         }
     }
 
-    let default = settings.default_model.as_ref().map(to_selected_model);
+    let registry = LanguageModelRegistry::global(cx);
+    let registry_ref = registry.read(cx);
+
+    let default = settings
+        .default_model
+        .as_ref()
+        .and_then(|s| to_selected_model(s, registry_ref, cx));
     let inline_assistant = settings
         .inline_assistant_model
         .as_ref()
-        .map(to_selected_model);
+        .and_then(|s| to_selected_model(s, registry_ref, cx));
     let commit_message = settings
         .commit_message_model
         .as_ref()
-        .map(to_selected_model);
+        .and_then(|s| to_selected_model(s, registry_ref, cx));
     let thread_summary = settings
         .thread_summary_model
         .as_ref()
-        .map(to_selected_model);
+        .and_then(|s| to_selected_model(s, registry_ref, cx));
     let inline_alternatives = settings
         .inline_alternatives
         .iter()
-        .map(to_selected_model)
+        .filter_map(|s| to_selected_model(s, registry_ref, cx))
         .collect::<Vec<_>>();
 
-    LanguageModelRegistry::global(cx).update(cx, |registry, cx| {
+    registry.update(cx, |registry, cx| {
         registry.select_default_model(default.as_ref(), cx);
         registry.select_inline_assistant_model(inline_assistant.as_ref(), cx);
         registry.select_commit_message_model(commit_message.as_ref(), cx);

crates/agent_ui/src/language_model_selector.rs

@@ -2,10 +2,9 @@ use std::{cmp::Reverse, sync::Arc};
 
 use agent_settings::AgentSettings;
 use collections::{HashMap, HashSet, IndexMap};
+use futures::{StreamExt, channel::mpsc};
 use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
-use gpui::{
-    Action, AnyElement, App, BackgroundExecutor, DismissEvent, FocusHandle, Subscription, Task,
-};
+use gpui::{Action, AnyElement, App, BackgroundExecutor, DismissEvent, FocusHandle, Task};
 use language_model::{
     AuthenticateError, ConfiguredModel, IconOrSvg, LanguageModel, LanguageModelId,
     LanguageModelProvider, LanguageModelProviderId, LanguageModelRegistry,
@@ -76,7 +75,7 @@ fn all_models(cx: &App) -> GroupedModels {
         })
         .collect();
 
-    let all = providers
+    let all: Vec<ModelInfo> = providers
         .iter()
         .flat_map(|provider| {
             provider
@@ -124,7 +123,7 @@ pub struct LanguageModelPickerDelegate {
     filtered_entries: Vec<LanguageModelPickerEntry>,
     selected_index: usize,
     _authenticate_all_providers_task: Task<()>,
-    _subscriptions: Vec<Subscription>,
+    _refresh_models_task: Task<()>,
     popover_styles: bool,
     focus_handle: FocusHandle,
 }
@@ -151,24 +150,42 @@ impl LanguageModelPickerDelegate {
             get_active_model: Arc::new(get_active_model),
             on_toggle_favorite: Arc::new(on_toggle_favorite),
             _authenticate_all_providers_task: Self::authenticate_all_providers(cx),
-            _subscriptions: vec![cx.subscribe_in(
-                &LanguageModelRegistry::global(cx),
-                window,
-                |picker, _, event, window, cx| {
-                    match event {
-                        language_model::Event::ProviderStateChanged(_)
-                        | language_model::Event::AddedProvider(_)
-                        | language_model::Event::RemovedProvider(_) => {
-                            let query = picker.query(cx);
-                            picker.delegate.all_models = Arc::new(all_models(cx));
-                            // Update matches will automatically drop the previous task
-                            // if we get a provider event again
-                            picker.update_matches(query, window, cx)
-                        }
-                        _ => {}
+            _refresh_models_task: {
+                // Create a channel to signal when models need refreshing
+                let (refresh_tx, mut refresh_rx) = mpsc::unbounded::<()>();
+
+                // Subscribe to registry events and send refresh signals through the channel
+                let registry = LanguageModelRegistry::global(cx);
+                cx.subscribe(&registry, move |_picker, _, event, _cx| match event {
+                    language_model::Event::ProviderStateChanged(_)
+                    | language_model::Event::AddedProvider(_)
+                    | language_model::Event::RemovedProvider(_)
+                    | language_model::Event::ProvidersChanged => {
+                        refresh_tx.unbounded_send(()).ok();
                     }
-                },
-            )],
+                    language_model::Event::DefaultModelChanged
+                    | language_model::Event::InlineAssistantModelChanged
+                    | language_model::Event::CommitMessageModelChanged
+                    | language_model::Event::ThreadSummaryModelChanged => {}
+                })
+                .detach();
+
+                // Spawn a task that listens for refresh signals and updates the picker
+                cx.spawn_in(window, async move |this, cx| {
+                    while let Some(()) = refresh_rx.next().await {
+                        if this
+                            .update_in(cx, |picker, window, cx| {
+                                picker.delegate.all_models = Arc::new(all_models(cx));
+                                picker.refresh(window, cx);
+                            })
+                            .is_err()
+                        {
+                            // Picker was dropped, exit the loop
+                            break;
+                        }
+                    }
+                })
+            },
             popover_styles,
             focus_handle,
         }

crates/extension_cli/src/main.rs

@@ -255,6 +255,21 @@ async fn copy_extension_resources(
         }
     }
 
+    for (_, provider_entry) in &manifest.language_model_providers {
+        if let Some(icon_path) = &provider_entry.icon {
+            let source_icon = extension_path.join(icon_path);
+            let dest_icon = output_dir.join(icon_path);
+
+            // Create parent directory if needed
+            if let Some(parent) = dest_icon.parent() {
+                fs::create_dir_all(parent)?;
+            }
+
+            fs::copy(&source_icon, &dest_icon)
+                .with_context(|| format!("failed to copy LLM provider icon '{}'", icon_path))?;
+        }
+    }
+
     if !manifest.languages.is_empty() {
         let output_languages_dir = output_dir.join("languages");
         fs::create_dir_all(&output_languages_dir)?;

crates/language_models/src/language_models.rs

@@ -12,12 +12,11 @@ pub mod provider;
 mod settings;
 
 pub use crate::extension::init_proxy as init_extension_proxy;
-
 use crate::provider::anthropic::AnthropicLanguageModelProvider;
 use crate::provider::bedrock::BedrockLanguageModelProvider;
 use crate::provider::cloud::CloudLanguageModelProvider;
 use crate::provider::copilot_chat::CopilotChatLanguageModelProvider;
-use crate::provider::google::GoogleLanguageModelProvider;
+pub use crate::provider::google::GoogleLanguageModelProvider;
 use crate::provider::lmstudio::LmStudioLanguageModelProvider;
 pub use crate::provider::mistral::MistralLanguageModelProvider;
 use crate::provider::ollama::OllamaLanguageModelProvider;
@@ -38,36 +37,41 @@ pub fn init(user_store: Entity<UserStore>, client: Arc<Client>, cx: &mut App) {
     if let Some(extension_store) = extension_host::ExtensionStore::try_global(cx) {
         cx.subscribe(&extension_store, {
             let registry = registry.clone();
-            move |extension_store, event, cx| match event {
-                extension_host::Event::ExtensionInstalled(extension_id) => {
-                    if let Some(manifest) = extension_store
-                        .read(cx)
-                        .extension_manifest_for_id(extension_id)
-                    {
-                        if !manifest.language_model_providers.is_empty() {
-                            registry.update(cx, |registry, cx| {
-                                registry.extension_installed(extension_id.clone(), cx);
-                            });
+            move |extension_store, event, cx| {
+                match event {
+                    extension_host::Event::ExtensionInstalled(extension_id) => {
+                        // Check if this extension has language_model_providers
+                        if let Some(manifest) = extension_store
+                            .read(cx)
+                            .extension_manifest_for_id(extension_id)
+                        {
+                            if !manifest.language_model_providers.is_empty() {
+                                registry.update(cx, |registry, cx| {
+                                    registry.extension_installed(extension_id.clone(), cx);
+                                });
+                            }
                         }
                     }
-                }
-                extension_host::Event::ExtensionUninstalled(extension_id) => {
-                    registry.update(cx, |registry, cx| {
-                        registry.extension_uninstalled(extension_id, cx);
-                    });
-                }
-                extension_host::Event::ExtensionsUpdated => {
-                    let mut new_ids = HashSet::default();
-                    for (extension_id, entry) in extension_store.read(cx).installed_extensions() {
-                        if !entry.manifest.language_model_providers.is_empty() {
-                            new_ids.insert(extension_id.clone());
-                        }
+                    extension_host::Event::ExtensionUninstalled(extension_id) => {
+                        registry.update(cx, |registry, cx| {
+                            registry.extension_uninstalled(extension_id, cx);
+                        });
                     }
-                    registry.update(cx, |registry, cx| {
-                        registry.sync_installed_llm_extensions(new_ids, cx);
-                    });
+                    extension_host::Event::ExtensionsUpdated => {
+                        // Re-sync installed extensions on bulk updates
+                        let mut new_ids = HashSet::default();
+                        for (extension_id, entry) in extension_store.read(cx).installed_extensions()
+                        {
+                            if !entry.manifest.language_model_providers.is_empty() {
+                                new_ids.insert(extension_id.clone());
+                            }
+                        }
+                        registry.update(cx, |registry, cx| {
+                            registry.sync_installed_llm_extensions(new_ids, cx);
+                        });
+                    }
+                    _ => {}
                 }
-                _ => {}
             }
         })
         .detach();

crates/language_models/src/provider/bedrock.rs

@@ -996,7 +996,7 @@ pub fn get_bedrock_tokens(
                 }
             }
 
-            // Tiktoken doesn't yet support these models, so we manually use the
+            // Tiktoken doesn't support these models, so we manually use the
             // same tokenizer as GPT-4.
             tiktoken_rs::num_tokens_from_messages("gpt-4", &string_messages)
                 .map(|tokens| (tokens + tokens_from_images) as u64)

crates/language_models/src/provider/google.rs

@@ -707,7 +707,7 @@ pub fn count_google_tokens(
             })
             .collect::<Vec<_>>();
 
-        // Tiktoken doesn't yet support these models, so we manually use the
+        // Tiktoken doesn't support these models, so we manually use the
         // same tokenizer as GPT-4.
         tiktoken_rs::num_tokens_from_messages("gpt-4", &messages).map(|tokens| tokens as u64)
     })

crates/zed/src/main.rs

@@ -564,6 +564,11 @@ pub fn main() {
         dap_adapters::init(cx);
         auto_update_ui::init(cx);
         reliability::init(client.clone(), cx);
+        // Initialize the language model registry first, then set up the extension proxy
+        // BEFORE extension_host::init so that extensions can register their LLM providers
+        // when they load.
+        language_model::init(app_state.client.clone(), cx);
+        language_models::init_extension_proxy(cx);
         extension_host::init(
             extension_host_proxy.clone(),
             app_state.fs.clone(),
@@ -589,7 +594,6 @@ pub fn main() {
             cx,
         );
         supermaven::init(app_state.client.clone(), cx);
-        language_model::init(app_state.client.clone(), cx);
         language_models::init(app_state.user_store.clone(), app_state.client.clone(), cx);
         acp_tools::init(cx);
         edit_prediction_ui::init(cx);