Sync upstream changes for 2026-06-09

crates/goose-cli/Cargo.toml

@@ -23,6 +23,7 @@ path = "src/bin/generate_manpages.rs"
 clap_mangen = { version = "0.3", default-features = false }
 goose = { path = "../goose", default-features = false }
 goose-mcp = { path = "../goose-mcp", default-features = false }
+goose-providers = { path = "../goose-providers", default-features = false }
 rmcp = { workspace = true }
 clap = { workspace = true }
 cliclack = { version = "0.5", default-features = false }

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

@@ -3,8 +3,8 @@ use console::style;
 use goose::config::paths::Paths;
 use goose::config::Config;
 use goose::conversation::message::Message;
-use goose::providers::errors::ProviderError;
 use goose::session::session_manager::{DB_NAME, SESSIONS_FOLDER};
+use goose_providers::errors::ProviderError;
 use serde_yaml;
 use std::time::Duration;
 

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

@@ -2091,11 +2091,11 @@ fn handle_agent_error(e: &anyhow::Error, is_stream_json_mode: bool) {
         });
     }
 
-    if e.downcast_ref::<goose::providers::errors::ProviderError>()
+    if e.downcast_ref::<goose_providers::errors::ProviderError>()
         .map(|provider_error| {
             matches!(
                 provider_error,
-                goose::providers::errors::ProviderError::ContextLengthExceeded(_)
+                goose_providers::errors::ProviderError::ContextLengthExceeded(_)
             )
         })
         .unwrap_or(false)
@@ -2366,7 +2366,7 @@ mod tests {
         assert_eq!(current.model_name, "gpt-5.4");
         assert_eq!(
             current.thinking_effort(),
-            Some(goose::model::ThinkingEffort::High)
+            Some(goose_providers::thinking::ThinkingEffort::High)
         );
 
         let switched = build_switched_model_config("openai", "gpt-5.4", &current).unwrap();

crates/goose-providers/Cargo.toml

@@ -13,11 +13,14 @@ workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
+async-stream = { workspace = true }
 base64 = { workspace = true }
 chrono = { workspace = true }
+futures = { workspace = true }
 once_cell = { workspace = true }
-regex = { workspace = true }
-rmcp = { workspace = true, features = ["server"] }
+regex = { workspace = true, features = ["unicode"] }
+reqwest = { workspace = true }
+rmcp = { workspace = true, features = ["server", "macros"] }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
@@ -28,3 +31,6 @@ uuid = { workspace = true, features = ["v4", "std"] }
 
 [dev-dependencies]
 test-case = { workspace = true }
+tempfile = { workspace = true }
+tokio = { workspace = true }
+tokio-stream = { workspace = true }

crates/goose-providers/src/base.rs

@@ -0,0 +1,17 @@
+use std::future::Future;
+
+pub struct Error;
+
+pub struct Model {
+    pub name: String,
+}
+
+pub struct StreamingRequest {
+    pub model: Model,
+}
+
+pub struct StreamingResponse;
+
+pub trait Provider {
+    fn stream(req: StreamingRequest) -> impl Future<Output = Result<StreamingResponse, Error>>;
+}

crates/goose-providers/src/conversation/mod.rs → crates/goose-providers/src/conversation.rs

@@ -7,6 +7,7 @@ use thiserror::Error;
 use utoipa::ToSchema;
 
 pub mod message;
+pub mod token_usage;
 mod tool_result_serde;
 
 #[derive(Debug, Clone, Serialize, Deserialize, ToSchema, PartialEq)]

crates/goose-providers/src/conversation/token_usage.rs

@@ -0,0 +1,148 @@
+use std::ops::{Add, AddAssign};
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProviderUsage {
+    pub model: String,
+    pub usage: Usage,
+}
+
+impl ProviderUsage {
+    pub fn new(model: String, usage: Usage) -> Self {
+        Self { model, usage }
+    }
+
+    /// Combine this ProviderUsage with another, adding their token counts
+    /// Uses the model from this ProviderUsage
+    pub fn combine_with(&self, other: &ProviderUsage) -> ProviderUsage {
+        ProviderUsage {
+            model: self.model.clone(),
+            usage: self.usage + other.usage,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default, Copy)]
+pub struct Usage {
+    pub input_tokens: Option<i32>,
+    pub output_tokens: Option<i32>,
+    pub total_tokens: Option<i32>,
+    pub cache_read_input_tokens: Option<i32>,
+    pub cache_write_input_tokens: Option<i32>,
+}
+
+fn sum_optionals<T>(a: Option<T>, b: Option<T>) -> Option<T>
+where
+    T: Add<Output = T> + Default,
+{
+    match (a, b) {
+        (Some(x), Some(y)) => Some(x + y),
+        (Some(x), None) => Some(x + T::default()),
+        (None, Some(y)) => Some(T::default() + y),
+        (None, None) => None,
+    }
+}
+
+impl Add for Usage {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        Self::new(
+            sum_optionals(self.input_tokens, other.input_tokens),
+            sum_optionals(self.output_tokens, other.output_tokens),
+            sum_optionals(self.total_tokens, other.total_tokens),
+        )
+        .with_cache_tokens(
+            sum_optionals(self.cache_read_input_tokens, other.cache_read_input_tokens),
+            sum_optionals(
+                self.cache_write_input_tokens,
+                other.cache_write_input_tokens,
+            ),
+        )
+    }
+}
+
+impl AddAssign for Usage {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs;
+    }
+}
+
+impl Usage {
+    pub fn new(
+        input_tokens: Option<i32>,
+        output_tokens: Option<i32>,
+        total_tokens: Option<i32>,
+    ) -> Self {
+        let calculated_total = if total_tokens.is_none() {
+            match (input_tokens, output_tokens) {
+                (Some(input), Some(output)) => Some(input + output),
+                (Some(input), None) => Some(input),
+                (None, Some(output)) => Some(output),
+                (None, None) => None,
+            }
+        } else {
+            total_tokens
+        };
+
+        Self {
+            input_tokens,
+            output_tokens,
+            total_tokens: calculated_total,
+            cache_read_input_tokens: None,
+            cache_write_input_tokens: None,
+        }
+    }
+
+    pub fn with_cache_tokens(
+        mut self,
+        cache_read_input_tokens: Option<i32>,
+        cache_write_input_tokens: Option<i32>,
+    ) -> Self {
+        self.cache_read_input_tokens = cache_read_input_tokens;
+        self.cache_write_input_tokens = cache_write_input_tokens;
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anyhow::Result;
+    use serde_json::json;
+
+    #[test]
+    fn test_usage_serialization() -> Result<()> {
+        let usage = Usage::new(Some(10), Some(20), Some(30));
+        let serialized = serde_json::to_string(&usage)?;
+        let deserialized: Usage = serde_json::from_str(&serialized)?;
+
+        assert_eq!(usage.input_tokens, deserialized.input_tokens);
+        assert_eq!(usage.output_tokens, deserialized.output_tokens);
+        assert_eq!(usage.total_tokens, deserialized.total_tokens);
+
+        // Test JSON structure
+        let json_value: serde_json::Value = serde_json::from_str(&serialized)?;
+        assert_eq!(json_value["input_tokens"], json!(10));
+        assert_eq!(json_value["output_tokens"], json!(20));
+        assert_eq!(json_value["total_tokens"], json!(30));
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_usage_addition_includes_cached_tokens() {
+        let usage_a =
+            Usage::new(Some(100), Some(20), Some(120)).with_cache_tokens(Some(10), Some(5));
+        let usage_b = Usage::new(Some(50), Some(8), Some(58)).with_cache_tokens(Some(4), Some(1));
+
+        let combined = usage_a + usage_b;
+
+        assert_eq!(combined.input_tokens, Some(150));
+        assert_eq!(combined.output_tokens, Some(28));
+        assert_eq!(combined.total_tokens, Some(178));
+        assert_eq!(combined.cache_read_input_tokens, Some(14));
+        assert_eq!(combined.cache_write_input_tokens, Some(6));
+    }
+}

crates/goose-providers/src/formats.rs

@@ -0,0 +1 @@
+pub mod openai;