fix: GPT-5.4 Responses API routing, context window limits, and reasoning effort lookup

- Route gpt-5.4 variants and codex/pro models to Responses API (not chat/completions)
  for both OpenAI and Databricks providers
- Add strict:false to Responses API function tool definitions
- Handle databricks- prefix stripping for routing decisions
- Handle dash-variant model names (gpt-5-4 == gpt-5.4)
- Fix OPEN_AI_KNOWN_MODELS context windows: gpt-5.4/pro to 1,050,000, gpt-5.4-nano to 400,000
- Add missing gpt-5.3-codex to known models
- Fix canonical lookup: strip reasoning effort suffixes (-high, -xhigh, etc.) before
  retrying, so models like databricks-gpt-5.4-high get correct context limits
  instead of falling back to 128k default

Signed-off-by: Bradley Axen <baxen@squareup.com>

Author: baxen

crates/goose/src/model.rs

@@ -138,9 +138,22 @@ impl ModelConfig {
             }
         }
 
-        if let Some(canonical) =
+        // Try canonical lookup with the full model name first, then fall back
+        // to the name with reasoning-effort suffixes stripped (e.g.
+        // "databricks-gpt-5.4-high" → "databricks-gpt-5.4").
+        let canonical =
             crate::providers::canonical::maybe_get_canonical_model(provider_name, &self.model_name)
-        {
+                .or_else(|| {
+                    let (base, _effort) =
+                        crate::providers::utils::extract_reasoning_effort(&self.model_name);
+                    if base != self.model_name {
+                        crate::providers::canonical::maybe_get_canonical_model(provider_name, &base)
+                    } else {
+                        None
+                    }
+                });
+
+        if let Some(canonical) = canonical {
             if self.context_limit.is_none() {
                 self.context_limit = Some(canonical.limit.context);
             }
@@ -499,6 +512,28 @@ mod tests {
             assert_eq!(config.max_tokens, None);
             assert_eq!(config.reasoning, None);
         }
+
+        #[test]
+        fn resolves_after_stripping_reasoning_effort_suffix() {
+            let _guard = env_lock::lock_env([
+                ("GOOSE_MAX_TOKENS", None::<&str>),
+                ("GOOSE_CONTEXT_LIMIT", None::<&str>),
+            ]);
+
+            // "databricks-gpt-5.4-high" should resolve via "databricks-gpt-5.4"
+            let config = ModelConfig::new_or_fail("databricks-gpt-5.4-high")
+                .with_canonical_limits("databricks");
+            assert_eq!(config.context_limit, Some(1_050_000));
+
+            // "gpt-5.4-xhigh" should resolve via "gpt-5.4"
+            let config = ModelConfig::new_or_fail("gpt-5.4-xhigh").with_canonical_limits("openai");
+            assert_eq!(config.context_limit, Some(1_050_000));
+
+            // "gpt-5.4-nano-low" should resolve via "gpt-5.4-nano"
+            let config =
+                ModelConfig::new_or_fail("gpt-5.4-nano-low").with_canonical_limits("openai");
+            assert_eq!(config.context_limit, Some(400_000));
+        }
     }
 
     mod is_openai_reasoning_model {

crates/goose/src/providers/databricks.rs

@@ -270,16 +270,26 @@ impl DatabricksProvider {
 
     fn is_responses_model(model_name: &str) -> bool {
         let normalized = model_name.to_ascii_lowercase();
-        normalized.contains("codex")
+        let base = normalized
+            .strip_prefix("databricks-")
+            .unwrap_or(&normalized);
+        let base = super::utils::normalize_gpt5_version(base);
+        base.contains("codex")
+            || base.starts_with("gpt-5-pro")
+            || base.starts_with("gpt-5.2-pro")
+            || base.starts_with("gpt-5.4")
     }
 
     fn get_endpoint_path(&self, model_name: &str, is_embedding: bool) -> String {
         if is_embedding {
             "serving-endpoints/text-embedding-3-small/invocations".to_string()
-        } else if Self::is_responses_model(model_name) {
-            "serving-endpoints/responses".to_string()
         } else {
-            format!("serving-endpoints/{}/invocations", model_name)
+            let (clean_name, _) = super::utils::extract_reasoning_effort(model_name);
+            if Self::is_responses_model(&clean_name) {
+                "serving-endpoints/responses".to_string()
+            } else {
+                format!("serving-endpoints/{}/invocations", clean_name)
+            }
         }
     }
 
@@ -590,3 +600,249 @@ impl EmbeddingCapable for DatabricksProvider {
         Ok(embeddings)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn gpt_5_4_is_responses_model() {
+        assert!(
+            DatabricksProvider::is_responses_model("gpt-5.4"),
+            "gpt-5.4 requires the Responses API — chat/completions rejects reasoning_effort with function tools"
+        );
+    }
+
+    #[test]
+    fn gpt_5_2_pro_is_responses_model() {
+        assert!(
+            DatabricksProvider::is_responses_model("gpt-5.2-pro"),
+            "gpt-5.2-pro requires the Responses API"
+        );
+    }
+
+    #[test]
+    fn codex_models_remain_responses_models() {
+        assert!(DatabricksProvider::is_responses_model("gpt-5-codex"));
+        assert!(DatabricksProvider::is_responses_model("gpt-5.1-codex"));
+    }
+
+    #[test]
+    fn gpt_5_pro_is_responses_model() {
+        assert!(
+            DatabricksProvider::is_responses_model("gpt-5-pro"),
+            "gpt-5-pro only supports the Responses API"
+        );
+    }
+
+    #[test]
+    fn gpt_5_4_mini_is_responses_model() {
+        assert!(DatabricksProvider::is_responses_model("gpt-5.4-mini"));
+    }
+
+    #[test]
+    fn gpt_5_4_nano_is_responses_model() {
+        assert!(DatabricksProvider::is_responses_model("gpt-5.4-nano"));
+    }
+
+    #[test]
+    fn gpt_5_4_pro_is_responses_model() {
+        assert!(DatabricksProvider::is_responses_model("gpt-5.4-pro"));
+    }
+
+    #[test]
+    fn non_responses_models_are_not_matched() {
+        assert!(!DatabricksProvider::is_responses_model("gpt-4o"));
+        assert!(!DatabricksProvider::is_responses_model("gpt-5"));
+        assert!(!DatabricksProvider::is_responses_model("gpt-5-mini"));
+        assert!(!DatabricksProvider::is_responses_model("gpt-5-nano"));
+        assert!(!DatabricksProvider::is_responses_model("gpt-5.1"));
+        assert!(!DatabricksProvider::is_responses_model("gpt-5.2"));
+        assert!(!DatabricksProvider::is_responses_model("o3-mini"));
+        assert!(!DatabricksProvider::is_responses_model("claude-sonnet-4"));
+    }
+
+    // --- Bug-fix tests: databricks-prefixed model names ---
+
+    #[test]
+    fn databricks_prefixed_gpt_5_4_is_responses_model() {
+        assert!(
+            DatabricksProvider::is_responses_model("databricks-gpt-5.4"),
+            "databricks-gpt-5.4 should route to the Responses API"
+        );
+    }
+
+    #[test]
+    fn databricks_prefixed_gpt_5_4_mini_is_responses_model() {
+        assert!(DatabricksProvider::is_responses_model(
+            "databricks-gpt-5.4-mini"
+        ));
+    }
+
+    #[test]
+    fn databricks_prefixed_gpt_5_pro_is_responses_model() {
+        assert!(DatabricksProvider::is_responses_model(
+            "databricks-gpt-5-pro"
+        ));
+    }
+
+    #[test]
+    fn databricks_prefixed_codex_is_responses_model() {
+        assert!(DatabricksProvider::is_responses_model(
+            "databricks-gpt-5-codex"
+        ));
+    }
+
+    #[test]
+    fn databricks_prefixed_non_responses_model_is_not_matched() {
+        assert!(!DatabricksProvider::is_responses_model("databricks-gpt-4o"));
+        assert!(!DatabricksProvider::is_responses_model(
+            "databricks-claude-sonnet-4"
+        ));
+    }
+
+    // --- Bug-fix tests: reasoning suffix must be stripped from endpoint path ---
+
+    #[test]
+    fn endpoint_path_strips_reasoning_suffix_for_chat_model() {
+        let provider = DatabricksProvider {
+            api_client: super::super::api_client::ApiClient::new(
+                "https://example.com".to_string(),
+                super::super::api_client::AuthMethod::NoAuth,
+            )
+            .unwrap(),
+            auth: DatabricksAuth::Token("fake".into()),
+            model: ModelConfig::new_or_fail("databricks-gpt-5-4"),
+            image_format: ImageFormat::OpenAi,
+            retry_config: RetryConfig::default(),
+            fast_retry_config: RetryConfig::new(0, 0, 1.0, 0),
+            name: "databricks".into(),
+            token_cache: std::sync::Arc::new(std::sync::Mutex::new(None)),
+            instance_id: None,
+        };
+
+        // "databricks-gpt-5-4-high" — gpt-5-4 is the dash variant of gpt-5.4,
+        // which requires the Responses API.
+        let path = provider.get_endpoint_path("databricks-gpt-5-4-high", false);
+        assert_eq!(
+            path, "serving-endpoints/responses",
+            "gpt-5-4 (dash variant of gpt-5.4) must route to the Responses API"
+        );
+    }
+
+    #[test]
+    fn endpoint_path_routes_prefixed_responses_model_correctly() {
+        let provider = DatabricksProvider {
+            api_client: super::super::api_client::ApiClient::new(
+                "https://example.com".to_string(),
+                super::super::api_client::AuthMethod::NoAuth,
+            )
+            .unwrap(),
+            auth: DatabricksAuth::Token("fake".into()),
+            model: ModelConfig::new_or_fail("databricks-gpt-5.4"),
+            image_format: ImageFormat::OpenAi,
+            retry_config: RetryConfig::default(),
+            fast_retry_config: RetryConfig::new(0, 0, 1.0, 0),
+            name: "databricks".into(),
+            token_cache: std::sync::Arc::new(std::sync::Mutex::new(None)),
+            instance_id: None,
+        };
+
+        let path = provider.get_endpoint_path("databricks-gpt-5.4-high", false);
+        assert_eq!(
+            path, "serving-endpoints/responses",
+            "databricks-gpt-5.4 variants must route to the Responses API"
+        );
+    }
+
+    #[test]
+    fn endpoint_path_unchanged_for_non_reasoning_model() {
+        let provider = DatabricksProvider {
+            api_client: super::super::api_client::ApiClient::new(
+                "https://example.com".to_string(),
+                super::super::api_client::AuthMethod::NoAuth,
+            )
+            .unwrap(),
+            auth: DatabricksAuth::Token("fake".into()),
+            model: ModelConfig::new_or_fail("databricks-claude-sonnet-4"),
+            image_format: ImageFormat::OpenAi,
+            retry_config: RetryConfig::default(),
+            fast_retry_config: RetryConfig::new(0, 0, 1.0, 0),
+            name: "databricks".into(),
+            token_cache: std::sync::Arc::new(std::sync::Mutex::new(None)),
+            instance_id: None,
+        };
+
+        let path = provider.get_endpoint_path("databricks-claude-sonnet-4", false);
+        assert_eq!(
+            path,
+            "serving-endpoints/databricks-claude-sonnet-4/invocations"
+        );
+    }
+
+    // --- Bug-fix: dash-variant model names (gpt-5-4 == gpt-5.4) ---
+
+    #[test]
+    fn gpt_5_4_dash_variant_is_responses_model() {
+        assert!(
+            DatabricksProvider::is_responses_model("gpt-5-4"),
+            "gpt-5-4 (dash variant of gpt-5.4) must route to the Responses API"
+        );
+    }
+
+    #[test]
+    fn gpt_5_4_dash_variant_mini_is_responses_model() {
+        assert!(DatabricksProvider::is_responses_model("gpt-5-4-mini"));
+    }
+
+    #[test]
+    fn gpt_5_4_dash_variant_nano_is_responses_model() {
+        assert!(DatabricksProvider::is_responses_model("gpt-5-4-nano"));
+    }
+
+    #[test]
+    fn gpt_5_4_dash_variant_pro_is_responses_model() {
+        assert!(DatabricksProvider::is_responses_model("gpt-5-4-pro"));
+    }
+
+    #[test]
+    fn databricks_prefixed_gpt_5_4_dash_variant_is_responses_model() {
+        assert!(
+            DatabricksProvider::is_responses_model("databricks-gpt-5-4"),
+            "databricks-gpt-5-4 must route to the Responses API"
+        );
+    }
+
+    #[test]
+    fn gpt_5_2_dash_variant_pro_is_responses_model() {
+        assert!(
+            DatabricksProvider::is_responses_model("gpt-5-2-pro"),
+            "gpt-5-2-pro (dash variant of gpt-5.2-pro) must route to the Responses API"
+        );
+    }
+
+    #[test]
+    fn endpoint_path_routes_dash_variant_gpt_5_4_to_responses() {
+        let provider = DatabricksProvider {
+            api_client: super::super::api_client::ApiClient::new(
+                "https://example.com".to_string(),
+                super::super::api_client::AuthMethod::NoAuth,
+            )
+            .unwrap(),
+            auth: DatabricksAuth::Token("fake".into()),
+            model: ModelConfig::new_or_fail("databricks-gpt-5-4"),
+            image_format: ImageFormat::OpenAi,
+            retry_config: RetryConfig::default(),
+            fast_retry_config: RetryConfig::new(0, 0, 1.0, 0),
+            name: "databricks".into(),
+            token_cache: std::sync::Arc::new(std::sync::Mutex::new(None)),
+            instance_id: None,
+        };
+
+        let path = provider.get_endpoint_path("databricks-gpt-5-4-xhigh", false);
+        assert_eq!(
+            path, "serving-endpoints/responses",
+            "databricks-gpt-5-4-xhigh must route to the Responses API, not chat/completions"
+        );
+    }
+}

crates/goose/src/providers/formats/databricks.rs

@@ -587,7 +587,7 @@ pub fn create_request(
         let last_part = parts.last().unwrap();
 
         match *last_part {
-            "low" | "medium" | "high" => {
+            "none" | "low" | "medium" | "high" | "xhigh" => {
                 let base_name = parts[..parts.len() - 1].join("-");
                 (base_name, Some(last_part.to_string()))
             }
@@ -1073,6 +1073,44 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_create_request_reasoning_effort_xhigh() -> anyhow::Result<()> {
+        let model_config = ModelConfig {
+            model_name: "o3-xhigh".to_string(),
+            context_limit: Some(4096),
+            temperature: None,
+            max_tokens: Some(1024),
+            toolshim: false,
+            toolshim_model: None,
+            fast_model_config: None,
+            request_params: None,
+            reasoning: None,
+        };
+        let request = create_request(&model_config, "system", &[], &[], &ImageFormat::OpenAi)?;
+        assert_eq!(request["model"], "o3");
+        assert_eq!(request["reasoning_effort"], "xhigh");
+        Ok(())
+    }
+
+    #[test]
+    fn test_create_request_reasoning_effort_none() -> anyhow::Result<()> {
+        let model_config = ModelConfig {
+            model_name: "o3-none".to_string(),
+            context_limit: Some(4096),
+            temperature: None,
+            max_tokens: Some(1024),
+            toolshim: false,
+            toolshim_model: None,
+            fast_model_config: None,
+            request_params: None,
+            reasoning: None,
+        };
+        let request = create_request(&model_config, "system", &[], &[], &ImageFormat::OpenAi)?;
+        assert_eq!(request["model"], "o3");
+        assert_eq!(request["reasoning_effort"], "none");
+        Ok(())
+    }
+
     #[test]
     fn test_create_request_adaptive_thinking_for_46_models() -> anyhow::Result<()> {
         let _guard = env_lock::lock_env([