fix: allow adaptive thinking and xhigh effort with Claude Opus 4.7

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

@@ -776,8 +776,9 @@ pub async fn configure_provider_dialog() -> anyhow::Result<bool> {
                 .item("low", "Low - Better latency, lighter reasoning", "")
                 .item("medium", "Medium - Moderate thinking", "")
                 .item("high", "High - Deep reasoning", "")
+                .item("xhigh", "XHigh - Extended coding and agentic work", "")
                 .item("max", "Max - No constraints on thinking depth", "")
-                .initial_value("off")
+                .initial_value("high")
                 .interact()?;
             config.set_goose_thinking_effort(effort)?;
         }

crates/goose/src/config/base.rs

@@ -1100,7 +1100,7 @@ config_value!(CURSOR_AGENT_COMMAND, String, "cursor-agent");
 config_value!(CODEX_COMMAND, String, "codex");
 config_value!(CODEX_ENABLE_SKILLS, String, "true");
 config_value!(CODEX_SKIP_GIT_CHECK, String, "false");
-config_value!(CHATGPT_CODEX_REASONING_EFFORT, String, "medium");
+config_value!(CHATGPT_CODEX_REASONING_EFFORT, String);
 
 config_value!(GOOSE_SEARCH_PATHS, Vec<String>);
 config_value!(GOOSE_MODE, GooseMode);

crates/goose/src/model.rs

@@ -17,6 +17,7 @@ pub enum ThinkingEffort {
     Low,
     Medium,
     High,
+    XHigh,
     Max,
 }
 
@@ -28,7 +29,8 @@ impl FromStr for ThinkingEffort {
             "low" => Ok(Self::Low),
             "medium" | "med" => Ok(Self::Medium),
             "high" => Ok(Self::High),
-            "max" | "xhigh" => Ok(Self::Max),
+            "xhigh" => Ok(Self::XHigh),
+            "max" => Ok(Self::Max),
             other => Err(format!("unknown thinking effort: '{other}'")),
         }
     }
@@ -41,6 +43,7 @@ impl fmt::Display for ThinkingEffort {
             Self::Low => write!(f, "low"),
             Self::Medium => write!(f, "medium"),
             Self::High => write!(f, "high"),
+            Self::XHigh => write!(f, "xhigh"),
             Self::Max => write!(f, "max"),
         }
     }
@@ -445,7 +448,7 @@ impl ModelConfig {
             "low" => ThinkingEffort::Low,
             "medium" => ThinkingEffort::Medium,
             "high" => ThinkingEffort::High,
-            "xhigh" => ThinkingEffort::Max,
+            "xhigh" => ThinkingEffort::XHigh,
             _ => return,
         };
         self.model_name = parts[..parts.len() - 1].join("-");
@@ -794,7 +797,7 @@ mod tests {
             ]);
             let config = ModelConfig::new("gpt-5.4-xhigh").unwrap();
             assert_eq!(config.model_name, "gpt-5.4");
-            assert_eq!(config.thinking_effort(), Some(ThinkingEffort::Max));
+            assert_eq!(config.thinking_effort(), Some(ThinkingEffort::XHigh));
         }
 
         #[test]
@@ -857,7 +860,7 @@ mod tests {
             );
             assert_eq!("med".parse::<ThinkingEffort>(), Ok(ThinkingEffort::Medium));
             assert_eq!("max".parse::<ThinkingEffort>(), Ok(ThinkingEffort::Max));
-            assert_eq!("xhigh".parse::<ThinkingEffort>(), Ok(ThinkingEffort::Max));
+            assert_eq!("xhigh".parse::<ThinkingEffort>(), Ok(ThinkingEffort::XHigh));
             assert!("invalid".parse::<ThinkingEffort>().is_err());
         }
     }

crates/goose/src/providers/anthropic.rs

@@ -30,6 +30,8 @@ const ANTHROPIC_PROVIDER_NAME: &str = "anthropic";
 pub const ANTHROPIC_DEFAULT_MODEL: &str = "claude-sonnet-4-5";
 const ANTHROPIC_DEFAULT_FAST_MODEL: &str = "claude-haiku-4-5";
 const ANTHROPIC_KNOWN_MODELS: &[&str] = &[
+    // Claude 4.7 models
+    "claude-opus-4-7",
     // Claude 4.6 models
     "claude-opus-4-6",
     "claude-sonnet-4-6",

crates/goose/src/providers/chatgpt_codex.rs

@@ -209,47 +209,51 @@ fn build_input_items(messages: &[Message]) -> Result<Vec<Value>> {
     Ok(items)
 }
 
-fn get_reasoning_effort(model_name: &str) -> String {
-    let config = crate::config::Config::global();
-    let effort = config
-        .get_chatgpt_codex_reasoning_effort()
-        .map(String::from)
-        .unwrap_or_else(|_| "medium".to_string());
-
+fn configured_reasoning_effort(model_name: &str, config: &crate::config::Config) -> Option<String> {
+    let effort = config.get_chatgpt_codex_reasoning_effort().ok()?;
     let valid_levels = reasoning_levels_for_model(model_name);
+
     if valid_levels.contains(&effort.as_str()) {
-        effort
+        Some(effort)
     } else {
         tracing::warn!(
-            "Invalid CHATGPT_CODEX_REASONING_EFFORT '{}' for model '{}', using 'medium'",
+            "Invalid CHATGPT_CODEX_REASONING_EFFORT '{}' for model '{}', omitting reasoning effort",
             effort,
             model_name
         );
-        "medium".to_string()
+        None
     }
 }
 
 fn reasoning_effort_for_config(model_config: &ModelConfig) -> Option<String> {
+    reasoning_effort_for_config_with_config(model_config, crate::config::Config::global())
+}
+
+fn reasoning_effort_for_config_with_config(
+    model_config: &ModelConfig,
+    config: &crate::config::Config,
+) -> Option<String> {
     use crate::model::ThinkingEffort;
 
-    model_config
-        .thinking_effort()
-        .map(|effort| {
+    match model_config.thinking_effort() {
+        Some(effort) => {
             let valid_levels = reasoning_levels_for_model(&model_config.model_name);
             let preferred_levels: &[&str] = match effort {
                 ThinkingEffort::Off => return None,
                 ThinkingEffort::Low => &["low", "medium", "high", "xhigh"],
                 ThinkingEffort::Medium => &["medium", "high", "low", "xhigh"],
                 ThinkingEffort::High => &["high", "medium", "xhigh", "low"],
+                ThinkingEffort::XHigh => &["xhigh", "high", "medium", "low"],
                 ThinkingEffort::Max => &["xhigh", "high", "medium", "low"],
             };
 
             preferred_levels
                 .iter()
                 .find(|level| valid_levels.contains(level))
                 .map(|level| (*level).to_string())
-        })
-        .unwrap_or_else(|| Some(get_reasoning_effort(&model_config.model_name)))
+        }
+        None => configured_reasoning_effort(&model_config.model_name, config),
+    }
 }
 
 fn create_codex_request(
@@ -1242,6 +1246,21 @@ mod tests {
         assert!(payload.get("reasoning_effort").is_none());
     }
 
+    #[test]
+    fn test_create_codex_request_omits_reasoning_when_effort_unset() {
+        let _guard = env_lock::lock_env([
+            ("GOOSE_THINKING_EFFORT", None::<&str>),
+            ("CHATGPT_CODEX_REASONING_EFFORT", None::<&str>),
+        ]);
+        let config_file = tempfile::NamedTempFile::new().unwrap();
+        let secrets_file = tempfile::NamedTempFile::new().unwrap();
+        let empty_config =
+            crate::config::Config::new_with_file_secrets(config_file.path(), secrets_file.path())
+                .unwrap();
+
+        assert!(configured_reasoning_effort("gpt-5.2-codex", &empty_config).is_none());
+    }
+
     #[test_case(
         JwtClaims {
             chatgpt_account_id: Some("account-1".to_string()),

crates/goose/src/providers/codex.rs

@@ -69,7 +69,7 @@ impl CodexProvider {
                 "low" => Some(crate::model::ThinkingEffort::Low),
                 "medium" => Some(crate::model::ThinkingEffort::Medium),
                 "high" => Some(crate::model::ThinkingEffort::High),
-                "xhigh" => Some(crate::model::ThinkingEffort::Max),
+                "xhigh" => Some(crate::model::ThinkingEffort::XHigh),
                 _ => None,
             })
     }
@@ -79,14 +79,12 @@ impl CodexProvider {
         effort: Option<crate::model::ThinkingEffort>,
     ) -> Option<String> {
         use crate::model::ThinkingEffort;
-        match effort
-            .or_else(Self::legacy_reasoning_effort)
-            .unwrap_or(ThinkingEffort::High)
-        {
+        match effort.or_else(Self::legacy_reasoning_effort)? {
             ThinkingEffort::Off => Some("none".to_string()),
             ThinkingEffort::Low => Some("low".to_string()),
             ThinkingEffort::Medium => Some("medium".to_string()),
             ThinkingEffort::High => Some("high".to_string()),
+            ThinkingEffort::XHigh => Some("xhigh".to_string()),
             ThinkingEffort::Max => Some("xhigh".to_string()),
         }
     }
@@ -1259,7 +1257,7 @@ mod tests {
         );
         assert_eq!(
             CodexProvider::map_thinking_effort("gpt-5.2-codex", None),
-            Some("high".to_string())
+            None
         );
     }