Add harness availability model to the client.

Author: liliwilson

Cargo.lock

@@ -36,6 +36,7 @@ use crate::ai::conversation_details_panel::{
     ConversationDetailsData, ConversationDetailsPanel, ConversationDetailsPanelEvent,
 };
 use crate::ai::conversation_status_ui::render_status_element;
+use crate::ai::harness_availability::HarnessAvailabilityModel;
 use crate::ai::harness_display;
 use crate::app_state::PersistedAgentManagementFilters;
 use crate::appearance::Appearance;
@@ -222,6 +223,13 @@ impl AgentManagementView {
             Self::handle_agent_management_model_event,
         );
 
+        ctx.subscribe_to_model(
+            &HarnessAvailabilityModel::handle(ctx),
+            |me, _, _event, ctx| {
+                me.update_harness_dropdown(ctx);
+            },
+        );
+
         let list_state = Self::construct_fresh_list_state(ctx.handle());
 
         let all_filter_button = ctx.add_typed_action_view(|_ctx| {
@@ -672,15 +680,25 @@ impl AgentManagementView {
         let mut dropdown = Dropdown::new(ctx);
         Self::setup_filter_menu(&mut dropdown, "Harness", ctx);
 
-        // "All" has no leading icon, matching the Status dropdown's "All" row.
+        let items = Self::build_harness_dropdown_items(ctx);
+        dropdown.set_rich_items(items, ctx);
+        dropdown.set_selected_by_index(0, ctx);
+        dropdown
+    }
+
+    fn build_harness_dropdown_items(
+        app: &AppContext,
+    ) -> Vec<MenuItem<DropdownAction<AgentManagementViewAction>>> {
         let mut items = vec![MenuItem::Item(
             MenuItemFields::new("All").with_on_select_action(DropdownAction::SelectActionAndClose(
                 AgentManagementViewAction::SetHarnessFilter(HarnessFilter::All),
             )),
         )];
 
-        for harness in [Harness::Oz, Harness::Claude, Harness::Gemini] {
-            let mut fields = MenuItemFields::new(harness_display::display_name(harness))
+        let availability = HarnessAvailabilityModel::as_ref(app);
+        for entry in availability.available_harnesses() {
+            let harness = entry.harness;
+            let mut fields = MenuItemFields::new(entry.display_name.clone())
                 .with_icon(harness_display::icon_for(harness))
                 .with_on_select_action(DropdownAction::SelectActionAndClose(
                     AgentManagementViewAction::SetHarnessFilter(HarnessFilter::Specific(harness)),
@@ -691,9 +709,7 @@ impl AgentManagementView {
             items.push(MenuItem::Item(fields));
         }
 
-        dropdown.set_rich_items(items, ctx);
-        dropdown.set_selected_by_index(0, ctx);
-        dropdown
+        items
     }
 
     fn create_environment_dropdown(
@@ -755,6 +771,13 @@ impl AgentManagementView {
         dropdown.set_button_variant(ButtonVariant::Secondary);
     }
 
+    fn update_harness_dropdown(&mut self, ctx: &mut ViewContext<Self>) {
+        let items = Self::build_harness_dropdown_items(ctx);
+        self.harness_dropdown.update(ctx, |dropdown, ctx| {
+            dropdown.set_rich_items(items, ctx);
+        });
+    }
+
     /// Since the valid set of environments depends on what tasks we have loaded in,
     /// we use this function to update the available options depending on the most recent
     /// set of tasks.
@@ -1836,11 +1859,12 @@ impl AgentManagementView {
             metadata_parts.push(format!("Source: {}", source.display_name()));
         }
 
-        if FeatureFlag::AgentHarness.is_enabled() {
+        let availability = HarnessAvailabilityModel::as_ref(app);
+        if availability.should_show_harness_selector() {
             if let Some(harness) = card_data.harness(app) {
                 metadata_parts.push(format!(
                     "Harness: {}",
-                    harness_display::display_name(harness)
+                    availability.display_name_for(harness)
                 ));
             }
         }
@@ -1972,7 +1996,7 @@ impl AgentManagementView {
                 .with_child(ChildView::new(&self.created_on_dropdown).finish())
                 .with_child(ChildView::new(&self.artifact_dropdown).finish());
 
-            if FeatureFlag::AgentHarness.is_enabled() {
+            if HarnessAvailabilityModel::as_ref(app).should_show_harness_selector() {
                 filters_wrap.add_child(ChildView::new(&self.harness_dropdown).finish());
             }
 

app/src/ai/agent_management/view.rs

@@ -9,7 +9,6 @@ use pathfinder_color::ColorU;
 use warp_cli::agent::Harness;
 use warp_cli::skill::SkillSpec;
 use warp_core::channel::ChannelState;
-use warp_core::features::FeatureFlag;
 use warp_core::ui::color::coloru_with_opacity;
 use warpui::{
     clipboard::ClipboardContent,
@@ -39,6 +38,7 @@ use crate::ai::ambient_agents::{cancel_task_with_toast, AmbientAgentTaskId};
 use crate::ai::artifacts::{Artifact, ArtifactButtonsRow, ArtifactButtonsRowEvent};
 use crate::ai::blocklist::BlocklistAIHistoryModel;
 use crate::ai::cloud_environments::{AmbientAgentEnvironment, CloudAmbientAgentEnvironment};
+use crate::ai::harness_availability::HarnessAvailabilityModel;
 use crate::ai::harness_display;
 use crate::appearance::Appearance;
 use crate::auth::UserUid;
@@ -982,8 +982,13 @@ impl ConversationDetailsPanel {
         )
     }
 
-    fn render_harness_section(&self, appearance: &Appearance) -> Option<Box<dyn Element>> {
-        if !FeatureFlag::AgentHarness.is_enabled() {
+    fn render_harness_section(
+        &self,
+        appearance: &Appearance,
+        app: &AppContext,
+    ) -> Option<Box<dyn Element>> {
+        let availability = HarnessAvailabilityModel::as_ref(app);
+        if !availability.should_show_harness_selector() {
             return None;
         }
         let harness = self.data.harness?;
@@ -1012,7 +1017,7 @@ impl ConversationDetailsPanel {
         .finish();
 
         let name = Text::new(
-            harness_display::display_name(harness).to_string(),
+            availability.display_name_for(harness).to_string(),
             appearance.ui_font_family(),
             ui_font_size,
         )
@@ -1659,7 +1664,7 @@ impl View for ConversationDetailsPanel {
             );
         }
 
-        if let Some(harness_section) = self.render_harness_section(appearance) {
+        if let Some(harness_section) = self.render_harness_section(appearance, app) {
             content.add_child(
                 Container::new(harness_section)
                     .with_margin_bottom(FIELD_SPACING)

app/src/ai/conversation_details_panel.rs

@@ -0,0 +1,155 @@
+use serde::{Deserialize, Serialize};
+use warp_cli::agent::Harness;
+use warp_core::features::FeatureFlag;
+use warp_core::user_preferences::GetUserPreferences;
+use warpui::{Entity, ModelContext, SingletonEntity};
+
+use crate::ai::harness_display;
+use crate::auth::auth_manager::{AuthManager, AuthManagerEvent};
+use crate::auth::AuthStateProvider;
+use crate::network::{NetworkStatus, NetworkStatusEvent, NetworkStatusKind};
+use crate::report_error;
+use crate::server::server_api::ServerApiProvider;
+use crate::workspaces::user_workspaces::{UserWorkspaces, UserWorkspacesEvent};
+
+const CACHE_KEY: &str = "AvailableHarnesses";
+
+/// Server-resolved harness availability entry.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HarnessAvailability {
+    pub harness: Harness,
+    pub display_name: String,
+    pub enabled: bool,
+}
+
+/// Default fallback used before the server responds.
+/// Oz is enabled by default so the UI is usable pre-fetch; the server
+/// list (which respects admin overrides) replaces this once available.
+fn default_harnesses() -> Vec<HarnessAvailability> {
+    vec![HarnessAvailability {
+        harness: Harness::Oz,
+        display_name: "Warp".to_string(),
+        enabled: true,
+    }]
+}
+
+pub enum HarnessAvailabilityEvent {
+    Changed,
+}
+
+pub struct HarnessAvailabilityModel {
+    harnesses: Vec<HarnessAvailability>,
+}
+
+impl HarnessAvailabilityModel {
+    pub fn new(ctx: &mut ModelContext<Self>) -> Self {
+        let harnesses = get_cached(ctx).unwrap_or_else(default_harnesses);
+
+        ctx.subscribe_to_model(&NetworkStatus::handle(ctx), |me, event, ctx| {
+            if let NetworkStatusEvent::NetworkStatusChanged {
+                new_status: NetworkStatusKind::Online,
+            } = event
+            {
+                me.refresh(ctx);
+            }
+        });
+
+        ctx.subscribe_to_model(&AuthManager::handle(ctx), |me, event, ctx| {
+            if let AuthManagerEvent::AuthComplete = event {
+                me.refresh(ctx);
+            }
+        });
+
+        ctx.subscribe_to_model(&UserWorkspaces::handle(ctx), |me, event, ctx| {
+            if let UserWorkspacesEvent::TeamsChanged = event {
+                me.refresh(ctx);
+            }
+        });
+
+        let me = Self { harnesses };
+        me.refresh(ctx);
+        me
+    }
+
+    pub fn available_harnesses(&self) -> &[HarnessAvailability] {
+        &self.harnesses
+    }
+
+    pub fn display_name_for(&self, harness: Harness) -> &str {
+        self.harnesses
+            .iter()
+            .find(|h| h.harness == harness)
+            .map(|h| h.display_name.as_str())
+            .unwrap_or_else(|| harness_display::display_name(harness))
+    }
+
+    pub fn enabled_harness_count(&self) -> usize {
+        self.harnesses.iter().filter(|h| h.enabled).count()
+    }
+
+    /// Whether the harness selector should be shown (>1 enabled harness).
+    pub fn should_show_harness_selector(&self) -> bool {
+        FeatureFlag::AgentHarness.is_enabled() && self.enabled_harness_count() > 1
+    }
+
+    /// Whether any harness is available at all (at least one enabled).
+    pub fn has_any_enabled_harness(&self) -> bool {
+        self.harnesses.iter().any(|h| h.enabled)
+    }
+
+    /// Whether a harness is both known and enabled.
+    pub fn is_harness_enabled(&self, harness: Harness) -> bool {
+        self.harnesses
+            .iter()
+            .any(|h| h.harness == harness && h.enabled)
+    }
+
+    pub fn refresh(&self, ctx: &mut ModelContext<Self>) {
+        // The endpoint queries `user`, which requires auth.
+        if !AuthStateProvider::as_ref(ctx).get().is_logged_in() {
+            return;
+        }
+
+        let ai_client = ServerApiProvider::as_ref(ctx).get_ai_client();
+        ctx.spawn(
+            async move { ai_client.get_available_harnesses().await },
+            |me, result, ctx| match result {
+                Ok(new_harnesses) => {
+                    if new_harnesses != me.harnesses {
+                        me.harnesses = new_harnesses;
+                        me.cache(ctx);
+                        ctx.emit(HarnessAvailabilityEvent::Changed);
+                    }
+                }
+                Err(e) => {
+                    report_error!(e.context("Failed to fetch available harnesses"));
+                }
+            },
+        );
+    }
+
+    fn cache(&self, ctx: &ModelContext<Self>) {
+        if let Ok(serialized) = serde_json::to_string(&self.harnesses) {
+            if let Err(e) = ctx
+                .private_user_preferences()
+                .write_value(CACHE_KEY, serialized)
+            {
+                report_error!(anyhow::anyhow!(e).context("Failed to cache available harnesses"));
+            }
+        }
+    }
+}
+
+fn get_cached(ctx: &ModelContext<HarnessAvailabilityModel>) -> Option<Vec<HarnessAvailability>> {
+    let raw = ctx
+        .private_user_preferences()
+        .read_value(CACHE_KEY)
+        .ok()??;
+    serde_json::from_str::<Vec<HarnessAvailability>>(&raw).ok()
+}
+
+impl Entity for HarnessAvailabilityModel {
+    type Event = HarnessAvailabilityEvent;
+}
+
+impl SingletonEntity for HarnessAvailabilityModel {}

app/src/ai/harness_availability.rs

@@ -24,6 +24,7 @@ pub(crate) mod conversation_status_ui;
 pub(crate) mod conversation_utils;
 pub(crate) mod document;
 pub(crate) mod get_relevant_files;
+pub mod harness_availability;
 pub(crate) mod harness_display;
 pub(crate) mod llms;
 pub mod onboarding;

app/src/ai/mod.rs

@@ -196,6 +196,7 @@ use workflows::manager::WorkflowManager;
 use crate::ai::ambient_agents::github_auth_notifier::GitHubAuthNotifier;
 use crate::ai::document::ai_document_model::AIDocumentModel;
 use crate::ai::facts::manager::AIFactManager;
+use crate::ai::harness_availability::HarnessAvailabilityModel;
 use crate::ai::llms::LLMPreferences;
 use crate::ai::mcp::MCPGalleryManager;
 use crate::ai::mcp::TemplatableMCPServerManager;
@@ -1794,6 +1795,7 @@ fn initialize_app(
     ctx.add_singleton_model(LocalWorkflows::new);
 
     ctx.add_singleton_model(LLMPreferences::new);
+    ctx.add_singleton_model(HarnessAvailabilityModel::new);
 
     ctx.add_singleton_model(|ctx| {
         ai::agent_tips::AITipModel::<ai::AgentTip>::new_for_agent_tips(ctx)