fix: strip databricks- prefix for reasoning effort and responses API routing

extract_reasoning_effort and is_responses_model did not account for the
databricks- prefix on model names. This caused:

- databricks-gpt-5-4-high to hit endpoint databricks-gpt-5-4-high (404)
  instead of stripping the -high reasoning suffix
- databricks-gpt-5.4 variants to miss the Responses API route

Fix extract_reasoning_effort to strip provider prefixes (databricks-,
goose-) before pattern matching, and fix Databricks is_responses_model
and get_endpoint_path similarly.

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

Author: baxen

crates/goose/src/providers/databricks.rs

@@ -270,19 +270,25 @@ impl DatabricksProvider {
 
     fn is_responses_model(model_name: &str) -> bool {
         let normalized = model_name.to_ascii_lowercase();
-        normalized.contains("codex")
-            || normalized.starts_with("gpt-5-pro")
-            || normalized.starts_with("gpt-5.2-pro")
-            || normalized.starts_with("gpt-5.4")
+        let base = normalized
+            .strip_prefix("databricks-")
+            .unwrap_or(&normalized);
+        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)
+            }
         }
     }
 
@@ -654,4 +660,122 @@ mod tests {
         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" — the "-high" is a reasoning effort suffix,
+        // not part of the Databricks endpoint name.
+        let path = provider.get_endpoint_path("databricks-gpt-5-4-high", false);
+        assert_eq!(
+            path, "serving-endpoints/databricks-gpt-5-4/invocations",
+            "reasoning suffix '-high' must be stripped from the endpoint name"
+        );
+    }
+
+    #[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"
+        );
+    }
 }

crates/goose/src/providers/utils.rs

@@ -194,22 +194,32 @@ pub async fn handle_response_google_compat(response: Response) -> Result<Value,
 }
 
 pub fn extract_reasoning_effort(model_name: &str) -> (String, Option<String>) {
-    let is_reasoning_model = model_name.starts_with("o1")
-        || model_name.starts_with("o2")
-        || model_name.starts_with("o3")
-        || model_name.starts_with("o4")
-        || model_name.starts_with("gpt-5");
+    const PROVIDER_PREFIXES: &[&str] = &["goose-", "databricks-"];
+
+    let (prefix, base) = PROVIDER_PREFIXES
+        .iter()
+        .find_map(|p| model_name.strip_prefix(p).map(|rest| (*p, rest)))
+        .unwrap_or(("", model_name));
+
+    let is_reasoning_model = base.starts_with("o1")
+        || base.starts_with("o2")
+        || base.starts_with("o3")
+        || base.starts_with("o4")
+        || base.starts_with("gpt-5");
 
     if !is_reasoning_model {
         return (model_name.to_string(), None);
     }
 
-    let parts: Vec<&str> = model_name.split('-').collect();
+    let parts: Vec<&str> = base.split('-').collect();
     let last_part = parts.last().unwrap();
     match *last_part {
         "none" | "low" | "medium" | "high" | "xhigh" => {
             let base_name = parts[..parts.len() - 1].join("-");
-            (base_name, Some(last_part.to_string()))
+            (
+                format!("{}{}", prefix, base_name),
+                Some(last_part.to_string()),
+            )
         }
         _ => (model_name.to_string(), Some("medium".to_string())),
     }
@@ -905,4 +915,39 @@ mod tests {
         assert_eq!(name, "gpt-4o");
         assert_eq!(effort, None);
     }
+
+    #[test]
+    fn test_extract_reasoning_effort_databricks_prefixed_high() {
+        let (name, effort) = extract_reasoning_effort("databricks-gpt-5-4-high");
+        assert_eq!(name, "databricks-gpt-5-4");
+        assert_eq!(effort.as_deref(), Some("high"));
+    }
+
+    #[test]
+    fn test_extract_reasoning_effort_databricks_prefixed_default() {
+        let (name, effort) = extract_reasoning_effort("databricks-gpt-5-4");
+        assert_eq!(name, "databricks-gpt-5-4");
+        assert_eq!(effort.as_deref(), Some("medium"));
+    }
+
+    #[test]
+    fn test_extract_reasoning_effort_databricks_prefixed_o3_low() {
+        let (name, effort) = extract_reasoning_effort("databricks-o3-low");
+        assert_eq!(name, "databricks-o3");
+        assert_eq!(effort.as_deref(), Some("low"));
+    }
+
+    #[test]
+    fn test_extract_reasoning_effort_databricks_non_reasoning() {
+        let (name, effort) = extract_reasoning_effort("databricks-claude-sonnet-4");
+        assert_eq!(name, "databricks-claude-sonnet-4");
+        assert_eq!(effort, None);
+    }
+
+    #[test]
+    fn test_extract_reasoning_effort_goose_prefixed_high() {
+        let (name, effort) = extract_reasoning_effort("goose-gpt-5-high");
+        assert_eq!(name, "goose-gpt-5");
+        assert_eq!(effort.as_deref(), Some("high"));
+    }
 }