Merge remote-tracking branch 'origin/main' into ldelalande/bump-versions

* origin/main:
  fix: clarify linux cli install only (#927)
  feat: update ui for ollama host (#912)
  feat: add CONFIGURE=false option in install script (#920)
  fix: truncation agent token calculations (#915)
  fix: request payload for o1 models (#921)
  Update SupportedEnvironments.js so others don't get confused on why they can not open the macos app on x86 (#888)
  fix: improve configure process with error message (#919)
  docs: Goose on Windows via WSL (#901)
  fix: more graceful handling of missing usage in provider response (#907)
  feat: rm uv.lock cause it points to square artifactory (#917)
  feat: Update issue templates for bug report for goose (#913)
  fix: post endpoint url on sse endpoint event (#900)

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,34 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Please provide following information:**
+ - **OS & Arch:** [e.g. Ubuntu 22.04 x86]
+ - **Interface:** [UI/CLI]
+ - **Version:** [e.g. v1.0.2]
+ - **Extensions enabled:** [e.g. Computer Controller, Figma]
+ - **Provider & Model:** [e.g. Google - gemini-1.5-pro]
+
+**Additional context**
+Add any other context about the problem here.

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

@@ -4,7 +4,8 @@ use goose::agents::{extension::Envs, ExtensionConfig};
 use goose::config::{Config, ConfigError, ExtensionEntry, ExtensionManager};
 use goose::message::Message;
 use goose::providers::{create, providers};
-use serde_json::Value;
+use mcp_core::Tool;
+use serde_json::{json, Value};
 use std::collections::HashMap;
 use std::error::Error;
 
@@ -270,37 +271,36 @@ pub async fn configure_provider_dialog() -> Result<bool, Box<dyn Error>> {
     let model_config = goose::model::ModelConfig::new(model.clone()).with_max_tokens(Some(10));
     let provider = create(provider_name, model_config)?;
 
-    let message = Message::user().with_text(
-        "Please give a nice welcome message (one sentence) and let them know they are all set to use this agent"
+    let messages =
+        vec![Message::user().with_text("What is the weather like in San Francisco today?")];
+    let sample_tool = Tool::new(
+        "get_weather".to_string(),
+        "Get current temperature for a given location.".to_string(),
+        json!({
+            "type": "object",
+            "required": ["location"],
+            "properties": {
+                "location": {"type": "string"}
+            }
+        }),
     );
 
     let result = provider
         .complete(
             "You are an AI agent called Goose. You use tools of connected extensions to solve problems.",
-            &[message],
-            &[]
+            &messages,
+            &[sample_tool]
         )
         .await;
 
     match result {
-        Ok((message, _usage)) => {
-            if let Some(content) = message.content.first() {
-                if let Some(text) = content.as_text() {
-                    spin.stop(text);
-                } else {
-                    spin.stop("No response text available");
-                }
-            } else {
-                spin.stop("No response content available");
-            }
-
+        Ok((_message, _usage)) => {
             cliclack::outro("Configuration saved successfully")?;
             Ok(true)
         }
         Err(e) => {
-            println!("{:?}", e);
-            spin.stop("We could not connect!");
-            let _ = cliclack::outro("The provider configuration was invalid");
+            spin.stop(style(e.to_string()).red());
+            cliclack::outro(style("Failed to configure provider: init chat completion request with tool did not succeed.").on_red().white())?;
             Ok(false)
         }
     }

crates/goose-server/src/routes/secrets.rs → crates/goose-server/src/routes/configs.rs

@@ -8,23 +8,23 @@ use serde_json::Value;
 use std::collections::HashMap;
 
 #[derive(Serialize)]
-struct SecretResponse {
+struct ConfigResponse {
     error: bool,
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct SecretRequest {
+struct ConfigRequest {
     key: String,
     value: String,
     is_secret: bool,
 }
 
-async fn store_secret(
+async fn store_config(
     State(state): State<AppState>,
     headers: HeaderMap,
-    Json(request): Json<SecretRequest>,
-) -> Result<Json<SecretResponse>, StatusCode> {
+    Json(request): Json<ConfigRequest>,
+) -> Result<Json<ConfigResponse>, StatusCode> {
     // Verify secret key
     let secret_key = headers
         .get("X-Secret-Key")
@@ -42,18 +42,18 @@ async fn store_secret(
         config.set(&request.key, Value::String(request.value))
     };
     match result {
-        Ok(_) => Ok(Json(SecretResponse { error: false })),
-        Err(_) => Ok(Json(SecretResponse { error: true })),
+        Ok(_) => Ok(Json(ConfigResponse { error: false })),
+        Err(_) => Ok(Json(ConfigResponse { error: true })),
     }
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-pub struct ProviderSecretRequest {
+pub struct ProviderConfigRequest {
     pub providers: Vec<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-pub struct SecretStatus {
+pub struct ConfigStatus {
     pub is_set: bool,
     pub location: Option<String>,
 }
@@ -64,7 +64,7 @@ pub struct ProviderResponse {
     pub name: Option<String>,
     pub description: Option<String>,
     pub models: Option<Vec<String>>,
-    pub secret_status: HashMap<String, SecretStatus>,
+    pub config_status: HashMap<String, ConfigStatus>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -80,30 +80,33 @@ static PROVIDER_ENV_REQUIREMENTS: Lazy<HashMap<String, ProviderConfig>> = Lazy::
     serde_json::from_str(contents).expect("Failed to parse providers_and_keys.json")
 });
 
-fn check_key_status(key: &str) -> (bool, Option<String>) {
+fn check_key_status(config: &Config, key: &str) -> (bool, Option<String>) {
     if let Ok(_value) = std::env::var(key) {
         (true, Some("env".to_string()))
-    } else if Config::global().get_secret::<String>(key).is_ok() {
+    } else if config.get::<String>(key).is_ok() {
+        (true, Some("yaml".to_string()))
+    } else if config.get_secret::<String>(key).is_ok() {
         (true, Some("keyring".to_string()))
     } else {
         (false, None)
     }
 }
 
-async fn check_provider_secrets(
-    Json(request): Json<ProviderSecretRequest>,
+async fn check_provider_configs(
+    Json(request): Json<ProviderConfigRequest>,
 ) -> Result<Json<HashMap<String, ProviderResponse>>, StatusCode> {
     let mut response = HashMap::new();
+    let config = Config::global();
 
     for provider_name in request.providers {
         if let Some(provider_config) = PROVIDER_ENV_REQUIREMENTS.get(&provider_name) {
-            let mut secret_status = HashMap::new();
+            let mut config_status = HashMap::new();
 
             for key in &provider_config.required_keys {
-                let (key_set, key_location) = check_key_status(key);
-                secret_status.insert(
+                let (key_set, key_location) = check_key_status(config, key);
+                config_status.insert(
                     key.to_string(),
-                    SecretStatus {
+                    ConfigStatus {
                         is_set: key_set,
                         location: key_location,
                     },
@@ -117,7 +120,7 @@ async fn check_provider_secrets(
                     name: Some(provider_config.name.clone()),
                     description: Some(provider_config.description.clone()),
                     models: Some(provider_config.models.clone()),
-                    secret_status,
+                    config_status,
                 },
             );
         } else {
@@ -128,7 +131,7 @@ async fn check_provider_secrets(
                     name: None,
                     description: None,
                     models: None,
-                    secret_status: HashMap::new(),
+                    config_status: HashMap::new(),
                 },
             );
         }
@@ -138,14 +141,16 @@ async fn check_provider_secrets(
 }
 
 #[derive(Deserialize)]
-struct DeleteSecretRequest {
+#[serde(rename_all = "camelCase")]
+struct DeleteConfigRequest {
     key: String,
+    is_secret: bool,
 }
 
-async fn delete_secret(
+async fn delete_config(
     State(state): State<AppState>,
     headers: HeaderMap,
-    Json(request): Json<DeleteSecretRequest>,
+    Json(request): Json<DeleteConfigRequest>,
 ) -> Result<StatusCode, StatusCode> {
     // Verify secret key
     let secret_key = headers
@@ -158,17 +163,23 @@ async fn delete_secret(
     }
 
     // Attempt to delete the key
-    match Config::global().delete_secret(&request.key) {
+    let config = Config::global();
+    let result = if request.is_secret {
+        config.delete_secret(&request.key)
+    } else {
+        config.delete(&request.key)
+    };
+    match result {
         Ok(_) => Ok(StatusCode::NO_CONTENT),
         Err(_) => Err(StatusCode::NOT_FOUND),
     }
 }
 
 pub fn routes(state: AppState) -> Router {
     Router::new()
-        .route("/secrets/providers", post(check_provider_secrets))
-        .route("/secrets/store", post(store_secret))
-        .route("/secrets/delete", delete(delete_secret))
+        .route("/configs/providers", post(check_provider_configs))
+        .route("/configs/store", post(store_config))
+        .route("/configs/delete", delete(delete_config))
         .with_state(state)
 }
 
@@ -179,12 +190,12 @@ mod tests {
     #[tokio::test]
     async fn test_unsupported_provider() {
         // Setup
-        let request = ProviderSecretRequest {
+        let request = ProviderConfigRequest {
             providers: vec!["unsupported_provider".to_string()],
         };
 
         // Execute
-        let result = check_provider_secrets(Json(request)).await;
+        let result = check_provider_configs(Json(request)).await;
 
         // Assert
         assert!(result.is_ok());
@@ -194,6 +205,6 @@ mod tests {
             .get("unsupported_provider")
             .expect("Provider should exist");
         assert!(!provider_status.supported);
-        assert!(provider_status.secret_status.is_empty());
+        assert!(provider_status.config_status.is_empty());
     }
 }

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

@@ -1,9 +1,9 @@
 // Export route modules
 pub mod agent;
+pub mod configs;
 pub mod extension;
 pub mod health;
 pub mod reply;
-pub mod secrets;
 
 use axum::Router;
 
@@ -14,5 +14,5 @@ pub fn configure(state: crate::state::AppState) -> Router {
         .merge(reply::routes(state.clone()))
         .merge(agent::routes(state.clone()))
         .merge(extension::routes(state.clone()))
-        .merge(secrets::routes(state))
+        .merge(configs::routes(state))
 }

crates/goose-server/src/routes/providers_and_keys.json

@@ -33,7 +33,7 @@
         "name": "Ollama",
         "description": "Lorem ipsum",
         "models": ["qwen2.5"],
-        "required_keys": []
+        "required_keys": ["OLLAMA_HOST"]
     },
     "openrouter": {
         "name": "OpenRouter",

crates/goose/src/agents/truncate.rs

@@ -43,6 +43,8 @@ impl TruncateAgent {
         &self,
         messages: &mut Vec<Message>,
         estimate_factor: f32,
+        system_prompt: &str,
+        tools: &mut Vec<Tool>,
     ) -> anyhow::Result<()> {
         // Model's actual context limit
         let context_limit = self
@@ -57,20 +59,37 @@ impl TruncateAgent {
         // Our token count is an estimate since model providers often don't provide the tokenizer (eg. Claude)
         let context_limit = (context_limit as f32 * estimate_factor) as usize;
 
-        // Calculate current token count
+        // Take into account the system prompt, and our tools input and subtract that from the
+        // remaining context limit
+        let system_prompt_token_count = self.token_counter.count_tokens(system_prompt);
+        let tools_token_count = self.token_counter.count_tokens_for_tools(tools.as_slice());
+
+        // Check if system prompt + tools exceed our context limit
+        let remaining_tokens = context_limit
+            .checked_sub(system_prompt_token_count)
+            .and_then(|remaining| remaining.checked_sub(tools_token_count))
+            .ok_or_else(|| {
+                anyhow::anyhow!("System prompt and tools exceed estimated context limit")
+            })?;
+
+        let context_limit = remaining_tokens;
+
+        // Calculate current token count of each message, use count_chat_tokens to ensure we
+        // capture the full content of the message, include ToolRequests and ToolResponses
         let mut token_counts: Vec<usize> = messages
             .iter()
-            .map(|msg| self.token_counter.count_tokens(&msg.as_concat_text()))
+            .map(|msg| {
+                self.token_counter
+                    .count_chat_tokens("", std::slice::from_ref(msg), &[])
+            })
             .collect();
 
-        let _ = truncate_messages(
+        truncate_messages(
             messages,
             &mut token_counts,
             context_limit,
             &OldestFirstTruncation,
-        );
-
-        Ok(())
+        )
     }
 }
 
@@ -229,7 +248,7 @@ impl Agent for TruncateAgent {
                             // Create an error message & terminate the stream
                             // the previous message would have been a user message (e.g. before any tool calls, this is just after the input message.
                             // at the start of a loop after a tool call, it would be after a tool_use assistant followed by a tool_result user)
-                            yield Message::assistant().with_text("Error: Context length exceeds limits even after multiple attempts to truncate.");
+                            yield Message::assistant().with_text("Error: Context length exceeds limits even after multiple attempts to truncate. Please start a new session with fresh context and try again.");
                             break;
                         }
 
@@ -243,7 +262,11 @@ impl Agent for TruncateAgent {
                         // release the lock before truncation to prevent deadlock
                         drop(capabilities);
 
-                        self.truncate_messages(&mut messages, estimate_factor).await?;
+                        if let Err(err) = self.truncate_messages(&mut messages, estimate_factor, &system_prompt, &mut tools).await {
+                            yield Message::assistant().with_text(format!("Error: Unable to truncate messages to stay within context limit. \n\nRan into this error: {}.\n\nPlease start a new session with fresh context and try again.", err));
+                            break;
+                        }
+
 
                         // Re-acquire the lock
                         capabilities = self.capabilities.lock().await;