Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
agent_ui: Respect effort-specific thinking controls (#62480)
Tom Houlé9f63850f7aff
diff --git a/crates/agent/src/tests/mod.rs b/crates/agent/src/tests/mod.rsindex b4382df7b93..8cf42ea3923 100644--- a/crates/agent/src/tests/mod.rs+++ b/crates/agent/src/tests/mod.rs@@ -573,6 +573,39 @@ async fn test_thinking_allowed_when_model_cannot_disable_thinking(cx: &mut TestA.unwrap();assert!(request.thinking_allowed);});++ // A model-level capability can be overridden by the selected effort.+ fake.update_model("fake", |model| {+ model.supported_effort_levels = [+ language_model::LanguageModelEffortLevel {+ name: "High".into(),+ value: "high".into(),+ is_default: true,+ supports_disabling_thinking: Some(true),+ },+ language_model::LanguageModelEffortLevel {+ name: "Max".into(),+ value: "max".into(),+ is_default: false,+ supports_disabling_thinking: None,+ },+ ]+ .into();+ });+ thread.update(cx, |thread, cx| {+ thread.refresh_model(&model.provider_id, cx);+ thread.set_thinking_effort(Some("high".to_string()), cx);+ let request = thread+ .build_completion_request(CompletionIntent::UserPrompt, cx)+ .unwrap();+ assert!(!request.thinking_allowed);++ thread.set_thinking_effort(Some("max".to_string()), cx);+ let request = thread+ .build_completion_request(CompletionIntent::UserPrompt, cx)+ .unwrap();+ assert!(request.thinking_allowed);+ });}#[gpui::test]diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rsindex 83f64a86e29..a2583e39d7a 100644--- a/crates/agent/src/thread.rs+++ b/crates/agent/src/thread.rs@@ -4407,7 +4407,8 @@ impl Thread {// Models that can't run with thinking disabled ignore the// toggle state, which may be stale from a previously selected// model that could.- thinking_allowed: self.thinking_enabled || !model.supports_disabling_thinking(),+ thinking_allowed: self.thinking_enabled+ || !model.supports_disabling_thinking_at_effort(self.thinking_effort.as_deref()),thinking_effort: self.thinking_effort.clone(),speed: self.speed(),compact_at_tokens: None,diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rsindex 45e186655ee..54bebf50f6f 100644--- a/crates/agent_ui/src/conversation_view/thread_view.rs+++ b/crates/agent_ui/src/conversation_view/thread_view.rs@@ -5807,35 +5807,40 @@ impl ThreadView {return None;}- // A toggle would be dishonest for models that always think: only- // offer the effort selector.- if !model.supports_disabling_thinking() {- let effort_levels = model.supported_effort_levels();+ let effort_levels = model.supported_effort_levels();+ let selected_effort = thread.thinking_effort().cloned();+ let supports_disabling_thinking =+ model.supports_disabling_thinking_at_effort(selected_effort.as_deref());+ let supports_disabling_thinking_at_any_effort = supports_disabling_thinking+ || effort_levels.iter().any(|effort_level| {+ model.supports_disabling_thinking_at_effort(Some(effort_level.value.as_ref()))+ });++ // A toggle would be dishonest for models that always think at every+ // effort level: only offer the effort selector.+ if !supports_disabling_thinking_at_any_effort {if effort_levels.is_empty() {return None;}return Some(- self.render_effort_selector(- effort_levels,- thread.thinking_effort().cloned(),- true,- cx,- )- .into_any_element(),+ self.render_effort_selector(effort_levels, selected_effort, true, cx)+ .into_any_element(),);}- let thinking = thread.thinking_enabled();+ let thinking = thread.thinking_enabled() || !supports_disabling_thinking;- let (tooltip_label, icon, color) = if thinking {+ let (tooltip_label, icon, color) = if !supports_disabling_thinking {+ (None, IconName::ThinkingMode, Color::Accent)+ } else if thinking {(- "Disable Thinking Mode",+ Some("Disable Thinking Mode"),IconName::ThinkingMode,Color::Accent,)} else {(- "Enable Thinking Mode",+ Some("Enable Thinking Mode"),IconName::ThinkingModeOff,Color::Custom(cx.theme().colors().icon_disabled.opacity(0.8)),)@@ -5846,10 +5851,24 @@ impl ThreadView {let thinking_toggle = IconButton::new("thinking-mode", icon).icon_size(IconSize::Small).icon_color(color)- .tooltip(move |_, cx| {- Tooltip::for_action_in(tooltip_label, &ToggleThinkingMode, &focus_handle, cx)- })- .on_click(cx.listener(move |this, _, _window, cx| {+ .map(|this| {+ if let Some(tooltip_label) = tooltip_label {+ this.tooltip(move |_, cx| {+ Tooltip::for_action_in(+ tooltip_label,+ &ToggleThinkingMode,+ &focus_handle,+ cx,+ )+ })+ } else {+ this.tooltip(Tooltip::text(+ "Thinking is always on at this effort level. Select a lower effort level to make it optional.",+ ))+ }+ });+ let thinking_toggle = if supports_disabling_thinking {+ thinking_toggle.on_click(cx.listener(move |this, _, _window, cx| {if let Some(thread) = this.as_native_thread(cx) {thread.update(cx, |thread, cx| {let enable_thinking = !thread.thinking_enabled();@@ -5875,23 +5894,21 @@ impl ThreadView {});});}- }));+ }))+ } else {+ thinking_toggle.cursor_style(gpui::CursorStyle::Arrow)+ };- if model.supported_effort_levels().is_empty() {+ if effort_levels.is_empty() {return Some(thinking_toggle.into_any_element());}- if !model.supported_effort_levels().is_empty() && !thinking {+ if !thinking {return Some(thinking_toggle.into_any_element());}let left_btn = thinking_toggle;- let right_btn = self.render_effort_selector(- model.supported_effort_levels(),- thread.thinking_effort().cloned(),- false,- cx,- );+ let right_btn = self.render_effort_selector(effort_levels, selected_effort, false, cx);Some(SplitButton::new(left_btn, right_btn.into_any_element())@@ -13013,7 +13030,11 @@ impl ThreadView {let Some(model) = thread_ref.model() else {return;};- if !model.supports_thinking() || !thread_ref.thinking_enabled() {+ let thinking_enabled = thread_ref.thinking_enabled()+ || !model.supports_disabling_thinking_at_effort(+ thread_ref.thinking_effort().map(String::as_str),+ );+ if !model.supports_thinking() || !thinking_enabled {return;}let effort_levels = model.supported_effort_levels();@@ -13213,9 +13234,11 @@ impl Render for ThreadView {}if let Some(thread) = this.as_native_thread(cx) {thread.update(cx, |thread, cx| {- let model_allows_disabling = thread- .model()- .is_none_or(|model| model.supports_disabling_thinking());+ let model_allows_disabling = thread.model().is_none_or(|model| {+ model.supports_disabling_thinking_at_effort(+ thread.thinking_effort().map(String::as_str),+ )+ });if model_allows_disabling {thread.set_thinking_enabled(!thread.thinking_enabled(), cx);}diff --git a/crates/cloud_llm_client/src/cloud_llm_client.rs b/crates/cloud_llm_client/src/cloud_llm_client.rsindex 167507e86a3..2999d5638f7 100644--- a/crates/cloud_llm_client/src/cloud_llm_client.rs+++ b/crates/cloud_llm_client/src/cloud_llm_client.rs@@ -337,6 +337,10 @@ pub struct SupportedEffortLevel {pub value: Arc<str>,#[serde(default, skip_serializing_if = "Option::is_none")]pub is_default: Option<bool>,+ /// Overrides the model-level `supports_disabling_thinking` capability for+ /// this effort level when present.+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub supports_disabling_thinking: Option<bool>,}#[derive(Debug, Serialize, Deserialize)]@@ -378,4 +382,23 @@ mod tests {assert!(limit.is_err());}}++ #[test]+ fn test_supported_effort_level_deserializes_disabling_thinking_support() {+ let effort_level = serde_json::from_value::<SupportedEffortLevel>(serde_json::json!({+ "name": "High",+ "value": "high",+ "is_default": true,+ "supports_disabling_thinking": true+ }))+ .expect("effort level should deserialize");+ assert_eq!(effort_level.supports_disabling_thinking, Some(true));++ let effort_level = serde_json::from_value::<SupportedEffortLevel>(serde_json::json!({+ "name": "Max",+ "value": "max"+ }))+ .expect("effort level without an override should deserialize");+ assert_eq!(effort_level.supports_disabling_thinking, None);+ }}diff --git a/crates/copilot_chat/src/model.rs b/crates/copilot_chat/src/model.rsindex 25f18894e0d..975244924c0 100644--- a/crates/copilot_chat/src/model.rs+++ b/crates/copilot_chat/src/model.rs@@ -53,6 +53,7 @@ pub fn language_model(model: &CopilotChatModel) -> LanguageModel {name,value: language_model::SharedString::from(level.clone()),is_default: level == "high",+ supports_disabling_thinking: None,}}).collect()diff --git a/crates/language_model/src/language_model.rs b/crates/language_model/src/language_model.rsindex 62e0675343b..67f2cdeaf75 100644--- a/crates/language_model/src/language_model.rs+++ b/crates/language_model/src/language_model.rs@@ -280,6 +280,24 @@ impl LanguageModel {self.supports_disabling_thinking}+ /// Whether thinking can be turned off at the selected effort level.+ pub fn supports_disabling_thinking_at_effort(&self, effort: Option<&str>) -> bool {+ let effort_level = match effort {+ Some(effort) => self+ .supported_effort_levels+ .iter()+ .find(|effort_level| effort_level.value.as_ref() == effort),+ None => self+ .supported_effort_levels+ .iter()+ .find(|effort_level| effort_level.is_default),+ };++ effort_level+ .and_then(|effort_level| effort_level.supports_disabling_thinking)+ .unwrap_or(self.supports_disabling_thinking)+ }+pub fn supports_fast_mode(&self) -> bool {self.supports_fast_mode}diff --git a/crates/language_model_core/src/language_model_core.rs b/crates/language_model_core/src/language_model_core.rsindex 244a5e6e8e0..3e13f1dc51a 100644--- a/crates/language_model_core/src/language_model_core.rs+++ b/crates/language_model_core/src/language_model_core.rs@@ -694,6 +694,7 @@ pub struct LanguageModelEffortLevel {pub name: SharedString,pub value: SharedString,pub is_default: bool,+ pub supports_disabling_thinking: Option<bool>,}/// An error that occurred when trying to authenticate the language model provider.diff --git a/crates/language_models/src/provider/anthropic.rs b/crates/language_models/src/provider/anthropic.rsindex 0201a371c65..ca57042fa68 100644--- a/crates/language_models/src/provider/anthropic.rs+++ b/crates/language_models/src/provider/anthropic.rs@@ -948,6 +948,7 @@ fn language_model(model: &anthropic::Model) -> LanguageModel {name,value,is_default,+ supports_disabling_thinking: None,}}).collect(),diff --git a/crates/language_models/src/provider/anthropic_compatible.rs b/crates/language_models/src/provider/anthropic_compatible.rsindex d18015d1fae..10d62f1f496 100644--- a/crates/language_models/src/provider/anthropic_compatible.rs+++ b/crates/language_models/src/provider/anthropic_compatible.rs@@ -224,6 +224,7 @@ impl AnthropicCompatibleLanguageModelProvider {name,value,is_default,+ supports_disabling_thinking: None,}}).collect(),diff --git a/crates/language_models/src/provider/bedrock.rs b/crates/language_models/src/provider/bedrock.rsindex e69d0a6dc35..a05b1f31c60 100644--- a/crates/language_models/src/provider/bedrock.rs+++ b/crates/language_models/src/provider/bedrock.rs@@ -1004,26 +1004,31 @@ fn converse_language_model(model: &ConverseModel) -> LanguageModel {name: "Low".into(),value: "low".into(),is_default: false,+ supports_disabling_thinking: None,},language_model::LanguageModelEffortLevel {name: "Medium".into(),value: "medium".into(),is_default: is_gpt_6_astra,+ supports_disabling_thinking: None,},language_model::LanguageModelEffortLevel {name: "High".into(),value: "high".into(),is_default: !is_gpt_6_astra,+ supports_disabling_thinking: None,},language_model::LanguageModelEffortLevel {name: "XHigh".into(),value: "xhigh".into(),is_default: false,+ supports_disabling_thinking: None,},language_model::LanguageModelEffortLevel {name: "Max".into(),value: "max".into(),is_default: false,+ supports_disabling_thinking: None,},].into_iter()@@ -1229,6 +1234,7 @@ fn mantle_supported_effort_levels(model: &MantleModel) -> Vec<LanguageModelEfforname: effort.label().into(),value: effort.value().into(),is_default: effort == default_effort,+ supports_disabling_thinking: None,}).collect()}diff --git a/crates/language_models/src/provider/deepseek.rs b/crates/language_models/src/provider/deepseek.rsindex 4f12b33327e..a921b1e7752 100644--- a/crates/language_models/src/provider/deepseek.rs+++ b/crates/language_models/src/provider/deepseek.rs@@ -311,16 +311,19 @@ fn language_model(model: &deepseek::Model) -> LanguageModel {name: "Low".into(),value: "low".into(),is_default: false,+ supports_disabling_thinking: None,},LanguageModelEffortLevel {name: "High".into(),value: "high".into(),is_default: true,+ supports_disabling_thinking: None,},LanguageModelEffortLevel {name: "Max".into(),value: "max".into(),is_default: false,+ supports_disabling_thinking: None,},])} else {diff --git a/crates/language_models/src/provider/google.rs b/crates/language_models/src/provider/google.rsindex dc8092498e1..9d1eccb7ca1 100644--- a/crates/language_models/src/provider/google.rs+++ b/crates/language_models/src/provider/google.rs@@ -406,6 +406,7 @@ fn language_model(model: &google_ai::Model) -> LanguageModel {name: level.name().into(),value: level.value().into(),is_default: Some(*level) == model.default_thinking_level,+ supports_disabling_thinking: None,}).collect(),tool_choice_support: LanguageModelToolChoiceSupport::ALL,diff --git a/crates/language_models/src/provider/open_ai.rs b/crates/language_models/src/provider/open_ai.rsindex 1a8aba0e069..c6d429d4a1c 100644--- a/crates/language_models/src/provider/open_ai.rs+++ b/crates/language_models/src/provider/open_ai.rs@@ -608,6 +608,7 @@ fn supported_thinking_effort_levels(model: &open_ai::Model) -> Vec<LanguageModelname: effort.label().into(),value: effort.value().into(),is_default: Some(effort) == default_effort,+ supports_disabling_thinking: None,})}).collect()diff --git a/crates/language_models/src/provider/open_ai_compatible.rs b/crates/language_models/src/provider/open_ai_compatible.rsindex 370da2c290e..6ffb6520d07 100644--- a/crates/language_models/src/provider/open_ai_compatible.rs+++ b/crates/language_models/src/provider/open_ai_compatible.rs@@ -370,6 +370,7 @@ fn supported_thinking_effort_levels(model: &AvailableModel) -> Vec<LanguageModelname: effort.label().into(),value: effort.value().into(),is_default: effort == default_effort,+ supports_disabling_thinking: None,}).collect()}diff --git a/crates/language_models/src/provider/open_router.rs b/crates/language_models/src/provider/open_router.rsindex 5381b3a95cc..d0220cb33ad 100644--- a/crates/language_models/src/provider/open_router.rs+++ b/crates/language_models/src/provider/open_router.rs@@ -402,6 +402,7 @@ fn language_model(model: &open_router::Model) -> LanguageModel {name: effort.label().into(),value: effort.value().into(),is_default: Some(effort) == default_effort,+ supports_disabling_thinking: None,}).collect();LanguageModel {diff --git a/crates/language_models/src/provider/opencode.rs b/crates/language_models/src/provider/opencode.rsindex 342885d9a20..1db81bb6ae2 100644--- a/crates/language_models/src/provider/opencode.rs+++ b/crates/language_models/src/provider/opencode.rs@@ -979,6 +979,7 @@ fn language_model(model: &DiscoveredModel, subscription: OpenCodeSubscription) -name: name.into(),value: value.into(),is_default: i == default_index,+ supports_disabling_thinking: None,}}).collect()diff --git a/crates/language_models/src/provider/x_ai.rs b/crates/language_models/src/provider/x_ai.rsindex 205f734bfd5..167501c7e62 100644--- a/crates/language_models/src/provider/x_ai.rs+++ b/crates/language_models/src/provider/x_ai.rs@@ -380,6 +380,7 @@ fn supported_thinking_effort_levels(model: &x_ai::Model) -> Vec<LanguageModelEffname: name.into(),value: value.into(),is_default: Some(effort) == default_effort,+ supports_disabling_thinking: None,})}).collect()diff --git a/crates/language_models_cloud/src/language_models_cloud.rs b/crates/language_models_cloud/src/language_models_cloud.rsindex 513bf4966f1..3772c08458a 100644--- a/crates/language_models_cloud/src/language_models_cloud.rs+++ b/crates/language_models_cloud/src/language_models_cloud.rs@@ -537,6 +537,7 @@ pub fn language_model(model: &cloud_llm_client::LanguageModel) -> LanguageModelname: effort_level.name.clone().into(),value: effort_level.value.clone().into(),is_default: effort_level.is_default.unwrap_or(false),+ supports_disabling_thinking: effort_level.supports_disabling_thinking,}).collect(),supports_streaming_tools: model.supports_streaming_tools,@@ -2526,6 +2527,32 @@ mod tests {(test_provider(http_client, vec![config]), model)}+ #[test]+ fn test_disabling_thinking_support_uses_effort_level_override() {+ let mut config = cloud_anthropic_test_config();+ config.supports_disabling_thinking = false;+ config.supported_effort_levels = vec![+ cloud_llm_client::SupportedEffortLevel {+ name: Arc::from("High"),+ value: Arc::from("high"),+ is_default: Some(true),+ supports_disabling_thinking: Some(true),+ },+ cloud_llm_client::SupportedEffortLevel {+ name: Arc::from("Max"),+ value: Arc::from("max"),+ is_default: None,+ supports_disabling_thinking: None,+ },+ ];+ let model = language_model(&config);++ assert!(model.supports_disabling_thinking_at_effort(None));+ assert!(model.supports_disabling_thinking_at_effort(Some("high")));+ assert!(!model.supports_disabling_thinking_at_effort(Some("max")));+ assert!(!model.supports_disabling_thinking_at_effort(Some("unknown")));+ }+fn cloud_anthropic_test_config() -> cloud_llm_client::LanguageModel {cloud_llm_client::LanguageModel {provider: cloud_llm_client::LanguageModelProvider::Anthropic,diff --git a/crates/openai_subscribed/src/openai_subscribed.rs b/crates/openai_subscribed/src/openai_subscribed.rsindex ad737a93e0d..439fd3fdf97 100644--- a/crates/openai_subscribed/src/openai_subscribed.rs+++ b/crates/openai_subscribed/src/openai_subscribed.rs@@ -740,6 +740,7 @@ pub fn language_model(model: &ChatGptModel) -> LanguageModel {name: name.into(),value: value.into(),is_default: Some(effort) == default_effort,+ supports_disabling_thinking: None,})}).collect();diff --git a/crates/x_ai_subscribed/src/x_ai_subscribed.rs b/crates/x_ai_subscribed/src/x_ai_subscribed.rsindex d7628f18a4a..88610c9a9ad 100644--- a/crates/x_ai_subscribed/src/x_ai_subscribed.rs+++ b/crates/x_ai_subscribed/src/x_ai_subscribed.rs@@ -387,6 +387,7 @@ fn supported_thinking_effort_levels(model: &SuperGrokModel) -> Vec<LanguageModelname: name.into(),value: value.into(),is_default: Some(effort) == default_effort,+ supports_disabling_thinking: None,})}).collect()