Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

agent_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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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<LanguageModelEffor
name: 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.rs
index 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.rs
index 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.rs
index 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<LanguageModel
name: 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.rs
index 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<LanguageModel
name: 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.rs
index 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.rs
index 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.rs
index 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<LanguageModelEff
name: 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.rs
index 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) -> LanguageModel
name: 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.rs
index 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.rs
index 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<LanguageModel
name: name.into(),
value: value.into(),
is_default: Some(effort) == default_effort,
+ supports_disabling_thinking: None,
})
})
.collect()