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.

open_router: Support effort-based reasoning (#61308)

Kim Wittenburga1cc2548f98d
diff --git a/crates/language_models/src/provider/open_router.rs b/crates/language_models/src/provider/open_router.rs
index 47bf634d9e9..e05c47beccf 100644
--- a/crates/language_models/src/provider/open_router.rs
+++ b/crates/language_models/src/provider/open_router.rs
@@ -6,15 +6,17 @@ use gpui::{App, AppContext, AsyncApp, Context, Entity, SharedString, Task};
use http_client::{CustomHeaders, HttpClient};
use language_model::{
ApiKeyConfiguration, ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, LanguageModel,
- LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName,
- LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName,
- LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice,
- LanguageModelToolResultContent, LanguageModelToolSchemaFormat, LanguageModelToolUse,
- MessageContent, ProviderSettingsView, RateLimiter, Role, StopReason, TokenUsage, env_var,
+ LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelEffortLevel,
+ LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId,
+ LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest,
+ LanguageModelToolChoice, LanguageModelToolResultContent, LanguageModelToolSchemaFormat,
+ LanguageModelToolUse, MessageContent, ProviderSettingsView, RateLimiter, Role, StopReason,
+ TokenUsage, env_var,
};
use open_ai::completion::ReasoningDetailsAccumulator;
use open_router::{
- Model, ModelMode as OpenRouterModelMode, OPEN_ROUTER_API_URL, ResponseStreamEvent, list_models,
+ Model, ModelMode as OpenRouterModelMode, OPEN_ROUTER_API_URL, ReasoningEffort,
+ ResponseStreamEvent, list_models,
};
use settings::{OpenRouterAvailableModel as AvailableModel, Settings, SettingsStore};
use sha2::{Digest as _, Sha256};
@@ -222,13 +224,27 @@ impl LanguageModelProvider for OpenRouterLanguageModelProvider {
let mut settings_models = Vec::new();
for model in &Self::settings(cx).available_models {
+ let mode = model.mode.unwrap_or_default();
+ let (supported_efforts, default_effort) =
+ if matches!(mode, OpenRouterModelMode::Adaptive) {
+ (
+ model.reasoning_effort.into_iter().collect(),
+ model.reasoning_effort,
+ )
+ } else {
+ (Vec::new(), None)
+ };
settings_models.push(open_router::Model {
name: model.name.clone(),
display_name: model.display_name.clone(),
max_tokens: model.max_tokens,
supports_tools: model.supports_tools,
supports_images: model.supports_images,
- mode: model.mode.unwrap_or_default(),
+ mode,
+ supported_efforts,
+ default_effort,
+ supports_max_tokens: false,
+ mandatory_reasoning: false,
provider: model.provider.clone(),
});
}
@@ -351,7 +367,37 @@ impl LanguageModel for OpenRouterLanguageModel {
}
fn supports_thinking(&self) -> bool {
- matches!(self.model.mode, OpenRouterModelMode::Thinking { .. })
+ matches!(
+ self.model.mode,
+ OpenRouterModelMode::Thinking { .. } | OpenRouterModelMode::Adaptive
+ )
+ }
+
+ fn supports_disabling_thinking(&self) -> bool {
+ !self.model.mandatory_reasoning
+ }
+
+ fn supported_effort_levels(&self) -> Vec<LanguageModelEffortLevel> {
+ let efforts: &[ReasoningEffort] = if !self.model.supported_efforts.is_empty() {
+ &self.model.supported_efforts
+ } else if self.model.supports_max_tokens {
+ &ReasoningEffort::OPENAI_COMPATIBLE_SELECTABLE
+ } else {
+ return Vec::new();
+ };
+ let default_effort = self.model.default_effort.or_else(|| {
+ self.model
+ .supports_max_tokens
+ .then_some(ReasoningEffort::Medium)
+ });
+ efforts
+ .iter()
+ .map(|&effort| LanguageModelEffortLevel {
+ name: effort.label().into(),
+ value: effort.value().into(),
+ is_default: Some(effort) == default_effort,
+ })
+ .collect()
}
fn tool_input_format(&self) -> LanguageModelToolSchemaFormat {
@@ -575,23 +621,40 @@ pub fn into_open_router(
stop: request.stop,
temperature: request.temperature.unwrap_or(0.4),
max_tokens: max_output_tokens,
- parallel_tool_calls: if model.supports_parallel_tool_calls() && !request.tools.is_empty() {
- Some(false)
- } else {
- None
- },
+ parallel_tool_calls: (!request.tools.is_empty() && !model.supports_parallel_tool_calls())
+ .then_some(false),
usage: open_router::RequestUsage { include: true },
- reasoning: if request.thinking_allowed
- && let OpenRouterModelMode::Thinking { budget_tokens } = model.mode
- {
- Some(open_router::Reasoning {
- effort: None,
- max_tokens: budget_tokens,
- exclude: Some(false),
- enabled: Some(true),
- })
- } else {
- None
+ reasoning: match model.mode {
+ OpenRouterModelMode::Adaptive if request.thinking_allowed => {
+ Some(open_router::Reasoning {
+ enabled: Some(true),
+ effort: request
+ .thinking_effort
+ .as_deref()
+ .and_then(|e| e.parse::<ReasoningEffort>().ok()),
+ max_tokens: None,
+ exclude: None,
+ })
+ }
+ OpenRouterModelMode::Thinking { budget_tokens } if request.thinking_allowed => {
+ Some(open_router::Reasoning {
+ enabled: Some(true),
+ effort: None,
+ max_tokens: budget_tokens,
+ exclude: None,
+ })
+ }
+ OpenRouterModelMode::Adaptive | OpenRouterModelMode::Thinking { .. }
+ if !model.mandatory_reasoning =>
+ {
+ Some(open_router::Reasoning {
+ enabled: Some(false),
+ effort: None,
+ max_tokens: None,
+ exclude: None,
+ })
+ }
+ _ => None,
},
tools: request
.tools
@@ -1098,6 +1161,9 @@ mod tests {
Some(false),
None,
None,
+ None,
+ false,
+ None,
);
let thread_id = "internal-thread-id";
let request = LanguageModelRequest {
@@ -1134,6 +1200,9 @@ mod tests {
Some(false),
None,
None,
+ None,
+ false,
+ None,
);
let request = LanguageModelRequest {
@@ -1285,6 +1354,9 @@ mod tests {
Some(false),
None,
None,
+ None,
+ false,
+ None,
);
let request = LanguageModelRequest {
@@ -1348,6 +1420,9 @@ mod tests {
Some(false),
None,
None,
+ None,
+ false,
+ None,
);
let request = LanguageModelRequest {
@@ -1400,4 +1475,83 @@ mod tests {
}
}
}
+
+ #[gpui::test]
+ async fn test_into_open_router_sends_requested_effort() {
+ let model = open_router::Model::new(
+ "z-ai/glm-5.2",
+ Some("GLM 5.2"),
+ Some(1_048_576),
+ Some(true),
+ Some(false),
+ Some(OpenRouterModelMode::Adaptive),
+ Some(vec![
+ open_router::ReasoningEffort::XHigh,
+ open_router::ReasoningEffort::High,
+ ]),
+ Some(open_router::ReasoningEffort::High),
+ false,
+ None,
+ );
+ let request = LanguageModelRequest {
+ messages: vec![language_model::LanguageModelRequestMessage {
+ role: Role::User,
+ content: vec![MessageContent::Text("Hello".to_string())],
+ cache: false,
+ reasoning_details: None,
+ }],
+ thinking_allowed: true,
+ thinking_effort: Some("xhigh".to_string()),
+ ..Default::default()
+ };
+
+ let result = into_open_router(request, &model, None).unwrap();
+ let reasoning = result.reasoning.expect("reasoning should be set");
+ assert_eq!(reasoning.effort, Some(open_router::ReasoningEffort::XHigh));
+ assert_eq!(
+ reasoning.max_tokens, None,
+ "max_tokens should not be sent when effort is used"
+ );
+ assert_eq!(reasoning.exclude, None);
+ assert_eq!(reasoning.enabled, Some(true));
+ }
+
+ #[gpui::test]
+ async fn test_into_open_router_disables_reasoning_when_thinking_not_allowed() {
+ let model = open_router::Model::new(
+ "z-ai/glm-5.2",
+ Some("GLM 5.2"),
+ Some(1_048_576),
+ Some(true),
+ Some(false),
+ Some(OpenRouterModelMode::Adaptive),
+ Some(vec![
+ open_router::ReasoningEffort::XHigh,
+ open_router::ReasoningEffort::High,
+ ]),
+ Some(open_router::ReasoningEffort::High),
+ false,
+ None,
+ );
+ let request = LanguageModelRequest {
+ messages: vec![language_model::LanguageModelRequestMessage {
+ role: Role::User,
+ content: vec![MessageContent::Text("Hello".to_string())],
+ cache: false,
+ reasoning_details: None,
+ }],
+ thinking_allowed: false,
+ thinking_effort: Some("high".to_string()),
+ ..Default::default()
+ };
+
+ let result = into_open_router(request, &model, None).unwrap();
+ let reasoning = result.reasoning.expect("reasoning should be set");
+ assert_eq!(reasoning.enabled, Some(false));
+ assert_eq!(
+ reasoning.effort, None,
+ "effort should not be sent when reasoning is disabled"
+ );
+ assert_eq!(reasoning.max_tokens, None);
+ }
}
diff --git a/crates/open_router/src/open_router.rs b/crates/open_router/src/open_router.rs
index 36ac81a2b60..14cb90079e0 100644
--- a/crates/open_router/src/open_router.rs
+++ b/crates/open_router/src/open_router.rs
@@ -3,6 +3,7 @@ use futures::{AsyncReadExt, StreamExt, stream::BoxStream};
use http_client::{
AsyncBody, CustomHeaders, HttpClient, Method, Request as HttpRequest, RequestBuilderExt, http,
};
+pub use language_model_core::ReasoningEffort;
use open_ai::ChatCompletionStreamEvent;
use serde::{Deserialize, Serialize};
use serde_json::Value;
@@ -81,6 +82,12 @@ pub struct Model {
pub supports_images: Option<bool>,
#[serde(default)]
pub mode: ModelMode,
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub supported_efforts: Vec<ReasoningEffort>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub default_effort: Option<ReasoningEffort>,
+ pub supports_max_tokens: bool,
+ pub mandatory_reasoning: bool,
pub provider: Option<Provider>,
}
@@ -94,6 +101,9 @@ impl Model {
Some(false),
Some(ModelMode::Default),
None,
+ None,
+ false,
+ None,
)
}
@@ -104,6 +114,9 @@ impl Model {
supports_tools: Option<bool>,
supports_images: Option<bool>,
mode: Option<ModelMode>,
+ supported_efforts: Option<Vec<ReasoningEffort>>,
+ default_effort: Option<ReasoningEffort>,
+ supports_max_tokens: bool,
provider: Option<Provider>,
) -> Self {
Self {
@@ -113,6 +126,10 @@ impl Model {
supports_tools,
supports_images,
mode: mode.unwrap_or(ModelMode::Default),
+ supported_efforts: supported_efforts.unwrap_or_default(),
+ default_effort,
+ supports_max_tokens,
+ mandatory_reasoning: false,
provider,
}
}
@@ -138,7 +155,7 @@ impl Model {
}
pub fn supports_parallel_tool_calls(&self) -> bool {
- false
+ true
}
}
@@ -200,7 +217,7 @@ pub struct FunctionDefinition {
#[derive(Debug, Serialize, Deserialize)]
pub struct Reasoning {
#[serde(skip_serializing_if = "Option::is_none")]
- pub effort: Option<String>,
+ pub effort: Option<ReasoningEffort>,
#[serde(skip_serializing_if = "Option::is_none")]
pub max_tokens: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
@@ -481,6 +498,8 @@ pub struct ModelEntry {
pub supported_parameters: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub architecture: Option<ModelArchitecture>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub reasoning: Option<ModelReasoning>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
@@ -489,6 +508,20 @@ pub struct ModelArchitecture {
pub input_modalities: Vec<String>,
}
+#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
+pub struct ModelReasoning {
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub default_effort: Option<ReasoningEffort>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub default_enabled: Option<bool>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub mandatory: Option<bool>,
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub supported_efforts: Vec<ReasoningEffort>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub supports_max_tokens: Option<bool>,
+}
+
pub async fn stream_completion(
client: &dyn HttpClient,
api_url: &str,
@@ -610,12 +643,29 @@ pub async fn list_models(
.supported_parameters
.contains(&"reasoning".to_string())
{
- ModelMode::Thinking {
- budget_tokens: Some(4_096),
- }
+ ModelMode::Adaptive
} else {
ModelMode::Default
},
+ supported_efforts: entry
+ .reasoning
+ .as_ref()
+ .map(|r| r.supported_efforts.clone())
+ .unwrap_or_default()
+ .into_iter()
+ .rev()
+ .collect(),
+ default_effort: entry.reasoning.as_ref().and_then(|r| r.default_effort),
+ supports_max_tokens: entry
+ .reasoning
+ .as_ref()
+ .and_then(|r| r.supports_max_tokens)
+ .unwrap_or(false),
+ mandatory_reasoning: entry
+ .reasoning
+ .as_ref()
+ .and_then(|r| r.mandatory)
+ .unwrap_or(false),
provider: None,
})
.collect();
diff --git a/crates/settings_content/src/language_model.rs b/crates/settings_content/src/language_model.rs
index 06239c76c2b..94d49f90eca 100644
--- a/crates/settings_content/src/language_model.rs
+++ b/crates/settings_content/src/language_model.rs
@@ -590,6 +590,7 @@ pub struct OpenRouterAvailableModel {
pub supports_tools: Option<bool>,
pub supports_images: Option<bool>,
pub mode: Option<ModelMode>,
+ pub reasoning_effort: Option<ReasoningEffort>,
pub provider: Option<OpenRouterProvider>,
}