From a701bb1756f0c6a49a7dbc10ac8a90f94dd24bd1 Mon Sep 17 00:00:00 2001 From: Vincenzo Palazzo Date: Tue, 29 Sep 2026 02:47:01 +0000 Subject: [PATCH] Add Meta Muse Code provider (#11765) --- .../src/canonical/name_builder.rs | 1 + .../src/formats/anthropic.rs | 35 +- crates/goose-providers/src/anthropic.rs | 7 +- crates/goose-providers/src/api_client.rs | 11 + .../src/declarative/definitions/meta.json | 36 + crates/goose/src/providers/init.rs | 10 + .../src/providers/inventory/registrations.rs | 39 + crates/goose/src/providers/mod.rs | 1 + crates/goose/src/providers/muse_code_def.rs | 1279 +++++++++++++++++ goose-self-test.yaml | 5 + 10 files changed, 1415 insertions(+), 9 deletions(-) create mode 100644 crates/goose/src/providers/muse_code_def.rs diff --git a/crates/goose-provider-types/src/canonical/name_builder.rs b/crates/goose-provider-types/src/canonical/name_builder.rs index 7914ac183..5a078434d 100644 --- a/crates/goose-provider-types/src/canonical/name_builder.rs +++ b/crates/goose-provider-types/src/canonical/name_builder.rs @@ -58,6 +58,7 @@ pub fn map_provider_name(provider: &str) -> &str { "opencode_zen" => "opencode", "ollama_cloud" => "ollama-cloud", "kimi_code" => "kimi-code-plan-cn", + "muse_code" => "meta", _ => provider, } } diff --git a/crates/goose-provider-types/src/formats/anthropic.rs b/crates/goose-provider-types/src/formats/anthropic.rs index a259f5b00..7bc98077f 100644 --- a/crates/goose-provider-types/src/formats/anthropic.rs +++ b/crates/goose-provider-types/src/formats/anthropic.rs @@ -78,7 +78,7 @@ impl AnthropicFormatOptions { } } - fn for_model(self, model_config: &ModelConfig) -> Self { + fn for_model(self, provider_name: &str, model_config: &ModelConfig) -> Self { let preserve_thinking_context = model_config .request_param::("preserve_thinking_context") .unwrap_or(self.preserve_thinking_context); @@ -86,8 +86,11 @@ impl AnthropicFormatOptions { .request_param::("preserve_unsigned_thinking") .unwrap_or(self.preserve_unsigned_thinking) || preserve_thinking_context; - let thinking_disabled = model_config.reasoning == Some(false) - || model_config.thinking_effort() == Some(ThinkingEffort::Off); + let always_on = canonical_thinking_mode(provider_name, &model_config.model_name) + == Some(ThinkingMode::AlwaysOnAdaptive); + let thinking_disabled = !always_on + && (model_config.reasoning == Some(false) + || model_config.thinking_effort() == Some(ThinkingEffort::Off)); let emit_clear_thinking = model_config .request_param::("emit_clear_thinking") .unwrap_or(self.emit_clear_thinking); @@ -148,7 +151,18 @@ pub fn thinking_block_is_stale(message: &Message, current_model: Option<&str>) - } fn canonical_thinking_mode(provider_name: &str, model_name: &str) -> Option { - maybe_get_canonical_model(provider_name, model_name).and_then(|model| model.thinking_mode) + maybe_get_canonical_model(provider_name, model_name) + .and_then(|model| model.thinking_mode) + .or_else(|| provider_thinking_mode(provider_name, model_name)) +} + +/// Models that always reason when the canonical entry has no thinking mode. +/// Muse Spark rejects `thinking: disabled` and ignores `budget_tokens`. +fn provider_thinking_mode(provider_name: &str, model_name: &str) -> Option { + if provider_name == "muse_code" && model_name.starts_with("muse-spark") { + return Some(ThinkingMode::AlwaysOnAdaptive); + } + None } /// Adaptive models run adaptive thinking when `thinking` is omitted, so turning @@ -759,6 +773,15 @@ pub fn thinking_effort(model_config: &ModelConfig) -> ThinkingEffort { .unwrap_or(ThinkingEffort::High) } +fn adaptive_effort_wire(provider_name: &str, model_config: &ModelConfig) -> String { + let effort = adaptive_output_effort(model_config); + // Meta Messages accepts low, medium, high, and xhigh. goose's max maps to xhigh. + if provider_name == "muse_code" && effort == ThinkingEffort::Max { + return "xhigh".to_string(); + } + effort.to_string() +} + pub fn adaptive_output_effort(model_config: &ModelConfig) -> ThinkingEffort { match thinking_effort(model_config) { ThinkingEffort::Off => ThinkingEffort::High, @@ -805,7 +828,7 @@ fn apply_thinking_config( match thinking_type_for_provider(provider_name, model_config) { ThinkingType::Adaptive => { obj.insert("thinking".to_string(), json!({"type": "adaptive"})); - let effort = adaptive_output_effort(model_config).to_string(); + let effort = adaptive_effort_wire(provider_name, model_config); obj.insert("output_config".to_string(), json!({"effort": effort})); } ThinkingType::Enabled => { @@ -909,7 +932,7 @@ pub fn create_request_for_model( tools: &[Tool], options: AnthropicFormatOptions, ) -> Result { - let options = options.for_model(model_config); + let options = options.for_model(provider_name, model_config); let anthropic_messages = format_messages_with_options(messages, &options); let tool_specs = format_tools(tools, &options); let system_spec = format_system(system, &options); diff --git a/crates/goose-providers/src/anthropic.rs b/crates/goose-providers/src/anthropic.rs index 0e586a0a3..2bbeaff8f 100644 --- a/crates/goose-providers/src/anthropic.rs +++ b/crates/goose-providers/src/anthropic.rs @@ -17,10 +17,11 @@ use super::api_client::ApiClient; use super::base::{ known_models_from_registry, ConfigKey, MessageStream, ModelInfo, Provider, ProviderMetadata, }; +pub use super::formats::anthropic::AnthropicFormatOptions; use super::formats::anthropic::{ block_binding_behavior, create_request_for_model, is_thinking_signature_error, - response_to_streaming_message, AnthropicFormatOptions, PrefixMismatchBehavior, - ANTHROPIC_PROVIDER_NAME, INPUT_TRANSFORMATIONS_FIELD, THINKING_BINDING_CONTROLS_BETA, + response_to_streaming_message, PrefixMismatchBehavior, ANTHROPIC_PROVIDER_NAME, + INPUT_TRANSFORMATIONS_FIELD, THINKING_BINDING_CONTROLS_BETA, }; use super::openai_compatible::handle_status; use super::retry::ProviderRetry; @@ -153,7 +154,7 @@ impl AnthropicProvider { format_options: AnthropicFormatOptions, ) -> Result { let mut payload = create_request_for_model( - ANTHROPIC_PROVIDER_NAME, + &self.name, model_config, wire_model, system, diff --git a/crates/goose-providers/src/api_client.rs b/crates/goose-providers/src/api_client.rs index 30bf40380..0c54e0a0e 100644 --- a/crates/goose-providers/src/api_client.rs +++ b/crates/goose-providers/src/api_client.rs @@ -317,6 +317,17 @@ impl ApiClient { .read_timeout(timeout) } + /// Build a reqwest client that honors the same custom CA and client + /// certificate settings as provider API clients. + pub fn http_client(tls_config: Option<&TlsConfig>) -> Result { + let mut client_builder = + Self::client_builder(Duration::from_secs(DEFAULT_PROVIDER_TIMEOUT_SECS)); + if let Some(tls_config) = tls_config { + client_builder = Self::configure_tls(client_builder, tls_config)?; + } + Ok(client_builder.build()?) + } + fn rebuild_client(&mut self) -> Result<()> { let mut client_builder = Self::client_builder(self.timeout).default_headers(self.default_headers.clone()); diff --git a/crates/goose-providers/src/declarative/definitions/meta.json b/crates/goose-providers/src/declarative/definitions/meta.json index 6b0c0f123..2de3cfc36 100644 --- a/crates/goose-providers/src/declarative/definitions/meta.json +++ b/crates/goose-providers/src/declarative/definitions/meta.json @@ -16,6 +16,42 @@ "output_token_cost": 0.00000425, "currency": "USD", "reasoning": true + }, + { + "name": "muse-spark-1.2", + "context_limit": 1048576, + "max_tokens": 131072, + "input_token_cost": 0.00000125, + "output_token_cost": 0.00000425, + "currency": "USD", + "reasoning": true + }, + { + "name": "muse-spark-1.2-contributor", + "context_limit": 1048576, + "max_tokens": 131072, + "input_token_cost": 0.0000001, + "output_token_cost": 0.0000002, + "currency": "USD", + "reasoning": true + }, + { + "name": "muse-spark-1.3", + "context_limit": 1048576, + "max_tokens": 131072, + "input_token_cost": 0.00000125, + "output_token_cost": 0.00000425, + "currency": "USD", + "reasoning": true + }, + { + "name": "muse-spark-1.3-contributor", + "context_limit": 1048576, + "max_tokens": 131072, + "input_token_cost": 0.0000001, + "output_token_cost": 0.0000002, + "currency": "USD", + "reasoning": true } ], "preserves_thinking": true, diff --git a/crates/goose/src/providers/init.rs b/crates/goose/src/providers/init.rs index 543cb49c3..04702c1d3 100644 --- a/crates/goose/src/providers/init.rs +++ b/crates/goose/src/providers/init.rs @@ -42,6 +42,7 @@ use crate::providers::base::ProviderType; use crate::providers::databricks_def::{self, DatabricksProviderDef}; use crate::providers::databricks_v2_def::{self, DatabricksV2ProviderDef}; use crate::providers::google_def::GoogleProviderDef; +use crate::providers::muse_code_def::{MuseCodeProvider, MuseCodeProviderDef}; use crate::providers::ollama_def::OllamaProviderDef; use crate::providers::openai_def::OpenAiProviderDef; use crate::providers::openrouter_def::OpenRouterProviderDef; @@ -149,6 +150,10 @@ async fn init_registry() -> RwLock { ); registry .register_with_inventory::(true, Some(registrations::refresh_only())); + registry.register_with_inventory::( + true, + Some(registrations::muse_code_inventory()), + ); registry.register_with_inventory::( true, Some(registrations::ollama_inventory()), @@ -198,6 +203,10 @@ async fn init_registry() -> RwLock { "kimi_code", Arc::new(|| Box::pin(KimiCodeProvider::cleanup())), ); + registry.set_cleanup( + "muse_code", + Arc::new(|| Box::pin(MuseCodeProvider::cleanup())), + ); registry.set_cleanup( "chatgpt_codex", Arc::new(|| Box::pin(ChatGptCodexProvider::cleanup())), @@ -566,6 +575,7 @@ mod tests { "gcp_vertex_ai", "github_copilot", "kimi_code", + "muse_code", "nano-gpt", "tetrate", "xai", diff --git a/crates/goose/src/providers/inventory/registrations.rs b/crates/goose/src/providers/inventory/registrations.rs index 67a90c915..f75ad3d8b 100644 --- a/crates/goose/src/providers/inventory/registrations.rs +++ b/crates/goose/src/providers/inventory/registrations.rs @@ -16,6 +16,7 @@ use crate::providers::google::{GOOGLE_API_HOST, GOOGLE_PROVIDER_NAME}; use crate::providers::huggingface::HuggingFaceProvider; use crate::providers::huggingface_auth; use crate::providers::kimicode; +use crate::providers::muse_code_def; use crate::providers::ollama::OLLAMA_PROVIDER_NAME; use crate::providers::openai::{OPEN_AI_DEFAULT_BASE_PATH, OPEN_AI_PROVIDER_NAME}; use crate::providers::pi_acp::{PI_ACP_BINARY, PI_ACP_PROVIDER_NAME}; @@ -199,6 +200,10 @@ pub fn kimi_code_inventory() -> InventoryRegistration { refresh_only().with_configured(kimicode::has_configured_token) } +pub fn muse_code_inventory() -> InventoryRegistration { + refresh_only().with_configured(muse_code_def::has_configured_token) +} + pub fn chatgpt_codex_inventory() -> InventoryRegistration { InventoryRegistration { supports_refresh: false, @@ -351,4 +356,38 @@ mod tests { assert!(configured()); } + + #[test] + #[serial_test::serial] + fn muse_code_inventory_configured_uses_token_cache() { + let root = tempfile::tempdir().unwrap(); + let root_path = root.path().to_string_lossy().to_string(); + let _guard = env_lock::lock_env([ + ("GOOSE_PATH_ROOT", Some(root_path.as_str())), + ("MUSE_AUTH_PATH", Some("/tmp/goose-missing-muse-auth.json")), + ("XDG_CONFIG_HOME", Some(root_path.as_str())), + ]); + + let registration = muse_code_inventory(); + let configured = registration + .configured + .expect("Muse Code should define configured resolver"); + + assert!(!configured()); + + let cache_path = Paths::in_config_dir("muse_code/token.json"); + std::fs::create_dir_all(cache_path.parent().unwrap()).unwrap(); + std::fs::write( + cache_path, + serde_json::to_string(&serde_json::json!({ + "access_token": "access", + "refresh_token": "refresh", + "expires_at": (Utc::now() + chrono::Duration::hours(1)).to_rfc3339(), + })) + .unwrap(), + ) + .unwrap(); + + assert!(configured()); + } } diff --git a/crates/goose/src/providers/mod.rs b/crates/goose/src/providers/mod.rs index ce333e3d2..28710b43f 100644 --- a/crates/goose/src/providers/mod.rs +++ b/crates/goose/src/providers/mod.rs @@ -56,6 +56,7 @@ pub mod kimicode; pub mod litellm; #[cfg(feature = "local-inference")] pub mod local_inference; +pub mod muse_code_def; pub mod nanogpt; pub mod oauth; pub mod oauth_device_flow; diff --git a/crates/goose/src/providers/muse_code_def.rs b/crates/goose/src/providers/muse_code_def.rs new file mode 100644 index 000000000..6961c60e5 --- /dev/null +++ b/crates/goose/src/providers/muse_code_def.rs @@ -0,0 +1,1279 @@ +use anyhow::Result; +use async_trait::async_trait; +use chrono::{DateTime, Duration, Utc}; +use futures::future::BoxFuture; +use goose_providers::anthropic::{ + AnthropicFormatOptions, AnthropicProvider, AnthropicProviderBuilder, ANTHROPIC_API_VERSION, +}; +use goose_providers::api_client::{ApiClient, AuthMethod, AuthProvider, TlsConfig}; +use goose_providers::base::{ + model_info_for_provider_model, ConfigKey, MessageStream, ModelInfo, Provider, + ProviderDescriptor, ProviderMetadata, +}; +use goose_providers::errors::ProviderError; +use goose_providers::model::ModelConfig; +use reqwest::header::{HeaderMap, HeaderValue, ACCEPT, USER_AGENT}; +use reqwest::Client; +use rmcp::model::Tool; +use serde::{Deserialize, Serialize}; +use std::path::PathBuf; +use std::sync::atomic::{AtomicU64, Ordering}; +use std::sync::Arc; +use std::time::Duration as StdDuration; +use tokio::sync::Mutex as TokioMutex; + +use crate::config::paths::Paths; +use crate::config::Config; +use crate::conversation::message::Message; +use crate::providers::base::ProviderDef; +use crate::providers::oauth_device_flow::{ + run_device_flow, DeviceFlowConfig, DeviceFlowTokens, RequestEncoding, +}; +use crate::providers::private_file::write_private_file; + +pub const MUSE_CODE_PROVIDER_NAME: &str = "muse_code"; +pub const MUSE_CODE_API_HOST: &str = "https://api.meta.ai"; +pub const MUSE_CODE_AUTH_HOST: &str = "https://auth.meta.com"; +pub const MUSE_CODE_CLIENT_ID: &str = "1031625952748946"; +const MUSE_CODE_DOC_URL: &str = "https://ai.developer.meta.com/docs/muse-code/subscriptions"; +const MUSE_CODE_USER_AGENT: &str = "goose-muse-code"; + +const MUSE_CODE_KNOWN_MODELS: &[&str] = &[ + "muse-spark-1.3", + "muse-spark-1.2", + "muse-spark-1.1", + "muse-spark-1.2-contributor", + "muse-spark-1.3-contributor", +]; + +const REFRESH_THRESHOLD_SECS: i64 = 300; +/// Minted Model API keys are valid for about a day. The identity token is not +/// renewable: auth.meta.com does not issue a refresh_token and rejects +/// grant_type=refresh_token. Re-mint from the stored identity token instead. +const API_KEY_LIFETIME_SECS: i64 = 24 * 60 * 60; + +static GLOBAL_MUSE_REFRESH_MUTEX: std::sync::OnceLock> = std::sync::OnceLock::new(); + +fn global_muse_refresh_mutex() -> &'static TokioMutex<()> { + GLOBAL_MUSE_REFRESH_MUTEX.get_or_init(|| TokioMutex::new(())) +} + +static MUSE_TOKEN_GENERATION: AtomicU64 = AtomicU64::new(0); + +pub struct MuseCodeProviderDef; + +pub struct MuseCodeProvider { + inner: AnthropicProvider, + auth: Arc, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] +struct MuseToken { + access_token: String, + #[serde(default)] + refresh_token: String, + #[serde(default)] + api_key: String, + expires_at: DateTime, +} + +#[derive(Debug, Deserialize)] +struct MintedKey { + api_key: Option, +} + +#[derive(Debug, Clone)] +pub(crate) struct TokenCache { + path: PathBuf, +} + +struct MuseCodeAuth { + cache: TokenCache, + client: Client, + api_host: String, + auth_host: String, + client_id: String, +} + +struct SharedAuthProvider(Arc); + +fn known_models() -> Vec { + MUSE_CODE_KNOWN_MODELS + .iter() + .map(|&name| model_info_for_provider_model(MUSE_CODE_PROVIDER_NAME, name)) + .collect() +} + +fn tokens_to_muse(tokens: DeviceFlowTokens) -> MuseToken { + MuseToken { + access_token: tokens.access_token, + refresh_token: String::new(), + api_key: String::new(), + expires_at: Utc::now(), + } +} + +fn minted_key_expiry() -> DateTime { + Utc::now() + Duration::seconds(API_KEY_LIFETIME_SECS) +} + +fn mint_error(status: reqwest::StatusCode, body: &str) -> ProviderError { + let details = format!("key mint failed ({status}): {body}"); + if status == reqwest::StatusCode::UNAUTHORIZED || status == reqwest::StatusCode::FORBIDDEN { + return ProviderError::Authentication(format!( + "Meta session expired ({status}). Sign in to Muse Code again. {body}" + )); + } + if status == reqwest::StatusCode::TOO_MANY_REQUESTS { + return ProviderError::RateLimitExceeded { + details, + retry_delay: None, + }; + } + if status.is_server_error() { + return ProviderError::ServerError(details); + } + ProviderError::RequestFailed(details) +} + +fn join_url(host: &str, path: &str) -> String { + format!("{}{}", host.trim_end_matches('/'), path) +} + +pub(crate) fn has_configured_token() -> bool { + TokenCache::new().has_token() || muse_cli_token().is_some() +} + +fn muse_cli_auth_path() -> PathBuf { + if let Ok(path) = std::env::var("MUSE_AUTH_PATH") { + if !path.is_empty() { + return PathBuf::from(path); + } + } + if let Ok(xdg) = std::env::var("XDG_CONFIG_HOME") { + if !xdg.is_empty() { + return PathBuf::from(xdg).join("muse/auth.json"); + } + } + PathBuf::from(std::env::var("HOME").unwrap_or_else(|_| ".".to_string())) + .join(".config/muse/auth.json") +} + +fn muse_cli_keychain_token() -> Option { + #[cfg(feature = "system-keyring")] + { + if std::env::var("MUSE_AUTH_PATH").is_ok() { + return None; + } + + #[derive(Deserialize)] + struct Stored { + #[serde(default)] + api_key: String, + #[serde(default)] + access_token: String, + } + + let entry = keyring::Entry::new("ai.meta.dev.credentials", "meta").ok()?; + let raw = entry.get_password().ok()?; + let stored: Stored = serde_json::from_str(&raw).ok()?; + if stored.api_key.is_empty() { + return None; + } + Some(MuseToken { + access_token: stored.access_token, + refresh_token: String::new(), + api_key: stored.api_key, + expires_at: minted_key_expiry(), + }) + } + + #[cfg(not(feature = "system-keyring"))] + { + None + } +} + +fn muse_cli_token() -> Option { + if let Some(token) = muse_cli_keychain_token() { + return Some(token); + } + + #[derive(Deserialize)] + struct AuthFile { + providers: Providers, + } + #[derive(Deserialize)] + struct Providers { + meta: MetaSlot, + } + #[derive(Deserialize)] + struct MetaSlot { + mechanism: String, + #[serde(default)] + access_token: String, + #[serde(default)] + api_key: String, + expires_at: Option, + } + + let raw = std::fs::read_to_string(muse_cli_auth_path()).ok()?; + let parsed: AuthFile = serde_json::from_str(&raw).ok()?; + if parsed.providers.meta.mechanism != "oauth" { + return None; + } + let api_key = parsed.providers.meta.api_key; + let access_token = parsed.providers.meta.access_token; + if api_key.is_empty() && access_token.is_empty() { + return None; + } + let expires_at = parsed + .providers + .meta + .expires_at + .and_then(|ts| DateTime::from_timestamp(ts as i64, 0)) + .unwrap_or_else(minted_key_expiry); + Some(MuseToken { + access_token, + refresh_token: String::new(), + api_key, + expires_at, + }) +} + +impl TokenCache { + fn new() -> Self { + Self { + path: Paths::in_config_dir("muse_code/token.json"), + } + } + + fn load(&self) -> Option { + let raw = std::fs::read_to_string(&self.path).ok()?; + match serde_json::from_str(&raw) { + Ok(token) => Some(token), + Err(e) => { + tracing::warn!( + "muse_code token cache at {:?} is corrupted ({}); ignoring", + self.path, + e + ); + None + } + } + } + + pub(crate) fn has_token(&self) -> bool { + self.load().is_some() + } + + fn save(&self, token: &MuseToken) -> Result<()> { + if let Some(parent) = self.path.parent() { + std::fs::create_dir_all(parent)?; + } + write_private_file(&self.path, &serde_json::to_string(token)?)?; + Ok(()) + } + + fn clear(&self) -> anyhow::Result<()> { + let result = match std::fs::remove_file(&self.path) { + Ok(()) => Ok(()), + Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()), + Err(error) => Err(error.into()), + }; + if result.is_ok() { + MUSE_TOKEN_GENERATION.fetch_add(1, Ordering::SeqCst); + } + result + } +} + +impl MuseCodeAuth { + fn oauth_headers() -> HeaderMap { + let mut headers = HeaderMap::new(); + headers.insert(ACCEPT, HeaderValue::from_static("application/json")); + headers.insert(USER_AGENT, HeaderValue::from_static(MUSE_CODE_USER_AGENT)); + headers + } + + fn device_flow_config<'a>( + &'a self, + device_auth_url: &'a str, + token_url: &'a str, + ) -> DeviceFlowConfig<'a> { + DeviceFlowConfig { + device_auth_url: Some(device_auth_url), + token_url, + client_id: &self.client_id, + scopes: None, + extra_headers: Self::oauth_headers(), + encoding: RequestEncoding::Form, + } + } + + async fn device_flow_login(&self) -> Result { + let device_auth_url = join_url(&self.auth_host, "/oidc/device/authorization/"); + let token_url = join_url(&self.auth_host, "/oidc/device/token/"); + let cfg = self.device_flow_config(&device_auth_url, &token_url); + let tokens = run_device_flow(&self.client, &cfg).await?; + let mut token = tokens_to_muse(tokens); + token.api_key = self.mint_api_key(&token.access_token).await?; + token.expires_at = minted_key_expiry(); + Ok(token) + } + + async fn mint_api_key(&self, access_token: &str) -> Result { + let url = join_url(&self.api_host, "/muse-code/key"); + let response = self + .client + .post(url) + .header(ACCEPT, "application/json") + .header(USER_AGENT, MUSE_CODE_USER_AGENT) + .header("x-api-version", "1.0.0") + .bearer_auth(access_token) + .json(&serde_json::json!({})) + .send() + .await?; + let status = response.status(); + let bytes = response.bytes().await?; + if !status.is_success() { + return Err(mint_error(status, &String::from_utf8_lossy(&bytes)).into()); + } + let minted: MintedKey = serde_json::from_slice(&bytes)?; + minted + .api_key + .filter(|key| !key.is_empty()) + .ok_or_else(|| anyhow::anyhow!("mint response missing api_key")) + } + + async fn renew_api_key(&self, token: &MuseToken) -> Result { + if token.access_token.is_empty() { + return Err(ProviderError::Authentication( + "Meta session cannot be renewed. Sign in to Muse Code again.".to_string(), + )); + } + let api_key = self + .mint_api_key(&token.access_token) + .await + .map_err(|error| match error.downcast::() { + Ok(provider_error) => provider_error, + Err(error) => { + ProviderError::Authentication(format!("Failed to renew Muse API key: {error}")) + } + })?; + Ok(MuseToken { + api_key, + expires_at: minted_key_expiry(), + ..token.clone() + }) + } + + async fn get_valid_token(&self) -> Result { + let generation = MUSE_TOKEN_GENERATION.load(Ordering::SeqCst); + if let Some(token) = self.cache.load() { + match self.use_or_refresh(token, generation).await { + Ok(token) => return self.ensure_api_key(token, generation).await, + Err(ProviderError::NotConfigured) => {} + Err(error) => return Err(error), + } + } + + if let Some(token) = muse_cli_token() { + if token.expires_at > Utc::now() { + return self.ensure_api_key(token, generation).await; + } + } + + Err(ProviderError::NotConfigured) + } + + async fn ensure_api_key( + &self, + mut token: MuseToken, + generation: u64, + ) -> Result { + if !token.api_key.is_empty() { + return Ok(token); + } + if token.access_token.is_empty() { + return Err(ProviderError::NotConfigured); + } + token.api_key = self + .mint_api_key(&token.access_token) + .await + .map_err(|error| { + ProviderError::Authentication(format!("Failed to mint Muse API key: {error}")) + })?; + self.save_unless_cleaned(&token, generation).await?; + Ok(token) + } + + async fn save_unless_cleaned( + &self, + token: &MuseToken, + generation: u64, + ) -> Result<(), ProviderError> { + let _guard = global_muse_refresh_mutex().lock().await; + if MUSE_TOKEN_GENERATION.load(Ordering::SeqCst) != generation { + return Err(ProviderError::Authentication( + "Muse Code credential was removed during authentication".to_string(), + )); + } + self.cache.save(token).map_err(|error| { + ProviderError::Authentication(format!("Failed to save Muse Code credential: {error}")) + }) + } + + async fn use_or_refresh( + &self, + token: MuseToken, + generation: u64, + ) -> Result { + if !token.api_key.is_empty() + && token.expires_at - Utc::now() > Duration::seconds(REFRESH_THRESHOLD_SECS) + { + return Ok(token); + } + + if token.access_token.is_empty() { + if !token.api_key.is_empty() && token.expires_at > Utc::now() { + return Ok(token); + } + let _ = self.cache.clear(); + return Err(ProviderError::Authentication( + "Meta session expired. Sign in to Muse Code again.".to_string(), + )); + } + + let _guard = global_muse_refresh_mutex().lock().await; + if MUSE_TOKEN_GENERATION.load(Ordering::SeqCst) != generation { + return Err(ProviderError::Authentication( + "Muse Code credential was removed during authentication".to_string(), + )); + } + if let Some(reloaded) = self.cache.load() { + if reloaded != token + && !reloaded.api_key.is_empty() + && reloaded.expires_at - Utc::now() > Duration::seconds(REFRESH_THRESHOLD_SECS) + { + return Ok(reloaded); + } + } + drop(_guard); + + match self.renew_api_key(&token).await { + Ok(renewed) => { + self.save_unless_cleaned(&renewed, generation).await?; + Ok(renewed) + } + Err(error) => { + if matches!(error, ProviderError::Authentication(_)) { + let _guard = global_muse_refresh_mutex().lock().await; + if MUSE_TOKEN_GENERATION.load(Ordering::SeqCst) == generation { + let _ = self.cache.clear(); + } + } + Err(error) + } + } + } +} + +#[async_trait] +impl AuthProvider for SharedAuthProvider { + async fn get_auth_header(&self) -> Result<(String, String)> { + let token = self.0.get_valid_token().await.map_err(anyhow::Error::new)?; + if token.api_key.is_empty() { + return Err(ProviderError::Authentication( + "Muse Code API key is missing. Sign in again.".to_string(), + ) + .into()); + } + Ok(( + "Authorization".to_string(), + format!("Bearer {}", token.api_key), + )) + } +} + +impl MuseCodeProvider { + pub async fn cleanup() -> Result<()> { + let _guard = global_muse_refresh_mutex().lock().await; + TokenCache::new().clear()?; + Ok(()) + } +} + +async fn from_env(tls_config: Option) -> Result { + let config = Config::global(); + let host: String = config + .get_param("MUSE_CODE_HOST") + .unwrap_or_else(|_| MUSE_CODE_API_HOST.to_string()); + let auth_host: String = config + .get_param("MUSE_CODE_AUTH_HOST") + .unwrap_or_else(|_| MUSE_CODE_AUTH_HOST.to_string()); + let client_id: String = config + .get_param("MUSE_CODE_CLIENT_ID") + .unwrap_or_else(|_| MUSE_CODE_CLIENT_ID.to_string()); + + let auth = Arc::new(MuseCodeAuth { + cache: TokenCache::new(), + client: ApiClient::http_client(tls_config.as_ref())?, + api_host: host.clone(), + auth_host, + client_id, + }); + + let api_client = ApiClient::with_timeout_and_tls( + host, + AuthMethod::Custom(Box::new(SharedAuthProvider(Arc::clone(&auth)))), + StdDuration::from_secs(crate::providers::base::DEFAULT_PROVIDER_TIMEOUT_SECS), + tls_config, + )? + .with_request_builder(crate::session_context::session_id_request_builder()) + .with_header("anthropic-version", ANTHROPIC_API_VERSION)?; + + Ok(MuseCodeProvider { + inner: AnthropicProviderBuilder::new(api_client) + .name(MUSE_CODE_PROVIDER_NAME) + .custom_models(Some(known_models())) + .format_options(AnthropicFormatOptions { + // Meta's Messages adapter is stateless. Replay thinking so + // multi-turn tool loops keep the chain of thought. + preserve_unsigned_thinking: true, + preserve_thinking_context: true, + ..AnthropicFormatOptions::default() + }) + .build(), + auth, + }) +} + +impl ProviderDescriptor for MuseCodeProviderDef { + fn metadata() -> ProviderMetadata { + ProviderMetadata::with_models( + MUSE_CODE_PROVIDER_NAME, + "Meta Muse Code", + "Muse Spark models from a Meta Muse Code subscription", + "muse-spark-1.3", + known_models(), + MUSE_CODE_DOC_URL, + vec![ + ConfigKey::new_oauth_device_code("MUSE_CODE_TOKEN", true, true, None, false), + ConfigKey::new( + "MUSE_CODE_HOST", + false, + false, + Some(MUSE_CODE_API_HOST), + false, + ), + ConfigKey::new( + "MUSE_CODE_AUTH_HOST", + false, + false, + Some(MUSE_CODE_AUTH_HOST), + false, + ), + ConfigKey::new( + "MUSE_CODE_CLIENT_ID", + false, + false, + Some(MUSE_CODE_CLIENT_ID), + false, + ), + ], + ) + .with_setup_steps(vec![ + "Run `goose configure` and select 'Meta Muse Code'", + "A browser window will open — sign in to Meta and confirm the displayed code", + "Once authorized, Goose will save your token automatically", + ]) + .with_setup( + crate::providers::catalog::ProviderSetupMetadata::new( + crate::providers::catalog::ProviderSetupCategory::Model, + crate::providers::catalog::ProviderSetupMethod::OauthDeviceCode, + crate::providers::catalog::ProviderSetupGroup::Default, + ) + .with_docs_url(MUSE_CODE_DOC_URL) + .with_native_connect_query("Meta Muse Code") + .with_capabilities(false, true, false), + ) + } +} + +impl ProviderDef for MuseCodeProviderDef { + type Provider = MuseCodeProvider; + + fn from_env( + _extensions: Vec, + tls_config: Option, + ) -> BoxFuture<'static, Result> { + Box::pin(from_env(tls_config)) + } +} + +#[async_trait] +impl Provider for MuseCodeProvider { + fn get_name(&self) -> &str { + self.inner.get_name() + } + + async fn stream( + &self, + model_config: &ModelConfig, + system: &str, + messages: &[Message], + tools: &[Tool], + ) -> Result { + self.auth.get_valid_token().await?; + self.inner + .stream(model_config, system, messages, tools) + .await + } + + async fn fetch_supported_models(&self) -> Result, ProviderError> { + self.auth.get_valid_token().await?; + self.inner.fetch_supported_models().await + } + + async fn configure_oauth(&self) -> Result<(), ProviderError> { + let generation = MUSE_TOKEN_GENERATION.load(Ordering::SeqCst); + let token = self + .auth + .device_flow_login() + .await + .map_err(|e| ProviderError::Authentication(format!("OAuth flow failed: {e}")))?; + self.auth.save_unless_cleaned(&token, generation).await + } +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + use wiremock::matchers::{method, path}; + use wiremock::{Mock, MockServer, ResponseTemplate}; + + fn fresh_token(access: &str) -> MuseToken { + MuseToken { + access_token: access.to_string(), + refresh_token: "refresh".to_string(), + api_key: access.to_string(), + expires_at: Utc::now() + Duration::hours(1), + } + } + + #[test] + fn metadata_declares_subscription_models_and_oauth() { + let metadata = MuseCodeProviderDef::metadata(); + assert_eq!(metadata.name, "muse_code"); + assert_eq!(metadata.default_model, "muse-spark-1.3"); + assert_eq!( + metadata + .known_models + .iter() + .map(|model| model.name.as_str()) + .collect::>(), + vec![ + "muse-spark-1.3", + "muse-spark-1.2", + "muse-spark-1.1", + "muse-spark-1.2-contributor", + "muse-spark-1.3-contributor" + ] + ); + assert_eq!( + metadata + .known_models + .iter() + .map(|model| model.context_limit) + .collect::>(), + vec![Some(1_048_576); 5] + ); + assert!( + metadata.known_models.iter().all(|model| model.reasoning), + "muse-spark models should resolve as reasoning models via the canonical registry" + ); + let key = metadata + .config_keys + .iter() + .find(|key| key.name == "MUSE_CODE_TOKEN") + .expect("MUSE_CODE_TOKEN config key should exist"); + assert!(key.oauth_flow); + assert!(key.device_code_flow); + assert!(key.secret); + } + + #[test] + fn spark_models_resolve_output_limits_via_canonical_registry() { + // Spark reasons before emitting content; without a max_tokens from the + // canonical registry the wire omits it and Meta falls back to 4096, + // which reasoning exhausts before returning any visible content. + for model in [ + "muse-spark-1.3", + "muse-spark-1.2", + "muse-spark-1.2-contributor", + "muse-spark-1.3-contributor", + ] { + let config = ModelConfig::new(model).with_canonical_limits(MUSE_CODE_PROVIDER_NAME); + assert_eq!( + config.max_tokens, + Some(131_072), + "{model} should resolve its canonical output limit" + ); + } + } + + #[test] + fn spark_requests_use_adaptive_thinking_and_replay_it() { + use goose_providers::conversation::message::MessageContent; + use goose_providers::formats::anthropic::create_request; + + let config = + ModelConfig::new("muse-spark-1.3").with_canonical_limits(MUSE_CODE_PROVIDER_NAME); + let messages = vec![ + Message::assistant().with_content(MessageContent::thinking("plan", "sig")), + Message::user().with_text("continue"), + ]; + let payload = create_request( + MUSE_CODE_PROVIDER_NAME, + &config, + "system", + &messages, + &[], + AnthropicFormatOptions { + preserve_unsigned_thinking: true, + preserve_thinking_context: true, + ..AnthropicFormatOptions::default() + }, + ) + .expect("request should build"); + + assert_eq!(payload["thinking"]["type"], "adaptive"); + assert!(payload + .get("thinking") + .unwrap() + .get("budget_tokens") + .is_none()); + assert_ne!(payload["thinking"]["type"], "disabled"); + let replayed = &payload["messages"][0]["content"][0]; + assert_eq!(replayed["type"], "thinking"); + assert_eq!(replayed["thinking"], "plan"); + } + + #[tokio::test] + async fn from_env_builds_provider_against_configured_host_with_bearer_auth() { + let server = MockServer::start().await; + Mock::given(method("GET")) + .and(path("/v1/models")) + .respond_with( + ResponseTemplate::new(200) + .set_body_json(json!({"data": [{"id": "muse-spark-1.2"}]})), + ) + .mount(&server) + .await; + + let _guard = env_lock::lock_env([ + ("GOOSE_PATH_ROOT", None::<&str>), + ("META_MODEL_API_KEY", None::<&str>), + ("MUSE_CODE_HOST", None::<&str>), + ("MUSE_CODE_AUTH_HOST", None::<&str>), + ("MUSE_CODE_CLIENT_ID", None::<&str>), + ("MUSE_AUTH_PATH", None::<&str>), + ("XDG_CONFIG_HOME", None::<&str>), + ]); + let temp_dir = tempfile::tempdir().expect("tempdir should be created"); + std::env::set_var("GOOSE_PATH_ROOT", temp_dir.path()); + std::env::set_var("MUSE_CODE_HOST", server.uri()); + TokenCache::new() + .save(&fresh_token("test-key")) + .expect("token should save"); + + let provider = MuseCodeProviderDef::from_env(Vec::new(), None) + .await + .expect("provider should build"); + + let models = provider + .fetch_supported_models() + .await + .expect("models should be fetched from the configured host"); + assert_eq!(models, vec!["muse-spark-1.2".to_string()]); + + let requests = server.received_requests().await.expect("requests recorded"); + assert_eq!(requests.len(), 1); + assert_eq!( + requests[0] + .headers + .get("authorization") + .and_then(|value| value.to_str().ok()), + Some("Bearer test-key") + ); + } + + #[tokio::test] + async fn fetch_supported_models_does_not_authenticate_when_unconfigured() { + let server = MockServer::start().await; + let _guard = env_lock::lock_env([ + ("GOOSE_PATH_ROOT", None::<&str>), + ("MUSE_CODE_HOST", None::<&str>), + ("MUSE_AUTH_PATH", None::<&str>), + ("XDG_CONFIG_HOME", None::<&str>), + ]); + let temp_dir = tempfile::tempdir().expect("tempdir should be created"); + std::env::set_var("GOOSE_PATH_ROOT", temp_dir.path()); + std::env::set_var("MUSE_CODE_HOST", server.uri()); + std::env::set_var( + "MUSE_AUTH_PATH", + temp_dir + .path() + .join("missing-auth.json") + .to_string_lossy() + .as_ref(), + ); + + let provider = MuseCodeProviderDef::from_env(Vec::new(), None) + .await + .expect("provider should build without a token"); + let err = provider.fetch_supported_models().await.unwrap_err(); + assert_eq!(err, ProviderError::NotConfigured); + assert!(server.received_requests().await.unwrap().is_empty()); + } + + #[tokio::test] + async fn configure_oauth_stores_device_flow_token() { + let server = MockServer::start().await; + Mock::given(method("POST")) + .and(path("/oidc/device/authorization/")) + .respond_with(ResponseTemplate::new(200).set_body_json(json!({ + "device_code": "dc-1", + "user_code": "GSWR-PTCX", + "verification_uri": format!("{}/oauth/device/", server.uri()), + "verification_uri_complete": format!("{}/oauth/device/?code=GSWR-PTCX", server.uri()), + "expires_in": 600, + "interval": 1 + }))) + .mount(&server) + .await; + Mock::given(method("POST")) + .and(path("/oidc/device/token/")) + .respond_with(ResponseTemplate::new(200).set_body_json(json!({ + "access_token": "muse-access", + "refresh_token": "muse-refresh", + "expires_in": 3600 + }))) + .mount(&server) + .await; + Mock::given(method("POST")) + .and(path("/muse-code/key")) + .respond_with(ResponseTemplate::new(200).set_body_json(json!({ + "api_key": "LLM-muse-key" + }))) + .mount(&server) + .await; + + let _guard = env_lock::lock_env([ + ("GOOSE_PATH_ROOT", None::<&str>), + ("MUSE_CODE_HOST", None::<&str>), + ("MUSE_CODE_AUTH_HOST", None::<&str>), + ("MUSE_CODE_CLIENT_ID", None::<&str>), + ("MUSE_AUTH_PATH", None::<&str>), + ("XDG_CONFIG_HOME", None::<&str>), + ]); + let temp_dir = tempfile::tempdir().expect("tempdir should be created"); + std::env::set_var("GOOSE_PATH_ROOT", temp_dir.path()); + std::env::set_var("MUSE_CODE_HOST", server.uri()); + std::env::set_var("MUSE_CODE_AUTH_HOST", server.uri()); + std::env::set_var( + "MUSE_AUTH_PATH", + temp_dir + .path() + .join("missing-auth.json") + .to_string_lossy() + .as_ref(), + ); + + let provider = MuseCodeProviderDef::from_env(Vec::new(), None) + .await + .expect("provider should build"); + provider + .configure_oauth() + .await + .expect("device flow should complete"); + + let stored = TokenCache::new().load().expect("token should be cached"); + assert_eq!(stored.access_token, "muse-access"); + assert!( + stored.refresh_token.is_empty(), + "Meta does not issue a renewable refresh token" + ); + assert_eq!(stored.api_key, "LLM-muse-key"); + assert!( + stored.expires_at - Utc::now() > Duration::hours(23), + "minted key should be valid for about a day" + ); + } + + #[tokio::test] + async fn configure_oauth_reauths_even_when_a_cached_token_exists() { + let server = MockServer::start().await; + Mock::given(method("POST")) + .and(path("/oidc/device/authorization/")) + .respond_with(ResponseTemplate::new(200).set_body_json(json!({ + "device_code": "dc-2", + "user_code": "ABCD-EFGH", + "verification_uri": format!("{}/oauth/device/", server.uri()), + "verification_uri_complete": format!("{}/oauth/device/?code=ABCD-EFGH", server.uri()), + "expires_in": 600, + "interval": 1 + }))) + .mount(&server) + .await; + Mock::given(method("POST")) + .and(path("/oidc/device/token/")) + .respond_with(ResponseTemplate::new(200).set_body_json(json!({ + "access_token": "new-access", + "refresh_token": "new-refresh", + "expires_in": 3600 + }))) + .mount(&server) + .await; + Mock::given(method("POST")) + .and(path("/muse-code/key")) + .respond_with(ResponseTemplate::new(200).set_body_json(json!({ + "api_key": "LLM-new-key" + }))) + .mount(&server) + .await; + + let _guard = env_lock::lock_env([ + ("GOOSE_PATH_ROOT", None::<&str>), + ("MUSE_CODE_HOST", None::<&str>), + ("MUSE_CODE_AUTH_HOST", None::<&str>), + ("MUSE_CODE_CLIENT_ID", None::<&str>), + ("MUSE_AUTH_PATH", None::<&str>), + ("XDG_CONFIG_HOME", None::<&str>), + ]); + let temp_dir = tempfile::tempdir().expect("tempdir should be created"); + std::env::set_var("GOOSE_PATH_ROOT", temp_dir.path()); + std::env::set_var("MUSE_CODE_HOST", server.uri()); + std::env::set_var("MUSE_CODE_AUTH_HOST", server.uri()); + std::env::set_var( + "MUSE_AUTH_PATH", + temp_dir + .path() + .join("missing-auth.json") + .to_string_lossy() + .as_ref(), + ); + TokenCache::new() + .save(&fresh_token("old-access")) + .expect("existing token should save"); + + let provider = MuseCodeProviderDef::from_env(Vec::new(), None) + .await + .expect("provider should build"); + provider + .configure_oauth() + .await + .expect("device flow should re-run"); + + let stored = TokenCache::new().load().expect("token should be cached"); + assert_eq!(stored.access_token, "new-access"); + assert!(stored.refresh_token.is_empty()); + assert_eq!(stored.api_key, "LLM-new-key"); + } + + #[tokio::test] + async fn configure_oauth_restores_previous_token_when_sign_in_fails() { + let server = MockServer::start().await; + Mock::given(method("POST")) + .and(path("/oidc/device/authorization/")) + .respond_with(ResponseTemplate::new(500)) + .mount(&server) + .await; + + let _guard = env_lock::lock_env([ + ("GOOSE_PATH_ROOT", None::<&str>), + ("MUSE_CODE_HOST", None::<&str>), + ("MUSE_CODE_AUTH_HOST", None::<&str>), + ("MUSE_CODE_CLIENT_ID", None::<&str>), + ("MUSE_AUTH_PATH", None::<&str>), + ("XDG_CONFIG_HOME", None::<&str>), + ]); + let temp_dir = tempfile::tempdir().expect("tempdir should be created"); + std::env::set_var("GOOSE_PATH_ROOT", temp_dir.path()); + std::env::set_var("MUSE_CODE_HOST", server.uri()); + std::env::set_var("MUSE_CODE_AUTH_HOST", server.uri()); + std::env::set_var( + "MUSE_AUTH_PATH", + temp_dir + .path() + .join("missing-auth.json") + .to_string_lossy() + .as_ref(), + ); + TokenCache::new() + .save(&fresh_token("old-access")) + .expect("existing token should save"); + + let provider = MuseCodeProviderDef::from_env(Vec::new(), None) + .await + .expect("provider should build"); + let err = provider.configure_oauth().await.unwrap_err(); + assert!(matches!(err, ProviderError::Authentication(_))); + + let stored = TokenCache::new() + .load() + .expect("previous token should remain"); + assert_eq!(stored.access_token, "old-access"); + } + + #[tokio::test] + async fn uses_muse_cli_auth_json_when_goose_cache_is_empty() { + let server = MockServer::start().await; + Mock::given(method("GET")) + .and(path("/v1/models")) + .respond_with( + ResponseTemplate::new(200) + .set_body_json(json!({"data": [{"id": "muse-spark-1.2"}]})), + ) + .mount(&server) + .await; + + let _guard = env_lock::lock_env([ + ("GOOSE_PATH_ROOT", None::<&str>), + ("MUSE_CODE_HOST", None::<&str>), + ("MUSE_AUTH_PATH", None::<&str>), + ("XDG_CONFIG_HOME", None::<&str>), + ]); + let temp_dir = tempfile::tempdir().expect("tempdir should be created"); + let cli_path = temp_dir.path().join("muse-auth.json"); + std::fs::write( + &cli_path, + serde_json::to_string(&json!({ + "providers": { + "meta": { + "mechanism": "oauth", + "access_token": "cli-access", + "api_key": "LLM-cli-key", + "expires_at": (Utc::now() + Duration::hours(1)).timestamp() + } + } + })) + .unwrap(), + ) + .unwrap(); + std::env::set_var("GOOSE_PATH_ROOT", temp_dir.path()); + std::env::set_var("MUSE_CODE_HOST", server.uri()); + std::env::set_var("MUSE_AUTH_PATH", cli_path); + + let provider = MuseCodeProviderDef::from_env(Vec::new(), None) + .await + .expect("provider should build"); + provider + .fetch_supported_models() + .await + .expect("cli token should authorize"); + + let requests = server.received_requests().await.expect("requests recorded"); + assert_eq!( + requests[0] + .headers + .get("authorization") + .and_then(|value| value.to_str().ok()), + Some("Bearer LLM-cli-key") + ); + } + + #[tokio::test] + async fn expired_api_key_is_reminted_from_the_identity_token() { + let server = MockServer::start().await; + Mock::given(method("POST")) + .and(path("/muse-code/key")) + .respond_with(ResponseTemplate::new(200).set_body_json(json!({ + "api_key": "LLM-renewed" + }))) + .mount(&server) + .await; + Mock::given(method("GET")) + .and(path("/v1/models")) + .respond_with( + ResponseTemplate::new(200) + .set_body_json(json!({"data": [{"id": "muse-spark-1.3"}]})), + ) + .mount(&server) + .await; + + let _guard = env_lock::lock_env([ + ("GOOSE_PATH_ROOT", None::<&str>), + ("MUSE_CODE_HOST", None::<&str>), + ("MUSE_CODE_AUTH_HOST", None::<&str>), + ("MUSE_AUTH_PATH", None::<&str>), + ("XDG_CONFIG_HOME", None::<&str>), + ]); + let temp_dir = tempfile::tempdir().expect("tempdir should be created"); + std::env::set_var("GOOSE_PATH_ROOT", temp_dir.path()); + std::env::set_var("MUSE_CODE_HOST", server.uri()); + std::env::set_var( + "MUSE_AUTH_PATH", + temp_dir + .path() + .join("missing-auth.json") + .to_string_lossy() + .as_ref(), + ); + TokenCache::new() + .save(&MuseToken { + access_token: "identity-token".to_string(), + refresh_token: String::new(), + api_key: "LLM-stale".to_string(), + expires_at: Utc::now() - Duration::minutes(1), + }) + .expect("stale token should save"); + + let provider = MuseCodeProviderDef::from_env(Vec::new(), None) + .await + .expect("provider should build"); + provider + .fetch_supported_models() + .await + .expect("expired key should be reminted"); + + let stored = TokenCache::new() + .load() + .expect("renewed token should be cached"); + assert_eq!(stored.api_key, "LLM-renewed"); + assert_eq!(stored.access_token, "identity-token"); + assert!(stored.refresh_token.is_empty()); + let requests = server.received_requests().await.expect("requests recorded"); + assert!( + requests + .iter() + .any(|request| request.url.path() == "/muse-code/key"), + "renewal must mint a key instead of calling the token endpoint" + ); + assert!( + requests + .iter() + .all(|request| !request.url.path().contains("/oidc/device/token")), + "identity tokens are not refreshable" + ); + } + + #[tokio::test] + async fn expired_session_without_identity_token_requires_sign_in() { + let server = MockServer::start().await; + let _guard = env_lock::lock_env([ + ("GOOSE_PATH_ROOT", None::<&str>), + ("MUSE_CODE_HOST", None::<&str>), + ("MUSE_AUTH_PATH", None::<&str>), + ("XDG_CONFIG_HOME", None::<&str>), + ]); + let temp_dir = tempfile::tempdir().expect("tempdir should be created"); + std::env::set_var("GOOSE_PATH_ROOT", temp_dir.path()); + std::env::set_var("MUSE_CODE_HOST", server.uri()); + std::env::set_var( + "MUSE_AUTH_PATH", + temp_dir + .path() + .join("missing-auth.json") + .to_string_lossy() + .as_ref(), + ); + TokenCache::new() + .save(&MuseToken { + access_token: String::new(), + refresh_token: "not-a-meta-refresh-token".to_string(), + api_key: "LLM-stale".to_string(), + expires_at: Utc::now() - Duration::minutes(1), + }) + .expect("stale token should save"); + + let provider = MuseCodeProviderDef::from_env(Vec::new(), None) + .await + .expect("provider should build"); + let err = provider.fetch_supported_models().await.unwrap_err(); + assert!(matches!(err, ProviderError::Authentication(_))); + assert!(TokenCache::new().load().is_none()); + assert!(server.received_requests().await.unwrap().is_empty()); + } + + #[tokio::test] + async fn configure_oauth_does_not_restore_credential_removed_during_sign_in() { + let server = MockServer::start().await; + Mock::given(method("POST")) + .and(path("/oidc/device/authorization/")) + .respond_with(ResponseTemplate::new(200).set_body_json(json!({ + "device_code": "device", + "user_code": "ABCD-EFGH", + "verification_uri": "https://auth.meta.com/activate", + "expires_in": 600, + "interval": 1 + }))) + .mount(&server) + .await; + Mock::given(method("POST")) + .and(path("/oidc/device/token/")) + .respond_with( + ResponseTemplate::new(200) + .set_delay(std::time::Duration::from_millis(300)) + .set_body_json(json!({ + "access_token": "muse-access", + "refresh_token": "muse-refresh", + "expires_in": 3600 + })), + ) + .mount(&server) + .await; + Mock::given(method("POST")) + .and(path("/muse-code/key")) + .respond_with(ResponseTemplate::new(200).set_body_json(json!({ + "api_key": "LLM-muse-key" + }))) + .mount(&server) + .await; + + let _guard = env_lock::lock_env([ + ("GOOSE_PATH_ROOT", None::<&str>), + ("MUSE_CODE_HOST", None::<&str>), + ("MUSE_CODE_AUTH_HOST", None::<&str>), + ("MUSE_CODE_CLIENT_ID", None::<&str>), + ("MUSE_AUTH_PATH", None::<&str>), + ("XDG_CONFIG_HOME", None::<&str>), + ]); + let temp_dir = tempfile::tempdir().expect("tempdir should be created"); + std::env::set_var("GOOSE_PATH_ROOT", temp_dir.path()); + std::env::set_var("MUSE_CODE_HOST", server.uri()); + std::env::set_var("MUSE_CODE_AUTH_HOST", server.uri()); + std::env::set_var( + "MUSE_AUTH_PATH", + temp_dir + .path() + .join("missing-auth.json") + .to_string_lossy() + .as_ref(), + ); + TokenCache::new() + .save(&fresh_token("old-access")) + .expect("existing token should save"); + + let provider = MuseCodeProviderDef::from_env(Vec::new(), None) + .await + .expect("provider should build"); + let sign_in = tokio::spawn(async move { provider.configure_oauth().await }); + tokio::time::sleep(std::time::Duration::from_millis(80)).await; + MuseCodeProvider::cleanup() + .await + .expect("disconnect should remove the credential"); + + let err = sign_in + .await + .expect("sign-in task should finish") + .expect_err("in-flight sign-in should not undo disconnect"); + assert!(matches!(err, ProviderError::Authentication(_))); + assert!( + TokenCache::new().load().is_none(), + "disconnect during sign-in must not be overwritten" + ); + } +} diff --git a/goose-self-test.yaml b/goose-self-test.yaml index b87d74444..54e2dd477 100644 --- a/goose-self-test.yaml +++ b/goose-self-test.yaml @@ -186,6 +186,11 @@ prompt: | 5. Run `python3 documentation/automation/gdk-api/generate.py --check` to verify the generated GDK API data is current and publishes `gateway_path` as an optional argument defaulting to `None`. If the source checkout or Rust toolchain is unavailable, mark this validation as skipped rather than failed. + ### Muse Code Provider Validation + When running from a goose source checkout: + 1. Run `cargo test -p goose --features scheduler --lib muse_code` to verify Muse Code metadata, device-code login, key mint, day-long key renewal from the identity token, and CLI-token reuse. + If the source checkout or Rust toolchain is unavailable, mark this validation as skipped rather than failed. + Log results to: {{ workspace_dir }}/phase1_basic_tools.md {% endif %}