fix: relax canonical model listing for custom providers

My company has a custom proxy that exposes an Anthropic-compatible API. When connecting Goose, it correctly calls the /v1/models endpoint to enumerate available models—but several models like glm-5 and kimi-k2 were mysteriously missing from the dropdown. The models worked fine when manually specified in config.yaml, yet the UI refused to show them.

After debugging, it turns out fetch_recommended_models was filtering out any model that couldn't be mapped to a canonical model ID in Goose's bundled registry. The code tried to look up each model name in the registry to get metadata like release dates and tool support—but if the lookup failed, the model was discarded entirely.

This is inconsistent with how the runtime actually works. When you configure glm-5 in config.yaml, the ModelConfig::with_canonical_limits function gracefully handles missing canonical metadata—it just skips filling in defaults. The model runs perfectly fine without it.

So the listing code was treating the registry as required while the execution code treated it as optional. If you think about it, why should a model be blocked from appearing in a dropdown just because Goose doesn't know its release date? The metadata is nice to have, not a prerequisite for using the model.

Fix:

- Changed fetch_recommended_models to branch on provider_type()

- Built-in OpenAI/Anthropic (with default host): strict filtering (require canonical metadata, text modality, tool support)

- Custom/declarative providers: relaxed filtering (allow unknown models, use canonical metadata when available for sorting)

- Alternate-host OpenAI/Anthropic (OPENAI_HOST/ANTHROPIC_HOST set): treated as custom

- Default provider_type is Custom, only OpenAI/Anthropic override to Builtin when using canonical names and default host

- Registry load errors are propagated instead of silently returning empty list

- Added regression tests for custom-include vs builtin-exclude behavior

Signed-off-by: Pete Gonzalez <4673363+octogonz@users.noreply.github.com>

Author: octogonz

crates/goose/src/providers/anthropic.rs

@@ -55,6 +55,7 @@ pub struct AnthropicProvider {
     model: ModelConfig,
     supports_streaming: bool,
     name: String,
+    is_custom_host: bool,
 }
 
 impl AnthropicProvider {
@@ -80,6 +81,7 @@ impl AnthropicProvider {
             model,
             supports_streaming: true,
             name: ANTHROPIC_PROVIDER_NAME.to_string(),
+            is_custom_host: host != "https://api.anthropic.com",
         })
     }
 
@@ -124,6 +126,7 @@ impl AnthropicProvider {
             model,
             supports_streaming,
             name: config.name.clone(),
+            is_custom_host: true,
         })
     }
 
@@ -189,6 +192,14 @@ impl Provider for AnthropicProvider {
         &self.name
     }
 
+    fn provider_type(&self) -> crate::providers::base::ProviderType {
+        if self.name == ANTHROPIC_PROVIDER_NAME && !self.is_custom_host {
+            crate::providers::base::ProviderType::Builtin
+        } else {
+            crate::providers::base::ProviderType::Custom
+        }
+    }
+
     fn get_model_config(&self) -> ModelConfig {
         self.model.clone()
     }

crates/goose/src/providers/base.rs

@@ -456,6 +456,11 @@ pub trait Provider: Send + Sync {
     /// Get the name of this provider instance
     fn get_name(&self) -> &str;
 
+    /// Get the provider classification for model listing behavior.
+    fn provider_type(&self) -> ProviderType {
+        ProviderType::Custom
+    }
+
     /// Primary streaming method that all providers must implement.
     ///
     /// Note: Do not add `#[instrument]` here — the call sites (`complete` and
@@ -534,40 +539,77 @@ pub trait Provider: Send + Sync {
         Ok(vec![])
     }
 
-    /// Fetch models filtered by canonical registry and usability
+    /// Fetch models sorted by release date when available from canonical registry.
+    /// For built-in providers, models must be in the canonical registry and pass
+    /// usability checks (text modality, tool support).
+    /// For custom providers, all models are included; unknown models sort alphabetically.
     async fn fetch_recommended_models(&self) -> Result<Vec<String>, ProviderError> {
         let all_models = self.fetch_supported_models().await?;
 
+        // Try to load the canonical registry for metadata.
+        // If it fails, propagate the error - we don't want to silently return
+        // an empty list or all models when we can't properly validate.
         let registry = CanonicalModelRegistry::bundled().map_err(|e| {
             ProviderError::ExecutionError(format!("Failed to load canonical registry: {}", e))
         })?;
 
         let provider_name = self.get_name();
+        let provider_type = self.provider_type();
+        let uses_strict_model_filtering = matches!(
+            provider_type,
+            ProviderType::Builtin | ProviderType::Preferred
+        );
+        let allows_unknown_models = matches!(
+            provider_type,
+            ProviderType::Custom | ProviderType::Declarative
+        );
+        let toolshim_enabled = self.get_model_config().toolshim;
 
-        // Get all text-capable models with their release dates
+        // Build list of (model_name, release_date) for sorting.
+        // For built-in providers, filter out models without canonical metadata
+        // or that don't pass usability checks.
         let mut models_with_dates: Vec<(String, Option<String>)> = all_models
             .iter()
             .filter_map(|model| {
-                let canonical_id = map_to_canonical_model(provider_name, model, registry)?;
-
-                let (provider, model_name) = canonical_id.split_once('/')?;
-                let canonical_model = registry.get(provider, model_name)?;
+                let canonical = map_to_canonical_model(provider_name, model, registry).and_then(
+                    |canonical_id| {
+                        let (provider, model_name) = canonical_id.split_once('/')?;
+                        registry.get(provider, model_name)
+                    },
+                );
+
+                match canonical {
+                    Some(cm) => {
+                        // Model has canonical metadata - apply checks
+                        // Check text modality
+                        if !cm
+                            .modalities
+                            .input
+                            .contains(&crate::providers::canonical::Modality::Text)
+                        {
+                            return None;
+                        }
 
-                if !canonical_model
-                    .modalities
-                    .input
-                    .contains(&crate::providers::canonical::Modality::Text)
-                {
-                    return None;
-                }
+                        // Check tool support
+                        if !cm.tool_call && !toolshim_enabled {
+                            return None;
+                        }
 
-                if !canonical_model.tool_call && !self.get_model_config().toolshim {
-                    return None;
+                        Some((model.clone(), cm.release_date.clone()))
+                    }
+                    None => {
+                        // Model not in canonical registry
+                        if uses_strict_model_filtering {
+                            // Built-in/preferred providers: skip unknown models
+                            None
+                        } else if allows_unknown_models {
+                            // Custom/declarative providers: include unknown models
+                            Some((model.clone(), None))
+                        } else {
+                            None
+                        }
+                    }
                 }
-
-                let release_date = canonical_model.release_date.clone();
-
-                Some((model.clone(), release_date))
             })
             .collect();
 
@@ -579,16 +621,10 @@ pub trait Provider: Send + Sync {
             (None, None) => a.0.cmp(&b.0),
         });
 
-        let recommended_models: Vec<String> = models_with_dates
+        Ok(models_with_dates
             .into_iter()
             .map(|(name, _)| name)
-            .collect();
-
-        if recommended_models.is_empty() {
-            Ok(all_models)
-        } else {
-            Ok(recommended_models)
-        }
+            .collect())
     }
 
     async fn map_to_canonical_model(
@@ -895,6 +931,45 @@ mod tests {
         }
     }
 
+    struct ListingProvider {
+        name: String,
+        provider_type: ProviderType,
+        model_config: ModelConfig,
+        supported_models: Vec<String>,
+    }
+
+    #[async_trait::async_trait]
+    impl Provider for ListingProvider {
+        fn get_name(&self) -> &str {
+            &self.name
+        }
+
+        fn provider_type(&self) -> ProviderType {
+            self.provider_type
+        }
+
+        fn get_model_config(&self) -> ModelConfig {
+            self.model_config.clone()
+        }
+
+        async fn fetch_supported_models(&self) -> Result<Vec<String>, ProviderError> {
+            Ok(self.supported_models.clone())
+        }
+
+        async fn stream(
+            &self,
+            _model_config: &ModelConfig,
+            _session_id: &str,
+            _system: &str,
+            _messages: &[Message],
+            _tools: &[Tool],
+        ) -> Result<MessageStream, ProviderError> {
+            Err(ProviderError::ExecutionError(
+                "stream not implemented for listing tests".to_string(),
+            ))
+        }
+    }
+
     fn create_test_stream(
         items: Vec<String>,
     ) -> impl Stream<Item = Result<(Option<Message>, Option<ProviderUsage>), ProviderError>> {
@@ -1078,4 +1153,30 @@ mod tests {
         assert_eq!(info.output_token_cost, Some(0.00001));
         assert_eq!(info.currency, Some("$".to_string()));
     }
+
+    #[tokio::test]
+    async fn test_fetch_recommended_models_includes_unknown_for_custom_provider() {
+        let provider = ListingProvider {
+            name: "custom-proxy".to_string(),
+            provider_type: ProviderType::Custom,
+            model_config: ModelConfig::new_or_fail("glm-5"),
+            supported_models: vec!["glm-5".to_string()],
+        };
+
+        let recommended = provider.fetch_recommended_models().await.unwrap();
+        assert!(recommended.contains(&"glm-5".to_string()));
+    }
+
+    #[tokio::test]
+    async fn test_fetch_recommended_models_excludes_unknown_for_builtin_provider() {
+        let provider = ListingProvider {
+            name: "openai".to_string(),
+            provider_type: ProviderType::Builtin,
+            model_config: ModelConfig::new_or_fail("gpt-4o"),
+            supported_models: vec!["definitely-unknown-model-id".to_string()],
+        };
+
+        let recommended = provider.fetch_recommended_models().await.unwrap();
+        assert!(recommended.is_empty());
+    }
 }

crates/goose/src/providers/openai.rs

@@ -65,6 +65,7 @@ pub struct OpenAiProvider {
     custom_headers: Option<HashMap<String, String>>,
     supports_streaming: bool,
     name: String,
+    is_custom_host: bool,
 }
 
 impl OpenAiProvider {
@@ -126,6 +127,7 @@ impl OpenAiProvider {
             custom_headers,
             supports_streaming: true,
             name: OPEN_AI_PROVIDER_NAME.to_string(),
+            is_custom_host: host != "https://api.openai.com",
         })
     }
 
@@ -140,6 +142,7 @@ impl OpenAiProvider {
             custom_headers: None,
             supports_streaming: true,
             name: OPEN_AI_PROVIDER_NAME.to_string(),
+            is_custom_host: false,
         }
     }
 
@@ -208,6 +211,7 @@ impl OpenAiProvider {
             custom_headers: config.headers,
             supports_streaming: config.supports_streaming.unwrap_or(true),
             name: config.name.clone(),
+            is_custom_host: true,
         })
     }
 
@@ -361,6 +365,14 @@ impl Provider for OpenAiProvider {
         &self.name
     }
 
+    fn provider_type(&self) -> crate::providers::base::ProviderType {
+        if self.name == OPEN_AI_PROVIDER_NAME && !self.is_custom_host {
+            crate::providers::base::ProviderType::Builtin
+        } else {
+            crate::providers::base::ProviderType::Custom
+        }
+    }
+
     fn get_model_config(&self) -> ModelConfig {
         self.model.clone()
     }