fix(providers): only fallback to custom models for endpoint-not-implemented errors

Auth failures (401/403), rate limits (429), and server errors (5xx) now
propagate correctly instead of being hidden by fallback. Only 404 and connection
failures trigger fallback to preserve diagnostics.

Fixes P1 feedback from PR aaif-goose#7530

Author: octogonz

crates/goose/src/providers/anthropic.rs

@@ -223,18 +223,23 @@ impl Provider for AnthropicProvider {
     }
 
     async fn fetch_supported_models(&self) -> Result<Vec<String>, ProviderError> {
-        // If custom models are defined, try API first but fallback to them on error
+        // If custom models are defined, try API first but fallback to them only if endpoint doesn't exist
         if let Some(custom_models) = &self.custom_models {
             match self.fetch_models_from_api().await {
                 Ok(models) => return Ok(models),
                 Err(e) => {
-                    // Log the error but don't fail - fallback to custom models
-                    tracing::debug!(
-                        "Failed to fetch models from API for provider '{}' ({}), using predefined list",
-                        self.name,
-                        e
-                    );
-                    return Ok(custom_models.clone());
+                    // Only fall back for endpoint-not-implemented errors (404, connection failures)
+                    // Auth errors, rate limits, and server errors should propagate
+                    if e.is_endpoint_not_implemented() {
+                        tracing::debug!(
+                            "Models endpoint not implemented for provider '{}' ({}), using predefined list",
+                            self.name,
+                            e
+                        );
+                        return Ok(custom_models.clone());
+                    }
+                    // Otherwise, propagate the error to preserve diagnostics
+                    return Err(e);
                 }
             }
         }

crates/goose/src/providers/errors.rs

@@ -52,6 +52,37 @@ impl ProviderError {
             ProviderError::CreditsExhausted { .. } => "credits_exhausted",
         }
     }
+
+    /// Returns true if this error indicates the models endpoint is not implemented
+    /// and we should fall back to configured custom models.
+    ///
+    /// Only certain errors should trigger fallback - specifically 404 (endpoint not found)
+    /// or connection failures that suggest the endpoint doesn't exist.
+    ///
+    /// Critical errors that should NOT fallback:
+    /// - Authentication failures (401/403) - indicates misconfigured credentials
+    /// - Rate limits (429) - indicates service is functioning but rate-limited
+    /// - Server errors (5xx) - indicates service is having issues
+    /// - Context length exceeded - indicates API is working
+    pub fn is_endpoint_not_implemented(&self) -> bool {
+        match self {
+            // 404 or connection failures suggest endpoint doesn't exist - safe to fallback
+            ProviderError::RequestFailed(msg) => {
+                msg.contains("404")
+                    || msg.contains("not found")
+                    || msg.contains("connection failed")
+                    || msg.contains("failed to connect")
+            }
+            // Auth, rate limit, server, context errors - do NOT fallback
+            ProviderError::Authentication(_) => false,
+            ProviderError::RateLimitExceeded { .. } => false,
+            ProviderError::ServerError(_) => false,
+            ProviderError::ContextLengthExceeded(_) => false,
+            ProviderError::CreditsExhausted { .. } => false,
+            // Other errors may indicate the endpoint exists - safer to not fallback
+            _ => false,
+        }
+    }
 }
 
 impl From<anyhow::Error> for ProviderError {

crates/goose/src/providers/openai.rs

@@ -366,18 +366,23 @@ impl Provider for OpenAiProvider {
     }
 
     async fn fetch_supported_models(&self) -> Result<Vec<String>, ProviderError> {
-        // If custom models are defined, try API first but fallback to them on error
+        // If custom models are defined, try API first but fallback to them only if endpoint doesn't exist
         if let Some(custom_models) = &self.custom_models {
             match self.fetch_models_from_api().await {
                 Ok(models) => return Ok(models),
                 Err(e) => {
-                    // Log the error but don't fail - fallback to custom models
-                    tracing::debug!(
-                        "Failed to fetch models from API for provider '{}' ({}), using predefined list",
-                        self.name,
-                        e
-                    );
-                    return Ok(custom_models.clone());
+                    // Only fall back for endpoint-not-implemented errors (404, connection failures)
+                    // Auth errors, rate limits, and server errors should propagate
+                    if e.is_endpoint_not_implemented() {
+                        tracing::debug!(
+                            "Models endpoint not implemented for provider '{}' ({}), using predefined list",
+                            self.name,
+                            e
+                        );
+                        return Ok(custom_models.clone());
+                    }
+                    // Otherwise, propagate the error to preserve diagnostics
+                    return Err(e);
                 }
             }
         }