Add unified thinking effort control across all providers

crates/goose-cli/src/commands/configure.rs

@@ -23,8 +23,6 @@ use goose::model::ModelConfig;
 #[cfg(feature = "telemetry")]
 use goose::posthog::{get_telemetry_choice, TELEMETRY_ENABLED_KEY};
 use goose::providers::base::ConfigKey;
-use goose::providers::chatgpt_codex::reasoning_levels_for_model;
-use goose::providers::formats::anthropic::supports_adaptive_thinking;
 use goose::providers::provider_test::test_provider_configuration;
 use goose::providers::{create, providers, retry_operation, RetryConfig};
 use goose::session::SessionType;
@@ -738,15 +736,13 @@ pub async fn configure_provider_dialog() -> anyhow::Result<bool> {
 
     let spin = spinner();
     spin.start("Attempting to fetch supported models...");
-    let models_res = {
-        let temp_model_config =
-            ModelConfig::new(&provider_meta.default_model)?.with_canonical_limits(provider_name);
-        let temp_provider = create(provider_name, temp_model_config, Vec::new()).await?;
-        retry_operation(&RetryConfig::default(), || async {
-            temp_provider.fetch_recommended_models().await
-        })
-        .await
-    };
+    let temp_model_config =
+        ModelConfig::new(&provider_meta.default_model)?.with_canonical_limits(provider_name);
+    let temp_provider = create(provider_name, temp_model_config, Vec::new()).await?;
+    let models_res = retry_operation(&RetryConfig::default(), || async {
+        temp_provider.fetch_recommended_models().await
+    })
+    .await;
     spin.stop(style("Model fetch complete").green());
 
     // Select a model: on fetch error show styled error and abort; if models available, show list; otherwise free-text input
@@ -766,78 +762,24 @@ pub async fn configure_provider_dialog() -> anyhow::Result<bool> {
         }
     };
 
-    if model.to_lowercase().starts_with("gemini-3") {
-        let thinking_level: &str = cliclack::select("Select thinking level for Gemini 3:")
-            .item("low", "Low - Better latency, lighter reasoning", "")
-            .item("high", "High - Deeper reasoning, higher latency", "")
-            .interact()?;
-        config.set_gemini3_thinking_level(thinking_level)?;
-    }
-
-    if model.to_lowercase().starts_with("claude-") {
-        let supports_adaptive = supports_adaptive_thinking(&model);
-
-        let mut thinking_select = cliclack::select("Select extended thinking mode for Claude:");
-        if supports_adaptive {
-            thinking_select = thinking_select.item(
-                "adaptive",
-                "Adaptive - Claude decides when and how much to think (recommended)",
-                "",
-            );
-        }
-        thinking_select = thinking_select
-            .item("enabled", "Enabled - Fixed token budget for thinking", "")
-            .item("disabled", "Disabled - No extended thinking", "");
-        if supports_adaptive {
-            thinking_select = thinking_select.initial_value("adaptive");
-        } else {
-            thinking_select = thinking_select.initial_value("disabled");
-        }
-        let thinking_type: &str = thinking_select.interact()?;
-        config.set_claude_thinking_type(thinking_type)?;
+    {
+        let supports_thinking = match temp_provider.fetch_model_info(&model).await {
+            Ok(model_info) => model_info.reasoning,
+            Err(_) => goose::model::ModelConfig::new(&model)
+                .map(|c| c.is_reasoning_model())
+                .unwrap_or(false),
+        };
 
-        if thinking_type == "adaptive" {
-            let effort: &str = cliclack::select("Select adaptive thinking effort level:")
-                .item("low", "Low - Minimal thinking, fastest responses", "")
+        if supports_thinking {
+            let effort: &str = cliclack::select("Select thinking effort:")
+                .item("off", "Off - No extended thinking", "")
+                .item("low", "Low - Better latency, lighter reasoning", "")
                 .item("medium", "Medium - Moderate thinking", "")
-                .item("high", "High - Deep reasoning (default)", "")
-                .item(
-                    "max",
-                    "Max - No constraints on thinking depth (Opus 4.6 only)",
-                    "",
-                )
-                .initial_value("high")
+                .item("high", "High - Deep reasoning", "")
+                .item("max", "Max - No constraints on thinking depth", "")
+                .initial_value("off")
                 .interact()?;
-            config.set_claude_thinking_effort(effort)?;
-        } else if thinking_type == "enabled" {
-            let budget: String = cliclack::input("Enter thinking budget (tokens):")
-                .default_input("16000")
-                .validate(|input: &String| match input.parse::<i32>() {
-                    Ok(n) if n > 0 => Ok(()),
-                    _ => Err("Please enter a valid positive number"),
-                })
-                .interact()?;
-            config.set_claude_thinking_budget(budget.parse::<i32>()?)?;
-        }
-    }
-
-    if provider_name == "chatgpt_codex" {
-        let valid_levels = reasoning_levels_for_model(&model);
-        if !valid_levels.is_empty() {
-            let mut select = cliclack::select("Select reasoning effort level:");
-            for &level in valid_levels {
-                let description = match level {
-                    "low" => "Low - Fast responses with lighter reasoning",
-                    "medium" => "Medium - Balances speed and reasoning depth for everyday tasks",
-                    "high" => "High - Greater reasoning depth for complex problems",
-                    "xhigh" => "Extra High - Extra high reasoning depth for complex problems",
-                    _ => "",
-                };
-                select = select.item(level, description, "");
-            }
-            select = select.initial_value("medium");
-            let effort: &str = select.interact()?;
-            config.set_chatgpt_codex_reasoning_effort(effort.to_string())?;
+            config.set_goose_thinking_effort(effort)?;
         }
     }
 

crates/goose-cli/src/session/builder.rs

@@ -268,6 +268,7 @@ fn resolve_provider_and_model(
             .is_some_and(|mc| mc.model_name == model_name)
     {
         let mut config = saved_model_config.unwrap();
+        config.normalize_effort_suffix();
         if let Some(temp) = recipe_settings.and_then(|s| s.temperature) {
             config = config.with_temperature(Some(temp));
         }

crates/goose-server/src/openapi.rs

@@ -5,7 +5,7 @@ use goose::config::permission::PermissionLevel;
 use goose::config::ExtensionEntry;
 use goose::conversation::Conversation;
 use goose::download_manager::{DownloadProgress, DownloadStatus};
-use goose::model::ModelConfig;
+use goose::model::{ModelConfig, ThinkingEffort};
 use goose::permission::permission_confirmation::{Permission, PrincipalType};
 use goose::providers::base::{ConfigKey, ModelInfo, ProviderMetadata, ProviderType};
 use goose::session::{Session, SessionInsights, SessionType, SystemInfo};
@@ -397,6 +397,7 @@ derive_utoipa!(IconTheme as IconThemeSchema);
         super::routes::config_management::read_all_config,
         super::routes::config_management::providers,
         super::routes::config_management::get_provider_models,
+        super::routes::config_management::get_provider_model_info,
         super::routes::config_management::get_slash_commands,
         super::routes::config_management::upsert_permissions,
         super::routes::config_management::create_custom_provider,
@@ -573,6 +574,8 @@ derive_utoipa!(IconTheme as IconThemeSchema);
         PrincipalType,
         ModelInfo,
         ModelConfig,
+        ThinkingEffort,
+        super::routes::config_management::ProviderModelInfoQuery,
         Session,
         goose::config::goose_mode::GooseMode,
         SessionInsights,

crates/goose-server/src/routes/agent.rs

@@ -1,3 +1,4 @@
+use crate::routes::config_management::resolve_provider_model_info;
 use crate::routes::errors::ErrorResponse;
 use crate::routes::recipe_utils::{
     apply_recipe_to_agent, build_recipe_with_parameter_values, load_recipe_by_id, validate_recipe,
@@ -595,16 +596,23 @@ async fn update_agent_provider(
         }
     };
 
-    let model_config = ModelConfig::new(&model)
+    let mut model_config = ModelConfig::new(&model)
         .map_err(|e| {
             (
                 StatusCode::BAD_REQUEST,
                 format!("Invalid model config: {}", e),
             )
         })?
         .with_canonical_limits(&payload.provider)
-        .with_context_limit(payload.context_limit)
-        .with_request_params(payload.request_params);
+        .with_context_limit(payload.context_limit);
+
+    if let Some(request_params) = payload.request_params {
+        model_config = model_config.with_merged_request_params(request_params);
+    }
+    let model_info = resolve_provider_model_info(&payload.provider, &model)
+        .await
+        .map_err(|e| (e.status, e.message))?;
+    model_config.reasoning = Some(model_info.reasoning);
 
     let extensions =
         EnabledExtensionsState::for_session(state.session_manager(), &payload.session_id, config)

crates/goose-server/src/routes/config_management.rs

@@ -13,7 +13,7 @@ use goose::config::ExtensionEntry;
 use goose::config::{Config, ConfigError};
 use goose::custom_requests::SourceType;
 use goose::model::ModelConfig;
-use goose::providers::base::{ProviderMetadata, ProviderType};
+use goose::providers::base::{ModelInfo, ProviderMetadata, ProviderType};
 use goose::providers::canonical::maybe_get_canonical_model;
 use goose::providers::catalog::{
     get_provider_template, get_providers_by_format, ProviderCatalogEntry, ProviderFormat,
@@ -366,15 +366,15 @@ pub async fn providers() -> Result<Json<Vec<ProviderDetails>>, ErrorResponse> {
         ("name" = String, Path, description = "Provider name (e.g., openai)")
     ),
     responses(
-        (status = 200, description = "Models fetched successfully", body = [String]),
+        (status = 200, description = "Models fetched successfully", body = [ModelInfo]),
         (status = 400, description = "Unknown provider, provider not configured, or authentication error"),
         (status = 429, description = "Rate limit exceeded"),
         (status = 500, description = "Internal server error")
     )
 )]
 pub async fn get_provider_models(
     Path(name): Path<String>,
-) -> Result<Json<Vec<String>>, ErrorResponse> {
+) -> Result<Json<Vec<ModelInfo>>, ErrorResponse> {
     let all = get_providers().await.into_iter().collect::<Vec<_>>();
     let Some((metadata, provider_type)) = all.into_iter().find(|(m, _)| m.name == name) else {
         return Err(ErrorResponse::bad_request(format!(
@@ -392,14 +392,78 @@ pub async fn get_provider_models(
     let model_config = ModelConfig::new(&metadata.default_model)?.with_canonical_limits(&name);
     let provider = goose::providers::create(&name, model_config, Vec::new()).await?;
 
-    let models_result = provider.fetch_recommended_models().await;
+    let models_result = provider.fetch_recommended_model_info().await;
 
     match models_result {
         Ok(models) => Ok(Json(models)),
         Err(provider_error) => Err(provider_error.into()),
     }
 }
 
+#[derive(Deserialize, ToSchema)]
+pub struct ProviderModelInfoQuery {
+    pub model: String,
+}
+
+pub async fn resolve_provider_model_info(
+    name: &str,
+    model: &str,
+) -> Result<ModelInfo, ErrorResponse> {
+    let all = get_providers().await.into_iter().collect::<Vec<_>>();
+    let Some((metadata, provider_type)) = all.into_iter().find(|(m, _)| m.name == name) else {
+        return Err(ErrorResponse::bad_request(format!(
+            "Unknown provider: {}",
+            name
+        )));
+    };
+    if !check_provider_configured(&metadata, provider_type) {
+        return Err(ErrorResponse::bad_request(format!(
+            "Provider '{}' is not configured",
+            name
+        )));
+    }
+
+    let model_config = ModelConfig::new(model)?.with_canonical_limits(name);
+    let provider = goose::providers::create(name, model_config.clone(), Vec::new()).await?;
+    match provider.fetch_model_info(model).await {
+        Ok(info) => Ok(info),
+        Err(error) => {
+            let mut info = ModelInfo::new(model, model_config.context_limit());
+            info.reasoning = model_config.is_reasoning_model();
+            tracing::debug!(
+                provider = name,
+                model,
+                error = %error,
+                "Falling back to local model metadata"
+            );
+            Ok(info)
+        }
+    }
+}
+
+#[utoipa::path(
+    post,
+    path = "/config/providers/{name}/model-info",
+    params(
+        ("name" = String, Path, description = "Provider name (e.g., openai)")
+    ),
+    request_body = ProviderModelInfoQuery,
+    responses(
+        (status = 200, description = "Model metadata fetched successfully", body = ModelInfo),
+        (status = 400, description = "Unknown provider, provider not configured, or authentication error"),
+        (status = 429, description = "Rate limit exceeded"),
+        (status = 500, description = "Internal server error")
+    )
+)]
+pub async fn get_provider_model_info(
+    Path(name): Path<String>,
+    Json(query): Json<ProviderModelInfoQuery>,
+) -> Result<Json<ModelInfo>, ErrorResponse> {
+    resolve_provider_model_info(&name, &query.model)
+        .await
+        .map(Json)
+}
+
 #[derive(Deserialize, utoipa::IntoParams)]
 pub struct SlashCommandsQuery {
     /// Optional working directory to discover local skills from
@@ -471,6 +535,7 @@ pub struct ModelInfoData {
     pub model: String,
     pub context_limit: usize,
     pub max_output_tokens: Option<usize>,
+    pub reasoning: bool,
     pub input_token_cost: Option<f64>,
     pub output_token_cost: Option<f64>,
     pub cache_read_token_cost: Option<f64>,
@@ -508,6 +573,9 @@ pub async fn get_canonical_model_info(
         model: query.model.clone(),
         context_limit: canonical_model.limit.context,
         max_output_tokens: canonical_model.limit.output,
+        reasoning: canonical_model
+            .reasoning
+            .unwrap_or_else(|| ModelConfig::new_or_fail(&query.model).is_reasoning_model()),
         // Costs are per million tokens - client handles division for display
         input_token_cost: canonical_model.cost.input,
         output_token_cost: canonical_model.cost.output,
@@ -857,6 +925,10 @@ pub fn routes(state: Arc<AppState>) -> Router {
         .route("/config/extensions/{name}", delete(remove_extension))
         .route("/config/providers", get(providers))
         .route("/config/providers/{name}/models", get(get_provider_models))
+        .route(
+            "/config/providers/{name}/model-info",
+            post(get_provider_model_info),
+        )
         .route("/config/provider-catalog", get(get_provider_catalog))
         .route(
             "/config/provider-catalog/{id}",

crates/goose/src/acp/server.rs

@@ -936,6 +936,27 @@ async fn resolve_provider_and_model_from_config(
     Ok((provider_name, model_config))
 }
 
+fn with_preserved_session_request_params(
+    mut model_config: crate::model::ModelConfig,
+    current_model_config: Option<&crate::model::ModelConfig>,
+    request_params: Option<HashMap<String, serde_json::Value>>,
+) -> crate::model::ModelConfig {
+    if let Some(thinking_effort) = current_model_config
+        .and_then(|config| config.request_params.as_ref())
+        .and_then(|params| params.get("thinking_effort"))
+        .cloned()
+    {
+        model_config = model_config.with_merged_request_params(HashMap::from([(
+            "thinking_effort".into(),
+            thinking_effort,
+        )]));
+    }
+    if let Some(request_params) = request_params {
+        model_config = model_config.with_merged_request_params(request_params);
+    }
+    model_config
+}
+
 /// Convenience wrapper: reads config from disk, then resolves provider + model.
 /// Cheap enough to call from `on_new_session` (file + registry reads, no network).
 async fn resolve_provider_and_model(
@@ -3174,11 +3195,14 @@ impl GooseAcpAgent {
             .await
             .internal_err_ctx("Failed to get provider")?;
         let provider_name = current_provider.get_name().to_string();
+        let current_model_config = current_provider.get_model_config();
         let extensions =
             EnabledExtensionsState::for_session(&self.session_manager, session_id, &config).await;
         let model_config = crate::model::ModelConfig::new(model_id)
             .invalid_params_err_ctx("Invalid model config")?
             .with_canonical_limits(&provider_name);
+        let model_config =
+            with_preserved_session_request_params(model_config, Some(&current_model_config), None);
         let session = self
             .session_manager
             .get_session(session_id, false)
@@ -3284,7 +3308,8 @@ impl GooseAcpAgent {
             .await
             .internal_err_ctx("Failed to get provider")?;
         let current_provider_name = current_provider.get_name();
-        let current_model = current_provider.get_model_config().model_name;
+        let current_model_config = current_provider.get_model_config();
+        let current_model = current_model_config.model_name.clone();
         let has_default_overrides =
             model_name.is_some() || context_limit.is_some() || request_params.is_some();
         let use_default_provider = provider_name == DEFAULT_PROVIDER_ID;
@@ -3308,11 +3333,15 @@ impl GooseAcpAgent {
             current_model
         };
         let model = model_name.unwrap_or(&default_model);
-        let model_config = crate::model::ModelConfig::new(model)
+        let mut model_config = crate::model::ModelConfig::new(model)
             .invalid_params_err_ctx("Invalid model config")?
             .with_canonical_limits(&resolved_provider_name)
-            .with_context_limit(context_limit)
-            .with_request_params(request_params);
+            .with_context_limit(context_limit);
+        model_config = with_preserved_session_request_params(
+            model_config,
+            (!is_changing_provider).then_some(&current_model_config),
+            request_params,
+        );
 
         let extensions =
             EnabledExtensionsState::for_session(&self.session_manager, session_id, &config).await;