Use Canonical Models to set context window sizes

crates/goose-acp/src/server.rs

@@ -737,7 +737,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?;
@@ -955,9 +956,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

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

crates/goose-server/src/openapi.rs

@@ -357,7 +357,7 @@ derive_utoipa!(Icon as IconSchema);
         super::routes::config_management::check_provider,
         super::routes::config_management::set_config_provider,
         super::routes::config_management::configure_provider_oauth,
-        super::routes::config_management::get_pricing,
+        super::routes::config_management::get_canonical_model_info,
         super::routes::prompts::get_prompts,
         super::routes::prompts::get_prompt,
         super::routes::prompts::save_prompt,
@@ -443,9 +443,9 @@ derive_utoipa!(Icon as IconSchema);
         super::routes::config_management::UpdateCustomProviderRequest,
         super::routes::config_management::CheckProviderRequest,
         super::routes::config_management::SetProviderRequest,
-        super::routes::config_management::PricingQuery,
-        super::routes::config_management::PricingResponse,
-        super::routes::config_management::PricingData,
+        super::routes::config_management::ModelInfoQuery,
+        super::routes::config_management::ModelInfoResponse,
+        super::routes::config_management::ModelInfoData,
         super::routes::prompts::PromptsListResponse,
         super::routes::prompts::PromptContentResponse,
         super::routes::prompts::SavePromptRequest,

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

@@ -549,6 +549,7 @@ async fn update_agent_provider(
                 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

@@ -227,13 +227,6 @@ fn is_valid_provider_name(provider_name: &str) -> bool {
 pub async fn read_config(
     Json(query): Json<ConfigKeyQuery>,
 ) -> Result<Json<ConfigValueResponse>, ErrorResponse> {
-    if query.key == "model-limits" {
-        let limits = ModelConfig::get_all_model_limits();
-        return Ok(Json(ConfigValueResponse::Value(serde_json::to_value(
-            limits,
-        )?)));
-    }
-
     let config = Config::global();
 
     let response_value = match config.get(&query.key, query.is_secret) {
@@ -386,7 +379,7 @@ pub async fn get_provider_models(
         )));
     }
 
-    let model_config = ModelConfig::new(&metadata.default_model)?;
+    let model_config = ModelConfig::new(&metadata.default_model)?.with_canonical_limits(&name);
     let provider = goose::providers::create(&name, model_config, Vec::new()).await?;
 
     let models_result = provider.fetch_recommended_models().await;
@@ -426,66 +419,60 @@ pub async fn get_slash_commands() -> Result<Json<SlashCommandsResponse>, ErrorRe
 }
 
 #[derive(Serialize, ToSchema)]
-pub struct PricingData {
+pub struct ModelInfoData {
     pub provider: String,
     pub model: String,
-    pub input_token_cost: f64,
-    pub output_token_cost: f64,
+    pub context_limit: usize,
+    pub max_output_tokens: Option<usize>,
+    pub input_token_cost: Option<f64>,
+    pub output_token_cost: Option<f64>,
+    pub cache_read_token_cost: Option<f64>,
+    pub cache_write_token_cost: Option<f64>,
     pub currency: String,
-    pub context_length: Option<u32>,
 }
 
 #[derive(Serialize, ToSchema)]
-pub struct PricingResponse {
-    pub pricing: Vec<PricingData>,
+pub struct ModelInfoResponse {
+    pub model_info: Option<ModelInfoData>,
     pub source: String,
 }
 
 #[derive(Deserialize, ToSchema)]
-pub struct PricingQuery {
+pub struct ModelInfoQuery {
     pub provider: String,
     pub model: String,
 }
 
 #[utoipa::path(
     post,
-    path = "/config/pricing",
-    request_body = PricingQuery,
+    path = "/config/canonical-model-info",
+    request_body = ModelInfoQuery,
     responses(
-        (status = 200, description = "Model pricing data retrieved successfully", body = PricingResponse)
+        (status = 200, description = "Model information retrieved successfully", body = ModelInfoResponse)
     )
 )]
-pub async fn get_pricing(
-    Json(query): Json<PricingQuery>,
-) -> Result<Json<PricingResponse>, ErrorResponse> {
-    let canonical_model =
-        maybe_get_canonical_model(&query.provider, &query.model).ok_or_else(|| {
-            ErrorResponse::not_found(format!(
-                "Model '{}/{}' not found",
-                query.provider, query.model
-            ))
-        })?;
-
-    let mut pricing_data = Vec::new();
-
-    if let (Some(input_cost), Some(output_cost)) =
-        (canonical_model.cost.input, canonical_model.cost.output)
-    {
-        pricing_data.push(PricingData {
-            provider: query.provider.clone(),
-            model: query.model.clone(),
-            // Canonical model costs are per million tokens, convert to per-token
-            input_token_cost: input_cost / 1_000_000.0,
-            output_token_cost: output_cost / 1_000_000.0,
-            currency: "$".to_string(),
-            context_length: Some(canonical_model.limit.context as u32),
-        });
-    }
+pub async fn get_canonical_model_info(
+    Json(query): Json<ModelInfoQuery>,
+) -> Json<ModelInfoResponse> {
+    let canonical_model = maybe_get_canonical_model(&query.provider, &query.model);
+
+    let model_info = canonical_model.map(|canonical_model| ModelInfoData {
+        provider: query.provider.clone(),
+        model: query.model.clone(),
+        context_limit: canonical_model.limit.context,
+        max_output_tokens: canonical_model.limit.output,
+        // Costs are per million tokens - client handles division for display
+        input_token_cost: canonical_model.cost.input,
+        output_token_cost: canonical_model.cost.output,
+        cache_read_token_cost: canonical_model.cost.cache_read,
+        cache_write_token_cost: canonical_model.cost.cache_write,
+        currency: "$".to_string(),
+    });
 
-    Ok(Json(PricingResponse {
-        pricing: pricing_data,
+    Json(ModelInfoResponse {
+        model_info,
         source: "canonical".to_string(),
-    }))
+    })
 }
 
 #[utoipa::path(
@@ -807,9 +794,11 @@ pub async fn configure_provider_oauth(
         )));
     }
 
-    let temp_model = ModelConfig::new("temp").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);
 
     // OAuth configuration does not use extensions.
     let provider = create(&provider_name, temp_model, Vec::new())
@@ -849,7 +838,10 @@ pub fn routes(state: Arc<AppState>) -> Router {
         .route("/config/providers/{name}/models", get(get_provider_models))
         .route("/config/detect-provider", post(detect_provider))
         .route("/config/slash_commands", get(get_slash_commands))
-        .route("/config/pricing", post(get_pricing))
+        .route(
+            "/config/canonical-model-info",
+            post(get_canonical_model_info),
+        )
         .route("/config/init", post(init_config))
         .route("/config/backup", post(backup_config))
         .route("/config/recover", post(recover_config))
@@ -872,33 +864,4 @@ pub fn routes(state: Arc<AppState>) -> Router {
 }
 
 #[cfg(test)]
-mod tests {
-    use http::HeaderMap;
-
-    use super::*;
-
-    #[tokio::test]
-    async fn test_read_model_limits() {
-        let mut headers = HeaderMap::new();
-        headers.insert("X-Secret-Key", "test".parse().unwrap());
-
-        let result = read_config(Json(ConfigKeyQuery {
-            key: "model-limits".to_string(),
-            is_secret: false,
-        }))
-        .await;
-
-        assert!(result.is_ok());
-        let response = match result.unwrap().0 {
-            ConfigValueResponse::Value(value) => value,
-            ConfigValueResponse::MaskedValue(_) => panic!("unexpected secret"),
-        };
-
-        let limits: Vec<goose::model::ModelLimitConfig> = serde_json::from_value(response).unwrap();
-        assert!(!limits.is_empty());
-
-        let gpt4_limit = limits.iter().find(|l| l.pattern == "gpt-4o");
-        assert!(gpt4_limit.is_some());
-        assert_eq!(gpt4_limit.unwrap().context_limit, 128_000);
-    }
-}
+mod tests {}

crates/goose/src/agents/agent.rs

@@ -1581,6 +1581,7 @@ impl Agent {
                     .ok_or_else(|| anyhow!("Could not configure agent: missing model"))?;
                 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/platform_extensions/summon.rs

@@ -1331,11 +1331,10 @@ impl SummonClient {
             .or_else(|| session.provider_name.clone())
             .ok_or_else(|| anyhow::anyhow!("No provider configured"))?;
 
-        let mut model_config = session
-            .model_config
-            .clone()
-            .map(Ok)
-            .unwrap_or_else(|| crate::model::ModelConfig::new("default"))?;
+        let mut model_config = session.model_config.clone().map(Ok).unwrap_or_else(|| {
+            crate::model::ModelConfig::new("default")
+                .map(|c| c.with_canonical_limits(&provider_name))
+        })?;
 
         if let Some(model) = &params.model {
             model_config.model_name = model.clone();