diff --git a/crates/goose-provider-types/src/canonical/name_builder.rs b/crates/goose-provider-types/src/canonical/name_builder.rs index 5a3ac03b7..84421f8e0 100644 --- a/crates/goose-provider-types/src/canonical/name_builder.rs +++ b/crates/goose-provider-types/src/canonical/name_builder.rs @@ -51,6 +51,7 @@ pub fn map_provider_name(provider: &str) -> &str { "gemini_oauth" => "google", "databricks_v2" => "databricks", "zhipu" => "zhipuai", + "together" => "togetherai", "novita" => "novita-ai", "opencode_go" => "opencode-go", "opencode_zen" => "opencode", diff --git a/crates/goose-provider-types/src/model.rs b/crates/goose-provider-types/src/model.rs index 284e8df13..5292303a3 100644 --- a/crates/goose-provider-types/src/model.rs +++ b/crates/goose-provider-types/src/model.rs @@ -117,21 +117,36 @@ impl ModelConfig { config } - pub fn with_canonical_limits(mut self, provider_name: &str) -> Self { + fn canonical_model(&self, provider_name: &str) -> Option { // 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::canonical::maybe_get_canonical_model(provider_name, &self.model_name).or_else( - || { - let (base, _effort) = extract_reasoning_effort(&self.model_name); - if base != self.model_name { - crate::canonical::maybe_get_canonical_model(provider_name, &base) - } else { - None - } - }, - ); + crate::canonical::maybe_get_canonical_model(provider_name, &self.model_name).or_else(|| { + let (base, _effort) = extract_reasoning_effort(&self.model_name); + if base != self.model_name { + crate::canonical::maybe_get_canonical_model(provider_name, &base) + } else { + None + } + }) + } + + pub fn with_canonical_vision_support(mut self, provider_name: &str) -> Self { + if self.supports_vision.is_none() { + if let Some(canonical) = self.canonical_model(provider_name) { + self.supports_vision = Some( + canonical + .modalities + .input + .contains(&crate::canonical::Modality::Image), + ); + } + } + self + } + + pub fn with_canonical_limits(mut self, provider_name: &str) -> Self { + let canonical = self.canonical_model(provider_name); if let Some(canonical) = canonical { if self.max_tokens.is_none() { diff --git a/crates/goose-providers/src/databricks.rs b/crates/goose-providers/src/databricks.rs index b09e0c9cf..216fbd4bf 100644 --- a/crates/goose-providers/src/databricks.rs +++ b/crates/goose-providers/src/databricks.rs @@ -194,6 +194,25 @@ impl DatabricksProvider { Self::is_claude_model(model_name) || is_openai_responses_model(model_name) } + fn resolve_vision_support( + model_config: &ModelConfig, + effective_model_name: &str, + ) -> Option { + if effective_model_name == model_config.model_name { + return None; + } + + let resolved = ModelConfig::new(effective_model_name) + .with_canonical_vision_support(DATABRICKS_PROVIDER_NAME) + .supports_vision?; + + if model_config.supports_vision == Some(resolved) { + return None; + } + + Some(model_config.clone().with_vision_support(resolved)) + } + fn uses_responses_api( endpoint_info: Option<&DatabricksEndpointInfo>, model_names: &[&str], @@ -588,6 +607,9 @@ impl Provider for DatabricksProvider { endpoint_info.as_ref(), &[&model_config.model_name, effective_model_name], ); + let vision_resolved_config = + Self::resolve_vision_support(model_config, effective_model_name); + let model_config = vision_resolved_config.as_ref().unwrap_or(model_config); let path = if is_responses_model { "serving-endpoints/responses".to_string() } else { @@ -1034,6 +1056,29 @@ mod tests { assert!(!info.supports_responses_api); } + #[test] + fn vision_support_resolves_from_upstream_model_behind_endpoint_alias() { + let aliased = ModelConfig::new("production-chat"); + assert_eq!(aliased.supports_vision, None); + + let resolved = DatabricksProvider::resolve_vision_support(&aliased, "gpt-4o") + .expect("upstream model should resolve vision support"); + assert_eq!(resolved.supports_vision, Some(true)); + assert_eq!(resolved.model_name, "production-chat"); + + let catalog_alias = ModelConfig::new("gpt-3.5-turbo") + .with_canonical_vision_support(DATABRICKS_PROVIDER_NAME); + assert_eq!(catalog_alias.supports_vision, Some(false)); + + let corrected = DatabricksProvider::resolve_vision_support(&catalog_alias, "gpt-4o") + .expect("upstream model should override alias-derived capability"); + assert_eq!(corrected.supports_vision, Some(true)); + + let downgraded = + DatabricksProvider::resolve_vision_support(&resolved, "gpt-3.5-turbo").unwrap(); + assert_eq!(downgraded.supports_vision, Some(false)); + } + #[test] fn responses_routing_prefers_metadata_over_model_name() { let responses_info = DatabricksEndpointInfo { diff --git a/crates/goose-sdk/src/bindings.rs b/crates/goose-sdk/src/bindings.rs index 8ea6dd451..8728c0a9d 100644 --- a/crates/goose-sdk/src/bindings.rs +++ b/crates/goose-sdk/src/bindings.rs @@ -490,8 +490,9 @@ pub struct ProviderModelConfig { } impl ProviderModelConfig { - fn to_goose_model_config(&self) -> Result { + fn to_goose_model_config(&self, provider_name: &str) -> Result { let mut config = ModelConfig::new(&self.model_name) + .with_canonical_vision_support(provider_name) .with_temperature(self.temperature) .with_max_tokens(self.max_tokens) .with_toolshim(self.toolshim) @@ -754,7 +755,7 @@ impl ProviderHandle { tools: Vec, ) -> Result, GooseError> { let timeout_ms = model.timeout_ms; - let model = model.to_goose_model_config()?; + let model = model.to_goose_model_config(self.provider.get_name())?; let messages = convert_messages(messages)?; let tools = convert_tools(tools)?; let observer = Arc::new(RequestObserver::start(RequestDescriptor { @@ -797,7 +798,7 @@ impl ProviderHandle { tools: Vec, ) -> Result { let timeout_ms = model.timeout_ms; - let model = model.to_goose_model_config()?; + let model = model.to_goose_model_config(self.provider.get_name())?; let messages = convert_messages(messages)?; let tools = convert_tools(tools)?; let observer = RequestObserver::start(RequestDescriptor { @@ -1690,7 +1691,7 @@ mod tests { ..base_model_config() }; - assert!(config.to_goose_model_config().is_err()); + assert!(config.to_goose_model_config("openai").is_err()); } #[test]