Bedrock model discovery and validation

crates/goose-cli/src/commands/configure.rs

@@ -811,10 +811,8 @@ pub async fn configure_provider_dialog() -> anyhow::Result<bool> {
     let spin = spinner();
     spin.start("Checking your configuration...");
 
-    let toolshim_enabled = std::env::var("GOOSE_TOOLSHIM")
-        .map(|val| val == "1" || val.to_lowercase() == "true")
-        .unwrap_or(false);
-    let toolshim_model = std::env::var("GOOSE_TOOLSHIM_OLLAMA_MODEL").ok();
+    let (toolshim_enabled, toolshim_model) =
+        goose::providers::provider_test::toolshim_settings_from_env();
 
     match test_provider_configuration(provider_name, &model, toolshim_enabled, toolshim_model).await
     {

crates/goose-server/src/routes/agent.rs

@@ -17,6 +17,7 @@ use goose::agents::ExtensionConfig;
 use goose::config::resolve_extensions_for_new_session;
 use goose::config::{Config, GooseMode};
 use goose::providers::create;
+use goose::providers::provider_test::test_provider_model;
 use goose::recipe::Recipe;
 use goose::recipe_deeplink;
 use goose::session::session_manager::SessionType;
@@ -591,6 +592,11 @@ async fn update_agent_provider(
     if let Some(request_params) = payload.request_params {
         model_config = model_config.with_merged_request_params(request_params);
     }
+
+    test_provider_model(&payload.provider, &model)
+        .await
+        .map_err(|e| (StatusCode::BAD_REQUEST, e.to_string()))?;
+
     let model_info = resolve_provider_model_info(&payload.provider, &model)
         .await
         .map_err(|e| (e.status, e.message))?;

crates/goose-server/src/routes/config_management.rs

@@ -19,6 +19,7 @@ use goose::providers::catalog::{
     ProviderTemplate,
 };
 use goose::providers::create_with_default_model;
+use goose::providers::provider_test::test_provider_model;
 use goose::providers::providers as get_providers;
 use goose::{
     agents::execute_commands, agents::ExtensionConfig, slash_commands::recipe_slash_command,
@@ -108,6 +109,8 @@ fn normalize_custom_provider_api_key(api_key: String) -> Option<String> {
 #[derive(Deserialize, ToSchema)]
 pub struct CheckProviderRequest {
     pub provider: String,
+    #[serde(default)]
+    pub model: Option<String>,
 }
 
 #[derive(Deserialize, ToSchema)]
@@ -827,8 +830,20 @@ pub async fn update_custom_provider(
     request_body = CheckProviderRequest,
 )]
 pub async fn check_provider(
-    Json(CheckProviderRequest { provider }): Json<CheckProviderRequest>,
+    Json(CheckProviderRequest { provider, model }): Json<CheckProviderRequest>,
 ) -> Result<(), ErrorResponse> {
+    if let Some(model) = model.filter(|model| !model.trim().is_empty()) {
+        test_provider_model(&provider, &model)
+            .await
+            .map_err(|err| {
+                ErrorResponse::bad_request(format!(
+                    "Provider '{}' with model '{}' check failed: {}",
+                    provider, model, err
+                ))
+            })?;
+        return Ok(());
+    }
+
     create_with_default_model(&provider, Vec::new())
         .await
         .map_err(|err| {
@@ -845,19 +860,22 @@ pub async fn check_provider(
 pub async fn set_config_provider(
     Json(SetProviderRequest { provider, model }): Json<SetProviderRequest>,
 ) -> Result<(), ErrorResponse> {
-    create_with_default_model(&provider, Vec::new())
+    test_provider_model(&provider, &model)
         .await
-        .and_then(|_| {
-            let config = Config::global();
-            goose::config::set_active_provider(config, &provider, &model)
-                .map_err(|e| anyhow::anyhow!(e))
-        })
         .map_err(|err| {
             ErrorResponse::bad_request(format!(
                 "Failed to set provider to '{}' with model '{}': {}",
                 provider, model, err
             ))
         })?;
+
+    let config = Config::global();
+    goose::config::set_active_provider(config, &provider, &model).map_err(|err| {
+        ErrorResponse::bad_request(format!(
+            "Failed to set provider to '{}' with model '{}': {}",
+            provider, model, err
+        ))
+    })?;
     Ok(())
 }
 

crates/goose/Cargo.toml

@@ -35,6 +35,7 @@ local-inference = [
 aws-providers = [
     "dep:aws-config",
     "dep:aws-smithy-types",
+    "dep:aws-sdk-bedrock",
     "dep:aws-sdk-bedrockruntime",
     "dep:aws-sdk-sagemakerruntime",
     "dep:smithy-transport-reqwest",
@@ -234,6 +235,7 @@ llama-cpp-sys-2 = { workspace = true, optional = true }
 image = { version = "0.24.9", default-features = false, features = ["png", "jpeg", "gif", "webp"] }
 subtle = { version = "2.5", default-features = false, features = ["std"] }
 gethostname = "1.1.0"
+aws-sdk-bedrock = { version = "1.132", default-features = false, features = ["rt-tokio"], optional = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 winapi = { workspace = true }

crates/goose/src/acp/server/config.rs

@@ -215,7 +215,8 @@ impl GooseAcpAgent {
         }
 
         if let Some(model_id) = model_id.as_deref() {
-            let model_exists = entry.default_model == model_id
+            let model_exists = entry.supports_refresh
+                || entry.default_model == model_id
                 || entry.models.iter().any(|model| model.id == model_id);
             if !model_exists {
                 return Err(agent_client_protocol::Error::invalid_params().data(format!(