Merge branch 'main' of github.com:block/goose into zane/working-dir-add-extension

* 'main' of github.com:block/goose:
  Use Canonical Models to set context window sizes (#6723)

Author: zanesq

crates/goose-acp/src/server.rs

@@ -738,7 +738,8 @@ impl GooseAcpAgent {
                 let config_path = self.config_dir.join(CONFIG_YAML_NAME);
                 let config = Config::new(&config_path, "goose")?;
                 let model_id = config.get_goose_model()?;
-                goose::model::ModelConfig::new(&model_id)?
+                let provider_name = config.get_goose_provider()?;
+                goose::model::ModelConfig::new(&model_id)?.with_canonical_limits(&provider_name)
             }
         };
         let provider = (self.provider_factory)(model_config, Vec::new()).await?;
@@ -956,9 +957,18 @@ impl GooseAcpAgent {
         session_id: &str,
         model_id: &str,
     ) -> Result<SetSessionModelResponse, sacp::Error> {
-        let model_config = goose::model::ModelConfig::new(model_id).map_err(|e| {
-            sacp::Error::invalid_params().data(format!("Invalid model config: {}", e))
+        let config_path = self.config_dir.join(CONFIG_YAML_NAME);
+        let config = Config::new(&config_path, "goose").map_err(|e| {
+            sacp::Error::internal_error().data(format!("Failed to read config: {}", e))
+        })?;
+        let provider_name = config.get_goose_provider().map_err(|_| {
+            sacp::Error::internal_error().data("No provider configured".to_string())
         })?;
+        let model_config = 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, Vec::new())
             .await
             .map_err(|e| {

crates/goose-acp/src/server_factory.rs

@@ -38,9 +38,7 @@ impl AcpServer {
             Box::pin(async move {
                 let config_path = config_dir.join(goose::config::base::CONFIG_YAML_NAME);
                 let config = goose::config::Config::new(&config_path, "goose")?;
-                let provider_name = config
-                    .get_goose_provider()
-                    .map_err(|_| anyhow::anyhow!("No provider configured"))?;
+                let provider_name = config.get_goose_provider()?;
                 goose::providers::create(&provider_name, model_config, extensions).await
             })
         });

crates/goose-acp/tests/common_tests/mod.rs

@@ -25,7 +25,7 @@ pub async fn run_config_mcp<C: Connection>() {
     let mcp = McpFixture::new(Some(expected_session_id.clone())).await;
 
     let config_yaml = format!(
-        "GOOSE_MODEL: {TEST_MODEL}\nextensions:\n  mcp-fixture:\n    enabled: true\n    type: streamable_http\n    name: mcp-fixture\n    description: MCP fixture\n    uri: \"{}\"\n",
+        "GOOSE_MODEL: {TEST_MODEL}\nGOOSE_PROVIDER: openai\nextensions:\n  mcp-fixture:\n    enabled: true\n    type: streamable_http\n    name: mcp-fixture\n    description: MCP fixture\n    uri: \"{}\"\n",
         mcp.url
     );
     fs::write(temp_dir.path().join(CONFIG_YAML_NAME), config_yaml).unwrap();

crates/goose-acp/tests/fixtures/mod.rs

@@ -199,7 +199,11 @@ pub async fn spawn_acp_server_in_process(
     fs::create_dir_all(data_root).unwrap();
     let config_path = data_root.join(goose::config::base::CONFIG_YAML_NAME);
     if !config_path.exists() {
-        fs::write(&config_path, format!("GOOSE_MODEL: {TEST_MODEL}\n")).unwrap();
+        fs::write(
+            &config_path,
+            format!("GOOSE_MODEL: {TEST_MODEL}\nGOOSE_PROVIDER: openai\n"),
+        )
+        .unwrap();
     }
     let provider_factory = provider_factory.unwrap_or_else(|| {
         let base_url = openai_base_url.to_string();

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")?;
+    let temp_model = ModelConfig::new("temp")?.with_canonical_limits(provider_name);
     match create(provider_name, temp_model, Vec::new()).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)?;
+        let temp_model_config =
+            ModelConfig::new(&provider_meta.default_model)?.with_canonical_limits(provider_name);
         let temp_provider = create(provider_name, temp_model_config, Vec::new()).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)?;
+    let model_config = ModelConfig::new(&model)?.with_canonical_limits(&provider_name);
 
     let agent = Agent::new();
 
@@ -1662,7 +1663,7 @@ pub async fn handle_openrouter_auth() -> anyhow::Result<()> {
     println!("\nTesting configuration...");
     let configured_model: String = config.get_goose_model()?;
     let model_config = match goose::model::ModelConfig::new(&configured_model) {
-        Ok(config) => config,
+        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.");
@@ -1742,7 +1743,7 @@ pub async fn handle_tetrate_auth() -> anyhow::Result<()> {
     println!("\nTesting configuration...");
     let configured_model: String = config.get_goose_model()?;
     let model_config = match goose::model::ModelConfig::new(&configured_model) {
-        Ok(config) => config,
+        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

@@ -291,7 +291,13 @@ pub async fn handle_term_info() -> Result<()> {
     let context_limit = config
         .get_goose_model()
         .ok()
-        .and_then(|model_name| goose::model::ModelConfig::new(&model_name).ok())
+        .and_then(|model_name| {
+            config.get_goose_provider().ok().and_then(|provider_name| {
+                goose::model::ModelConfig::new(&model_name)
+                    .ok()
+                    .map(|c| c.with_canonical_limits(&provider_name))
+            })
+        })
         .map(|mc| mc.context_limit())
         .unwrap_or(128_000);
 

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

@@ -168,7 +168,7 @@ 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)?;
+    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

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

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

@@ -386,6 +386,7 @@ fn resolve_provider_and_model(
                 output::render_error(&format!("Failed to create model configuration: {}", e));
                 process::exit(1);
             })
+            .with_canonical_limits(&provider_name)
             .with_temperature(temperature)
     };
 

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

@@ -1847,7 +1847,7 @@ async fn get_reasoner() -> Result<Arc<dyn Provider>, anyhow::Error> {
     };
 
     let model_config =
-        ModelConfig::new_with_context_env(model, Some("GOOSE_PLANNER_CONTEXT_LIMIT"))?;
+        ModelConfig::new_with_context_env(model, &provider, Some("GOOSE_PLANNER_CONTEXT_LIMIT"))?;
     let extensions = goose::config::extensions::get_enabled_extensions_with_config(config);
     let reasoner = create(&provider, model_config, extensions).await?;