with_canonical_limits refactor

Author: katzdave

crates/goose-acp/src/server.rs

@@ -740,7 +740,8 @@ impl GooseAcpAgent {
                 let provider_name = config
                     .get_goose_provider()
                     .map_err(|_| anyhow::anyhow!("No provider configured"))?;
-                goose::model::ModelConfig::new(&model_id, &provider_name)?
+                goose::model::ModelConfig::new(&model_id)?
+                    .with_canonical_limits(&provider_name)
             }
         };
         let provider = (self.provider_factory)(model_config).await?;
@@ -966,9 +967,11 @@ impl GooseAcpAgent {
             sacp::Error::internal_error().data("No provider configured".to_string())
         })?;
         let model_config =
-            goose::model::ModelConfig::new(model_id, &provider_name).map_err(|e| {
-                sacp::Error::invalid_params().data(format!("Invalid model config: {}", e))
-            })?;
+            goose::model::ModelConfig::new(model_id)
+                .map_err(|e| {
+                    sacp::Error::invalid_params().data(format!("Invalid model config: {}", e))
+                })?
+                .with_canonical_limits(&provider_name);
         let provider = (self.provider_factory)(model_config).await.map_err(|e| {
             sacp::Error::internal_error().data(format!("Failed to create provider: {}", e))
         })?;
@@ -1305,7 +1308,7 @@ print(\"hello, world\")
         }
 
         fn get_model_config(&self) -> goose::model::ModelConfig {
-            goose::model::ModelConfig::new_or_fail("unused", "test")
+            goose::model::ModelConfig::new_or_fail("unused")
         }
 
         async fn fetch_recommended_models(&self) -> Result<Vec<String>, ProviderError> {

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

@@ -327,7 +327,7 @@ async fn handle_oauth_configuration(provider_name: &str, key_name: &str) -> anyh
     ));
 
     // Create a temporary provider instance to handle OAuth
-    let temp_model = ModelConfig::new("temp", provider_name)?;
+    let temp_model = ModelConfig::new("temp")?.with_canonical_limits(provider_name);
     match create(provider_name, temp_model).await {
         Ok(provider) => match provider.configure_oauth().await {
             Ok(_) => {
@@ -682,7 +682,8 @@ pub async fn configure_provider_dialog() -> anyhow::Result<bool> {
     let spin = spinner();
     spin.start("Attempting to fetch supported models...");
     let models_res = {
-        let temp_model_config = ModelConfig::new(&provider_meta.default_model, provider_name)?;
+        let temp_model_config =
+            ModelConfig::new(&provider_meta.default_model)?.with_canonical_limits(provider_name);
         let temp_provider = create(provider_name, temp_model_config).await?;
         retry_operation(&RetryConfig::default(), || async {
             temp_provider.fetch_recommended_models().await
@@ -1442,7 +1443,7 @@ pub async fn configure_tool_permissions_dialog() -> anyhow::Result<()> {
     let model: String = config
         .get_goose_model()
         .expect("No model configured. Please set model first");
-    let model_config = ModelConfig::new(&model, &provider_name)?;
+    let model_config = ModelConfig::new(&model)?.with_canonical_limits(&provider_name);
 
     let agent = Agent::new();
     let new_provider = create(&provider_name, model_config).await?;
@@ -1658,8 +1659,8 @@ pub async fn handle_openrouter_auth() -> anyhow::Result<()> {
     // Test configuration - get the model that was configured
     println!("\nTesting configuration...");
     let configured_model: String = config.get_goose_model()?;
-    let model_config = match goose::model::ModelConfig::new(&configured_model, "openrouter") {
-        Ok(config) => config,
+    let model_config = match goose::model::ModelConfig::new(&configured_model) {
+        Ok(config) => config.with_canonical_limits("openrouter"),
         Err(e) => {
             eprintln!("⚠️  Invalid model configuration: {}", e);
             eprintln!("Your settings have been saved. Please check your model configuration.");
@@ -1738,8 +1739,8 @@ pub async fn handle_tetrate_auth() -> anyhow::Result<()> {
     // Test configuration
     println!("\nTesting configuration...");
     let configured_model: String = config.get_goose_model()?;
-    let model_config = match goose::model::ModelConfig::new(&configured_model, "tetrate") {
-        Ok(config) => config,
+    let model_config = match goose::model::ModelConfig::new(&configured_model) {
+        Ok(config) => config.with_canonical_limits("tetrate"),
         Err(e) => {
             eprintln!("⚠️  Invalid model configuration: {}", e);
             eprintln!("Your settings have been saved. Please check your model configuration.");

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

@@ -293,7 +293,9 @@ pub async fn handle_term_info() -> Result<()> {
         .ok()
         .and_then(|model_name| {
             config.get_goose_provider().ok().and_then(|provider_name| {
-                goose::model::ModelConfig::new(&model_name, &provider_name).ok()
+                goose::model::ModelConfig::new(&model_name)
+                    .ok()
+                    .map(|c| c.with_canonical_limits(&provider_name))
             })
         })
         .map(|mc| mc.context_limit())

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

@@ -168,7 +168,8 @@ fn get_provider_and_model() -> (String, String) {
 }
 
 async fn create_agent(provider_name: &str, model: &str) -> Result<Agent> {
-    let model_config = goose::model::ModelConfig::new(model, provider_name)?;
+    let model_config =
+        goose::model::ModelConfig::new(model)?.with_canonical_limits(provider_name);
 
     let agent = Agent::new();
 

crates/goose-cli/src/scenario_tests/scenario_runner.rs

@@ -189,7 +189,7 @@ where
 
         let inner_provider = create(
             &factory_name,
-            ModelConfig::new(config.model_name, &factory_name)?,
+            ModelConfig::new(config.model_name)?.with_canonical_limits(&factory_name),
         )
         .await?;
 

crates/goose-cli/src/session/builder.rs

@@ -382,11 +382,12 @@ fn resolve_provider_and_model(
         config
     } else {
         let temperature = recipe_settings.and_then(|s| s.temperature);
-        goose::model::ModelConfig::new(&model_name, &provider_name)
+        goose::model::ModelConfig::new(&model_name)
             .unwrap_or_else(|e| {
                 output::render_error(&format!("Failed to create model configuration: {}", e));
                 process::exit(1);
             })
+            .with_canonical_limits(&provider_name)
             .with_temperature(temperature)
     };
 

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

@@ -534,13 +534,14 @@ async fn update_agent_provider(
         }
     };
 
-    let model_config = ModelConfig::new(&model, &payload.provider)
+    let model_config = ModelConfig::new(&model)
         .map_err(|e| {
             (
                 StatusCode::BAD_REQUEST,
                 format!("Invalid model config: {}", e),
             )
         })?
+        .with_canonical_limits(&payload.provider)
         .with_context_limit(payload.context_limit)
         .with_request_params(payload.request_params);
 

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

@@ -380,7 +380,7 @@ pub async fn get_provider_models(
         )));
     }
 
-    let model_config = ModelConfig::new(&metadata.default_model, &name)?;
+    let model_config = ModelConfig::new(&metadata.default_model)?.with_canonical_limits(&name);
     let provider = goose::providers::create(&name, model_config).await?;
 
     let models_result = provider.fetch_recommended_models().await;
@@ -796,9 +796,11 @@ pub async fn configure_provider_oauth(
         )));
     }
 
-    let temp_model = ModelConfig::new("temp", &provider_name).map_err(|e| {
-        ErrorResponse::bad_request(format!("Failed to create temporary model config: {}", e))
-    })?;
+    let temp_model = ModelConfig::new("temp")
+        .map_err(|e| {
+            ErrorResponse::bad_request(format!("Failed to create temporary model config: {}", e))
+        })?
+        .with_canonical_limits(&provider_name);
 
     let provider = create(&provider_name, temp_model).await.map_err(|e| {
         ErrorResponse::bad_request(format!(

crates/goose/src/agents/agent.rs

@@ -1578,8 +1578,9 @@ impl Agent {
                 let model_name = config
                     .get_goose_model()
                     .map_err(|_| anyhow!("Could not configure agent: missing model"))?;
-                crate::model::ModelConfig::new(&model_name, &provider_name)
+                crate::model::ModelConfig::new(&model_name)
                     .map_err(|e| anyhow!("Could not configure agent: invalid model {}", e))?
+                    .with_canonical_limits(&provider_name)
             }
         };
 

crates/goose/src/agents/reply_parts.rs

@@ -491,7 +491,7 @@ mod tests {
             )
             .await?;
 
-        let model_config = ModelConfig::new("test-model", "test").unwrap();
+        let model_config = ModelConfig::new("test-model").unwrap();
         let provider = std::sync::Arc::new(MockProvider { model_config });
         agent.update_provider(provider, &session.id).await?;