From d26a422c240a09755c394b141ce022b5ced975c8 Mon Sep 17 00:00:00 2001 From: Douwe Osinga Date: Tue, 6 Oct 2026 20:25:48 +0000 Subject: [PATCH] Route every extension operation through a lease (#12723) Co-authored-by: Claude Opus 5.5 --- crates/goose-cli/src/cli.rs | 29 +- .../src/scenario_tests/scenario_runner.rs | 1 - crates/goose/src/acp/server.rs | 9 +- crates/goose/src/acp/server/apps.rs | 11 +- crates/goose/src/acp/server/resources.rs | 4 +- crates/goose/src/acp/server/tools.rs | 16 +- crates/goose/src/agents/agent.rs | 176 +--- .../src/agents/extension_manager/lease.rs | 155 +++- .../goose/src/agents/extension_manager/mod.rs | 862 +++--------------- crates/goose/src/agents/mcp_client.rs | 14 +- crates/goose/src/agents/moim.rs | 21 +- .../agents/platform_extensions/analyze/mod.rs | 1 - .../src/agents/platform_extensions/apps.rs | 1 - .../agents/platform_extensions/chatrecall.rs | 14 +- .../platform_extensions/code_execution.rs | 95 +- .../platform_extensions/developer/mod.rs | 1 - .../agents/platform_extensions/ext_manager.rs | 74 +- .../src/agents/platform_extensions/mod.rs | 6 +- .../platform_extensions/orchestrator.rs | 77 +- .../src/agents/platform_extensions/summon.rs | 192 +--- crates/goose/src/agents/prompt_manager.rs | 28 +- crates/goose/src/agents/reply_parts.rs | 2 +- .../state_machine/inference_preparation.rs | 17 +- .../agents/state_machine/ops_toolcalling.rs | 44 +- .../agents/state_machine/tests/agent_reply.rs | 2 - .../agents/state_machine/tests/pipeline.rs | 1 - crates/goose/src/goose_apps/app.rs | 23 +- crates/goose/src/skills/client.rs | 104 +-- crates/goose/tests/mcp_integration_test.rs | 16 +- crates/goose/tests/providers.rs | 18 +- 30 files changed, 520 insertions(+), 1494 deletions(-) diff --git a/crates/goose-cli/src/cli.rs b/crates/goose-cli/src/cli.rs index 70321b031..c73fa1a0f 100644 --- a/crates/goose-cli/src/cli.rs +++ b/crates/goose-cli/src/cli.rs @@ -1448,7 +1448,8 @@ enum McpProbeElicitation { } async fn handle_mcp_probe(extension_command: String, script_path: Option) -> Result<()> { - use goose::agents::{Agent, AgentConfig, ToolCallContext}; + use goose::agents::extension_manager::CallRequest; + use goose::agents::{Agent, AgentConfig}; use goose::config::ExtensionConfig; use rmcp::model::{ElicitRequestParams, ElicitResult, ElicitationAction}; use tokio_util::sync::CancellationToken; @@ -1562,46 +1563,42 @@ async fn handle_mcp_probe(extension_command: String, script_path: Option let session_id = session.id.as_str(); agent.add_extension(extension, session_id).await?; + let working_dir = std::env::current_dir()?; let mut results = Vec::new(); for step in script.steps { + let lease = agent + .extension_manager + .current_lease(session_id, Some(&working_dir)) + .await; let result = match step { McpProbeStep::ListTools => serde_json::json!({ "action": "listTools", - "result": agent.extension_manager.list_tools_from_extension( - session_id, + "result": lease.list_tools_from_extension( "probe", CancellationToken::new(), ).await?, }), McpProbeStep::ListPrompts => serde_json::json!({ "action": "listPrompts", - "result": agent.extension_manager.list_prompts_from_extension( - session_id, + "result": lease.list_prompts_from_extension( "probe", CancellationToken::new(), ).await?, }), McpProbeStep::ListResources => serde_json::json!({ "action": "listResources", - "result": agent.extension_manager.list_resources_result_from_extension( - session_id, + "result": lease.list_resources_result_from_extension( "probe", CancellationToken::new(), ).await?, }), McpProbeStep::CallTool { name, arguments } => { let scoped_name = format!("probe__{name}"); - let ctx = ToolCallContext::new( - session_id.to_string(), - Some(std::env::current_dir()?), - Some("mcp-probe-tool-call".to_string()), - ); - let result = agent - .extension_manager - .dispatch_tool_call( - &ctx, + let result = lease + .call( rmcp::model::CallToolRequestParams::new(scoped_name) .with_arguments(arguments), + CallRequest::new("mcp-probe-tool-call"), CancellationToken::new(), ) .await? diff --git a/crates/goose-cli/src/scenario_tests/scenario_runner.rs b/crates/goose-cli/src/scenario_tests/scenario_runner.rs index 7169c9c76..365266add 100644 --- a/crates/goose-cli/src/scenario_tests/scenario_runner.rs +++ b/crates/goose-cli/src/scenario_tests/scenario_runner.rs @@ -232,7 +232,6 @@ where bundled: None, available_tools: vec![], }, - Some(session.working_dir.clone()), Arc::new(mock_client), None, ) diff --git a/crates/goose/src/acp/server.rs b/crates/goose/src/acp/server.rs index 72975d7ba..f6ee78a78 100644 --- a/crates/goose/src/acp/server.rs +++ b/crates/goose/src/acp/server.rs @@ -1140,13 +1140,10 @@ impl GooseAcpAgent { .find(|extension| extension.name() == "developer") .unwrap_or_else(|| builtin_to_extension_config("developer")); - if let Err(error) = agent + agent .extension_manager - .add_session_client(developer_config, &session.id, client, info) - .await - { - warn!(%error, "Failed to install ACP developer client"); - } + .add_client(developer_config, client, info) + .await; } async fn prepare_acp_session_agent( diff --git a/crates/goose/src/acp/server/apps.rs b/crates/goose/src/acp/server/apps.rs index c0323f7f7..bbfe7dc8e 100644 --- a/crates/goose/src/acp/server/apps.rs +++ b/crates/goose/src/acp/server/apps.rs @@ -23,12 +23,11 @@ impl GooseAcpAgent { }; let agent = self.get_session_agent(&session_id).await?; - let mut apps = fetch_mcp_apps(&agent.extension_manager, &session_id) - .await - .map_err(|error| { - agent_client_protocol::Error::internal_error() - .data(format!("Failed to list apps: {}", error.message)) - })?; + let lease = agent + .extension_manager + .current_lease(&session_id, None) + .await; + let mut apps = fetch_mcp_apps(&lease).await; McpAppCache::restore_bundled_default_apps(&mut apps); diff --git a/crates/goose/src/acp/server/resources.rs b/crates/goose/src/acp/server/resources.rs index 8022b7c2c..b1276170d 100644 --- a/crates/goose/src/acp/server/resources.rs +++ b/crates/goose/src/acp/server/resources.rs @@ -10,7 +10,9 @@ impl GooseAcpAgent { let cancel_token = CancellationToken::new(); let result = agent .extension_manager - .read_resource(session_id, &req.uri, &req.extension_name, cancel_token) + .current_lease(session_id, None) + .await + .read_resource(&req.uri, &req.extension_name, cancel_token) .await .internal_err()?; let result_json = serde_json::to_value(&result).internal_err()?; diff --git a/crates/goose/src/acp/server/tools.rs b/crates/goose/src/acp/server/tools.rs index d475ad963..437fb4af6 100644 --- a/crates/goose/src/acp/server/tools.rs +++ b/crates/goose/src/acp/server/tools.rs @@ -109,18 +109,16 @@ impl GooseAcpAgent { .data(format!("Session not found: {}", session_id)) })?; - let ctx = crate::agents::ToolCallContext::new( - session_id.clone(), - Some(session.working_dir), - None, - ) - .with_container(agent.container().await); + let container = agent.container().await; let tool_result = agent .extension_manager - .dispatch_app_tool_call( - &ctx, + .current_lease(session_id, Some(&session.working_dir)) + .await + .call_for_app( tool_call, &req.extension_name, + crate::agents::extension_manager::CallRequest::default() + .with_container(container.clone()), CancellationToken::new(), ) .await @@ -128,7 +126,7 @@ impl GooseAcpAgent { let result = agent .extension_manager - .applying_mutation(tool_result, ctx.container().cloned(), session_id) + .applying_mutation(tool_result, container, session_id) .result .await .map_err(|e| agent_client_protocol::Error::internal_error().data(e.to_string()))?; diff --git a/crates/goose/src/agents/agent.rs b/crates/goose/src/agents/agent.rs index 98569f747..9cfe23786 100644 --- a/crates/goose/src/agents/agent.rs +++ b/crates/goose/src/agents/agent.rs @@ -1499,18 +1499,18 @@ impl Agent { ) -> Arc { Arc::new( self.extension_manager - .current_session_lease(session_id, working_dir) + .current_lease(session_id, Some(working_dir)) .await, ) } pub async fn list_tools(&self, session_id: &str, extension_name: Option) -> Vec { let include_final_output = extension_name.is_none(); - let mut prefixed_tools = self - .extension_manager - .get_prefixed_tools(session_id, extension_name) - .await - .unwrap_or_default(); + let lease = self.extension_manager.current_lease(session_id, None).await; + let mut prefixed_tools = match extension_name { + Some(name) => lease.tools_for(&name).await, + None => lease.tools().await, + }; if include_final_output { if let Some(final_output_tool) = self.final_output_tool.lock().await.as_ref() { @@ -4023,9 +4023,10 @@ impl Agent { pub async fn list_extension_prompts(&self, session_id: &str) -> HashMap> { self.extension_manager - .list_prompts(session_id, CancellationToken::default()) + .current_lease(session_id, None) + .await + .list_prompts(CancellationToken::default()) .await - .expect("Failed to list prompts") } pub async fn get_prompt( @@ -4034,29 +4035,17 @@ impl Agent { name: &str, arguments: Value, ) -> Result { - // First find which extension has this prompt - let prompts = self - .extension_manager - .list_prompts(session_id, CancellationToken::default()) - .await - .map_err(|e| anyhow!("Failed to list prompts: {}", e))?; + let lease = self.extension_manager.current_lease(session_id, None).await; + let prompts = lease.list_prompts(CancellationToken::default()).await; if let Some(extension) = prompts .iter() .find(|(_, prompt_list)| prompt_list.iter().any(|p| p.name == name)) .map(|(extension, _)| extension) { - return self - .extension_manager - .get_prompt( - session_id, - extension, - name, - arguments, - CancellationToken::default(), - ) - .await - .map_err(|e| anyhow!("Failed to get prompt: {}", e)); + return lease + .get_prompt(extension, name, arguments, CancellationToken::default()) + .await; } Err(anyhow!("Prompt '{}' not found", name)) @@ -4146,87 +4135,6 @@ mod tests { call_count: AtomicUsize, } - struct MovingDirectoryProvider { - manager: std::sync::Mutex>>, - session_id: std::sync::Mutex>, - new_working_dir: PathBuf, - tool_lists: std::sync::Mutex>>, - call_count: AtomicUsize, - } - - impl MovingDirectoryProvider { - fn new(new_working_dir: PathBuf) -> Self { - Self { - manager: std::sync::Mutex::new(None), - session_id: std::sync::Mutex::new(None), - new_working_dir, - tool_lists: std::sync::Mutex::new(Vec::new()), - call_count: AtomicUsize::new(0), - } - } - } - - #[async_trait::async_trait] - impl crate::providers::base::Provider for MovingDirectoryProvider { - async fn stream( - &self, - _model_config: &goose_providers::model::ModelConfig, - _system_prompt: &str, - _messages: &[Message], - tools: &[Tool], - ) -> Result { - self.tool_lists - .lock() - .unwrap() - .push(tools.iter().map(|tool| tool.name.to_string()).collect()); - let call = self.call_count.fetch_add(1, Ordering::SeqCst); - let message = if call == 0 { - let manager = self - .manager - .lock() - .unwrap() - .clone() - .expect("extension manager unavailable"); - let session_id = self - .session_id - .lock() - .unwrap() - .clone() - .expect("session unavailable"); - manager - .get_context() - .session_manager - .update(&session_id) - .working_dir(self.new_working_dir.clone()) - .apply() - .await - .unwrap(); - manager - .update_working_dir(&self.new_working_dir, None, &session_id) - .await - .unwrap(); - Message::assistant().with_tool_request( - "move-directory", - Ok(CallToolRequestParams::new("changing__value")), - ) - } else { - Message::assistant().with_text("done") - }; - Ok(stream_from_single_message( - message, - ProviderUsage::new("mock-model".to_string(), Usage::default()), - )) - } - - fn get_name(&self) -> &str { - "moving-directory" - } - - async fn get_context_limit(&self, _model: &str, _override_limit: Option) -> usize { - 100_000 - } - } - impl RefreshingLeaseProvider { fn new() -> Self { Self { @@ -4264,7 +4172,6 @@ mod tests { manager .add_client( platform_extension("changing"), - Some(PathBuf::default()), Arc::new(LeaseValueClient("second")), None, ) @@ -4298,7 +4205,6 @@ mod tests { .extension_manager .add_client( persisted_builtin("changing"), - Some(session.working_dir.clone()), Arc::new(LeaseValueClient("first")), None, ) @@ -4309,7 +4215,6 @@ mod tests { .extension_manager .add_client( persisted_builtin("changing"), - Some(session.working_dir.clone()), Arc::new(LeaseValueClient("second")), None, ) @@ -4374,58 +4279,6 @@ mod tests { Ok(()) } - #[tokio::test] - async fn legacy_inference_refreshes_the_session_directory() -> Result<()> { - let temp_dir = tempfile::tempdir()?; - let new_working_dir = temp_dir.path().join("moved"); - std::fs::create_dir(&new_working_dir)?; - let provider = Arc::new(MovingDirectoryProvider::new(new_working_dir)); - let (agent, session_id) = create_test_agent( - temp_dir.path().join("data"), - crate::hooks::HookManager::from_plugins_for_test(vec![]), - provider.clone(), - ) - .await?; - let session = agent - .config - .session_manager - .get_session(&session_id, false) - .await?; - agent - .extension_manager - .add_client( - persisted_builtin("changing"), - Some(session.working_dir), - Arc::new(LeaseValueClient("value")), - None, - ) - .await; - *provider.manager.lock().unwrap() = Some(Arc::clone(&agent.extension_manager)); - *provider.session_id.lock().unwrap() = Some(session_id.clone()); - - let mut stream = agent - .reply( - Message::user().with_text("move the directory"), - SessionConfig { - id: session_id, - schedule_id: None, - max_turns: Some(100), - retry_config: None, - }, - false, - None, - ) - .await?; - while let Some(event) = stream.next().await { - event?; - } - - let tool_lists = provider.tool_lists.lock().unwrap(); - assert_eq!(tool_lists.len(), 2); - assert!(tool_lists[1].iter().any(|tool| tool == "changing__value")); - Ok(()) - } - #[tokio::test] async fn inference_context_uses_the_lease_session_snapshot() -> Result<()> { let temp_dir = tempfile::tempdir()?; @@ -4450,7 +4303,6 @@ mod tests { .extension_manager .add_client( persisted_builtin("changing"), - Some(stale_session.working_dir.clone()), Arc::new(LeaseValueClient("value")), None, ) diff --git a/crates/goose/src/agents/extension_manager/lease.rs b/crates/goose/src/agents/extension_manager/lease.rs index 100bbd74b..ecb7d46aa 100644 --- a/crates/goose/src/agents/extension_manager/lease.rs +++ b/crates/goose/src/agents/extension_manager/lease.rs @@ -16,8 +16,9 @@ use std::sync::Arc; use futures::stream; use futures::{FutureExt, Stream}; use rmcp::model::{ - CallToolRequestParams, CallToolResult, ContentBlock, ErrorCode, ErrorData, ListResourcesResult, - ReadResourceResult, ResourceContents, ServerNotification, Tool, + CallToolRequestParams, CallToolResult, ContentBlock, ErrorCode, ErrorData, GetPromptResult, + ListResourcesResult, ListToolsResult, Prompt, ReadResourceResult, Resource, ResourceContents, + ServerNotification, Tool, }; use rmcp::service::ServiceError; use serde_json::Value; @@ -341,26 +342,123 @@ impl ExtensionLease { }) } - pub async fn list_resources_result_from_extension( - &self, - extension_name: &str, - cancellation_token: CancellationToken, - ) -> Result { + fn client(&self, extension_name: &str) -> Result<&Arc, ErrorData> { let key = name_to_key(extension_name); - let client = self - .extensions + self.extensions .iter() .find(|extension| extension.key == key) - .map(|extension| Arc::clone(&extension.client)) + .map(|extension| &extension.client) .ok_or_else(|| { ErrorData::new( ErrorCode::INVALID_PARAMS, format!("Extension {extension_name} is not valid"), None, ) - })?; + }) + } - client + pub async fn list_tools_from_extension( + &self, + extension_name: &str, + cancellation_token: CancellationToken, + ) -> Result { + self.client(extension_name)? + .list_tools(&self.scope_id, None, cancellation_token) + .await + .map_err(|error| { + ErrorData::new( + ErrorCode::INTERNAL_ERROR, + format!("Unable to list tools for {extension_name}, {error:?}"), + None, + ) + }) + } + + pub async fn list_prompts_from_extension( + &self, + extension_name: &str, + cancellation_token: CancellationToken, + ) -> Result, ErrorData> { + self.client(extension_name)? + .list_prompts(&self.scope_id, None, cancellation_token) + .await + .map(|result| result.prompts) + .map_err(|error| { + ErrorData::new( + ErrorCode::INTERNAL_ERROR, + format!("Unable to list prompts for {extension_name}, {error:?}"), + None, + ) + }) + } + + pub async fn list_prompts( + &self, + cancellation_token: CancellationToken, + ) -> HashMap> { + let results = futures::future::join_all(self.extensions.iter().map(|extension| { + let token = cancellation_token.clone(); + async move { + ( + extension.key.clone(), + self.list_prompts_from_extension(&extension.key, token) + .await, + ) + } + })) + .await; + let mut prompts = HashMap::new(); + for (key, result) in results { + match result { + Ok(listed) => { + prompts.insert(key, listed); + } + Err(error) => tracing::debug!(?error, "failed to list prompts"), + } + } + prompts + } + + pub async fn get_prompt( + &self, + extension_name: &str, + name: &str, + arguments: Value, + cancellation_token: CancellationToken, + ) -> anyhow::Result { + self.client(extension_name)? + .get_prompt(&self.scope_id, name, arguments, cancellation_token) + .await + .map_err(|e| anyhow::anyhow!("Failed to get prompt: {}", e)) + } + + pub async fn ui_resources(&self) -> Vec<(String, Resource)> { + let mut ui_resources = Vec::new(); + for extension in &self.extensions { + match extension + .client + .list_resources(&self.scope_id, None, CancellationToken::default()) + .await + { + Ok(listed) => ui_resources.extend( + listed + .resources + .into_iter() + .filter(|resource| resource.uri.starts_with("ui://")) + .map(|resource| (extension.key.clone(), resource)), + ), + Err(error) => warn!(extension = %extension.key, ?error, "failed to list resources"), + } + } + ui_resources + } + + pub async fn list_resources_result_from_extension( + &self, + extension_name: &str, + cancellation_token: CancellationToken, + ) -> Result { + self.client(extension_name)? .list_resources(&self.scope_id, None, cancellation_token) .await .map_err(|error| { @@ -425,23 +523,26 @@ impl ExtensionLease { Ok(resources) } - pub fn instructions(&self) -> Vec { + pub async fn instructions(&self) -> Vec { let working_dir = self .working_dir - .as_deref() - .unwrap_or(std::path::Path::new(".")) - .to_string_lossy(); - self.extensions - .iter() - .map(|extension| { - let instructions = extension.client.get_instructions().unwrap_or_default(); - ExtensionInfo::new( - &extension.key, - &instructions.replace("{{WORKING_DIR}}", &working_dir), - extension.supports_resources(), - ) - }) - .collect() + .clone() + .unwrap_or_else(|| std::env::current_dir().unwrap_or_default()); + let placeholder = working_dir.to_string_lossy(); + let mut infos = Vec::new(); + for extension in &self.extensions { + let instructions = extension + .client + .get_instructions(&self.scope_id, &working_dir) + .await + .unwrap_or_default(); + infos.push(ExtensionInfo::new( + &extension.key, + &instructions.replace("{{WORKING_DIR}}", &placeholder), + extension.supports_resources(), + )); + } + infos } pub async fn moim(&self) -> Vec { diff --git a/crates/goose/src/agents/extension_manager/mod.rs b/crates/goose/src/agents/extension_manager/mod.rs index 52898f295..c9d032cd3 100644 --- a/crates/goose/src/agents/extension_manager/mod.rs +++ b/crates/goose/src/agents/extension_manager/mod.rs @@ -1,10 +1,7 @@ -use anyhow::Result; use chrono::{DateTime, Utc}; -use futures::stream::{FuturesUnordered, StreamExt}; use futures::FutureExt; use futures::Stream; use indexmap::IndexMap; -use std::collections::HashMap; use std::path::{Path, PathBuf}; use std::pin::Pin; use std::sync::atomic::{AtomicU64, Ordering}; @@ -18,10 +15,9 @@ use tracing::warn; use super::container::Container; use super::extension::{ - ExtensionConfig, ExtensionError, ExtensionInfo, ExtensionResult, PlatformExtensionContext, - PLATFORM_EXTENSIONS, + ExtensionConfig, ExtensionError, ExtensionResult, PlatformExtensionContext, PLATFORM_EXTENSIONS, }; -use super::tool_execution::{ToolCallContext, ToolCallResult}; +use super::tool_execution::ToolCallResult; use super::types::SharedProvider; use crate::action_required_manager::ActionRequiredManager; use crate::agents::mcp_client::{ @@ -31,10 +27,7 @@ use crate::config::extensions::name_to_key; use crate::config::{get_extension_by_name, Config}; use crate::oauth::GooseCredentialStore; use crate::session::{EnabledExtensionsState, ExtensionState, Session}; -use rmcp::model::{ - CallToolRequestParams, CallToolResult, ContentBlock, ErrorCode, ErrorData, GetPromptResult, - ListResourcesResult, ListToolsResult, MetaObject, Prompt, Resource, ServerConfig, Tool, -}; +use rmcp::model::{CallToolResult, ErrorCode, ErrorData, MetaObject, ServerConfig, Tool}; use serde_json::Value; mod builtin; @@ -135,7 +128,9 @@ fn resolve_timeout(timeout: Option) -> u64 { pub(super) struct Extension { pub(super) key: String, pub(super) config: ExtensionConfig, - working_dir: PathBuf, + /// `None` for extensions that take their directory from each call rather + /// than from the process they run in. + working_dir: Option, /// Resolved config snapshot (with secrets from keyring substituted) /// captured at client-creation time. Used to detect secret rotation /// without re-reading the keyring on every comparison. Only held in @@ -143,7 +138,6 @@ pub(super) struct Extension { resolved_config: ExtensionConfig, pub(super) client: McpClientBox, server_info: Option, - reconnect_on_working_dir_change: bool, /// Bumped by the client on tools/list_changed; a cached list is only valid /// for the version it was fetched under. tools_version: Arc, @@ -167,6 +161,13 @@ impl Extension { .is_some() } + fn serves(&self, working_dir: Option<&Path>) -> bool { + match (&self.working_dir, working_dir) { + (Some(own), Some(requested)) => own == requested, + _ => true, + } + } + fn invalidate_tools(&self) { self.tools_version.fetch_add(1, Ordering::SeqCst); } @@ -516,7 +517,6 @@ impl ExtensionManager { provider: provider.clone(), session_manager, scheduler, - session: None, use_login_shell_path, }, provider, @@ -567,12 +567,7 @@ impl ExtensionManager { .iter() .filter_map(|config| { let running = extensions.get(&config.key())?; - if running.config != *config - || set - .working_dir - .as_ref() - .is_some_and(|working_dir| running.working_dir != *working_dir) - { + if running.config != *config || !running.serves(set.working_dir.as_deref()) { warn!( extension = %config.key(), "selected extension differs from the running one; leaving it out" @@ -595,26 +590,19 @@ impl ExtensionManager { pub async fn current_lease( &self, session_id: &str, - working_dir: Option<&Path>, + fallback_working_dir: Option<&Path>, ) -> ExtensionLease { let _guard = self.directory_lock.read().await; - self.lease_for_working_dir(session_id, working_dir).await - } - - pub async fn current_session_lease( - &self, - session_id: &str, - fallback_working_dir: &Path, - ) -> ExtensionLease { - let _guard = self.directory_lock.read().await; - let working_dir = self + let working_dir = match self .context .session_manager .get_session(session_id, false) .await - .map(|session| session.working_dir) - .unwrap_or_else(|_| fallback_working_dir.to_path_buf()); - self.lease_for_working_dir(session_id, Some(&working_dir)) + { + Ok(session) => Some(session.working_dir), + Err(_) => fallback_working_dir.map(Path::to_path_buf), + }; + self.lease_for_working_dir(session_id, working_dir.as_deref()) .await } @@ -642,9 +630,7 @@ impl ExtensionManager { .lock() .await .values() - .filter(|extension| { - working_dir.is_none_or(|working_dir| extension.working_dir == working_dir) - }) + .filter(|extension| extension.serves(working_dir)) .cloned() .collect::>(); extensions.sort_by(|left, right| left.key.cmp(&right.key)); @@ -693,20 +679,19 @@ impl ExtensionManager { let sanitized_name = config.key(); let resolved_config = config.clone().resolve(Config::global()).await?; - let working_dir = working_dir - .or_else(|| std::env::var("GOOSE_WORKING_DIR").ok().map(PathBuf::from)) - .unwrap_or_else(|| std::env::current_dir().unwrap_or_default()); + let is_platform = matches!( + &resolved_config, + ExtensionConfig::Platform { name, .. } | ExtensionConfig::Builtin { name, .. } + if PLATFORM_EXTENSIONS.contains_key(name_to_key(name).as_str()) + ); + let working_dir = (!is_platform).then(|| { + working_dir + .or_else(|| std::env::var("GOOSE_WORKING_DIR").ok().map(PathBuf::from)) + .unwrap_or_else(|| std::env::current_dir().unwrap_or_default()) + }); let client_working_dir = match &resolved_config { ExtensionConfig::Stdio { cwd: Some(cwd), .. } => PathBuf::from(cwd), - _ => working_dir.clone(), - }; - let reconnect_on_working_dir_change = match &resolved_config { - ExtensionConfig::Platform { name, .. } | ExtensionConfig::Builtin { name, .. } - if PLATFORM_EXTENSIONS.contains_key(name_to_key(name).as_str()) => - { - name_to_key(name) == crate::skills::EXTENSION_NAME - } - _ => true, + _ => working_dir.clone().unwrap_or_default(), }; if let Some(existing) = self.extensions.lock().await.get(&sanitized_name) { @@ -769,11 +754,6 @@ impl ExtensionManager { let def = &PLATFORM_EXTENSIONS[name_to_key(name).as_str()]; let mut context = self.context.clone(); context.extension_manager = Some(Arc::downgrade(self)); - if let Some(id) = session_id { - if let Ok(session) = self.context.session_manager.get_session(id, false).await { - context.session = Some(Arc::new(session)); - } - } // A platform extension the host cannot provide (no scheduler // service, say) declines rather than registering with no tools. let Some(client) = (def.client_factory)(context) else { @@ -830,7 +810,6 @@ impl ExtensionManager { resolved_config, client: Arc::from(client), server_info, - reconnect_on_working_dir_change, tools_version, tools: Mutex::new(None), }), @@ -914,39 +893,6 @@ impl ExtensionManager { pub async fn add_client( &self, config: ExtensionConfig, - working_dir: Option, - client: McpClientBox, - info: Option, - ) { - let _guard = self.directory_lock.read().await; - let working_dir = - working_dir.unwrap_or_else(|| std::env::current_dir().unwrap_or_default()); - self.insert_client(config, working_dir, client, info).await; - } - - pub async fn add_session_client( - &self, - config: ExtensionConfig, - session_id: &str, - client: McpClientBox, - info: Option, - ) -> ExtensionResult<()> { - let _guard = self.directory_lock.read().await; - let working_dir = self - .context - .session_manager - .get_session(session_id, false) - .await - .map_err(|error| ExtensionError::SetupError(error.to_string()))? - .working_dir; - self.insert_client(config, working_dir, client, info).await; - Ok(()) - } - - async fn insert_client( - &self, - config: ExtensionConfig, - working_dir: PathBuf, client: McpClientBox, info: Option, ) { @@ -957,11 +903,10 @@ impl ExtensionManager { Arc::new(Extension { key, config: config.clone(), - working_dir, + working_dir: None, resolved_config: config, client, server_info: info, - reconnect_on_working_dir_change: false, tools_version: Arc::new(AtomicU64::new(0)), tools: Mutex::new(None), }), @@ -969,13 +914,6 @@ impl ExtensionManager { Self::invalidate_extension_manager_tools(&extensions); } - /// Get extensions info for building the system prompt - pub async fn get_extensions_info(&self, working_dir: &Path) -> Vec { - self.current_lease("", Some(working_dir)) - .await - .instructions() - } - pub async fn remove_extension(&self, name: &str) -> ExtensionResult<()> { let sanitized_name = name_to_key(name); self.remove_extension_by_key(&sanitized_name).await?; @@ -999,65 +937,34 @@ impl ExtensionManager { ) -> ExtensionResult<()> { let _guard = self.mutation_lock.lock().await; let _directory_guard = self.directory_lock.write().await; - let session = match self + let session = self .context .session_manager .get_session(session_id, false) - .await - { - Ok(mut session) => { - if session.working_dir != new_dir { - self.context - .session_manager - .update(session_id) - .working_dir(new_dir.to_path_buf()) - .apply() - .await - .map_err(|error| ExtensionError::SetupError(error.to_string()))?; - } - session.working_dir = new_dir.to_path_buf(); - Some(Arc::new(session)) - } - Err(_) => None, - }; + .await; + if session.is_ok_and(|session| session.working_dir != new_dir) { + self.context + .session_manager + .update(session_id) + .working_dir(new_dir.to_path_buf()) + .apply() + .await + .map_err(|error| ExtensionError::SetupError(error.to_string()))?; + } let extensions = self .extensions .lock() .await .values() + .filter(|extension| { + extension + .working_dir + .as_ref() + .is_some_and(|working_dir| working_dir != new_dir) + }) .cloned() .collect::>(); for extension in extensions { - if extension.working_dir == new_dir { - continue; - } - if !extension.reconnect_on_working_dir_change { - let client = session - .as_ref() - .and_then(|session| extension.client.rebind_session(Arc::clone(session))) - .unwrap_or_else(|| Arc::clone(&extension.client)); - let replacement = Arc::new(Extension { - key: extension.key.clone(), - config: extension.config.clone(), - working_dir: new_dir.to_path_buf(), - resolved_config: extension.resolved_config.clone(), - client, - server_info: extension.server_info.clone(), - reconnect_on_working_dir_change: false, - tools_version: Arc::clone(&extension.tools_version), - tools: Mutex::new(None), - }); - let mut running = self.extensions.lock().await; - if running - .get(&extension.key) - .is_some_and(|current| Arc::ptr_eq(current, &extension)) - { - running.insert(extension.key.clone(), replacement); - Self::invalidate_extension_manager_tools(&running); - } - continue; - } - self.add_extension_if_current( extension.config.clone(), Some(new_dir.to_path_buf()), @@ -1087,287 +994,6 @@ impl ExtensionManager { .map(|ext| ext.config.clone()) .collect() } - - /// Get all tools from all clients with proper prefixing - pub async fn get_prefixed_tools( - &self, - session_id: &str, - extension_name: Option, - ) -> ExtensionResult> { - let lease = self.current_lease(session_id, None).await; - Ok(match extension_name { - Some(name) => lease.tools_for(&name).await, - None => lease.tools().await, - }) - } - - pub async fn list_tools_from_extension( - &self, - session_id: &str, - extension_name: &str, - cancellation_token: CancellationToken, - ) -> Result { - let client = self - .get_server_client(extension_name) - .await - .ok_or_else(|| { - ErrorData::new( - ErrorCode::INVALID_PARAMS, - format!("Extension {} is not valid", extension_name), - None, - ) - })?; - - client - .list_tools(session_id, None, cancellation_token) - .await - .map_err(|e| { - ErrorData::new( - ErrorCode::INTERNAL_ERROR, - format!("Unable to list tools for {}, {:?}", extension_name, e), - None, - ) - }) - } - - pub async fn get_prefixed_tools_excluding( - &self, - session_id: &str, - exclude: &str, - ) -> ExtensionResult> { - let lease = self.current_lease(session_id, None).await; - Ok(lease.tools_excluding(exclude).await) - } - - pub async fn read_resource_tool( - &self, - session_id: &str, - params: Value, - cancellation_token: CancellationToken, - ) -> Result, ErrorData> { - self.current_lease(session_id, None) - .await - .read_resource_tool(params, cancellation_token) - .await - } - - pub async fn read_resource( - &self, - session_id: &str, - uri: &str, - extension_name: &str, - cancellation_token: CancellationToken, - ) -> Result { - self.current_lease(session_id, None) - .await - .read_resource(uri, extension_name, cancellation_token) - .await - } - - pub async fn get_ui_resources( - &self, - session_id: &str, - ) -> Result, ErrorData> { - let mut ui_resources = Vec::new(); - - let extensions_to_check: Vec<(String, McpClientBox)> = { - let extensions = self.extensions.lock().await; - extensions - .iter() - .map(|(name, ext)| (name.clone(), ext.client.clone())) - .collect() - }; - - for (extension_name, client) in extensions_to_check { - match client - .list_resources(session_id, None, CancellationToken::default()) - .await - { - Ok(list_response) => { - for resource in list_response.resources { - if resource.uri.starts_with("ui://") { - ui_resources.push((extension_name.clone(), resource)); - } - } - } - Err(e) => { - warn!("Failed to list resources for {}: {:?}", extension_name, e); - } - } - } - - Ok(ui_resources) - } - - pub async fn list_resources_result_from_extension( - &self, - session_id: &str, - extension_name: &str, - cancellation_token: CancellationToken, - ) -> Result { - self.current_lease(session_id, None) - .await - .list_resources_result_from_extension(extension_name, cancellation_token) - .await - } - - pub async fn list_resources( - &self, - session_id: &str, - params: Value, - cancellation_token: CancellationToken, - ) -> Result, ErrorData> { - self.current_lease(session_id, None) - .await - .list_resources(params, cancellation_token) - .await - } - - pub async fn dispatch_tool_call( - &self, - ctx: &ToolCallContext, - tool_call: CallToolRequestParams, - cancellation_token: CancellationToken, - ) -> Result { - self.lease_for_tool_call(ctx) - .await - .call(tool_call, CallRequest::from(ctx), cancellation_token) - .await - } - - pub async fn dispatch_app_tool_call( - &self, - ctx: &ToolCallContext, - tool_call: CallToolRequestParams, - extension_name: &str, - cancellation_token: CancellationToken, - ) -> Result { - self.lease_for_tool_call(ctx) - .await - .call_for_app( - tool_call, - extension_name, - CallRequest::from(ctx), - cancellation_token, - ) - .await - } - - async fn lease_for_tool_call(&self, ctx: &ToolCallContext) -> ExtensionLease { - match ctx.working_dir.as_deref() { - Some(working_dir) => { - self.current_session_lease(&ctx.session_id, working_dir) - .await - } - None => self.current_lease(&ctx.session_id, None).await, - } - } - - pub async fn list_prompts_from_extension( - &self, - session_id: &str, - extension_name: &str, - cancellation_token: CancellationToken, - ) -> Result, ErrorData> { - let client = self - .get_server_client(extension_name) - .await - .ok_or_else(|| { - ErrorData::new( - ErrorCode::INVALID_PARAMS, - format!("Extension {} is not valid", extension_name), - None, - ) - })?; - - client - .list_prompts(session_id, None, cancellation_token) - .await - .map_err(|e| { - ErrorData::new( - ErrorCode::INTERNAL_ERROR, - format!("Unable to list prompts for {}, {:?}", extension_name, e), - None, - ) - }) - .map(|lp| lp.prompts) - } - - pub async fn list_prompts( - &self, - session_id: &str, - cancellation_token: CancellationToken, - ) -> Result>, ErrorData> { - let mut futures = FuturesUnordered::new(); - - let names: Vec<_> = self.extensions.lock().await.keys().cloned().collect(); - for extension_name in names { - let token = cancellation_token.clone(); - futures.push(async move { - ( - extension_name.clone(), - self.list_prompts_from_extension(session_id, extension_name.as_str(), token) - .await, - ) - }); - } - - let mut all_prompts = HashMap::new(); - let mut errors = Vec::new(); - - // Process results as they complete - while let Some(result) = futures.next().await { - let (name, prompts) = result; - match prompts { - Ok(content) => { - all_prompts.insert(name.to_string(), content); - } - Err(tool_error) => { - errors.push(tool_error); - } - } - } - - if !errors.is_empty() { - tracing::debug!( - errors = ?errors - .into_iter() - .map(|e| format!("{:?}", e)) - .collect::>(), - "errors from listing prompts" - ); - } - - Ok(all_prompts) - } - - pub async fn get_prompt( - &self, - session_id: &str, - extension_name: &str, - name: &str, - arguments: Value, - cancellation_token: CancellationToken, - ) -> Result { - let client = self - .get_server_client(extension_name) - .await - .ok_or_else(|| anyhow::anyhow!("Extension {} not found", extension_name))?; - - client - .get_prompt(session_id, name, arguments, cancellation_token) - .await - .map_err(|e| anyhow::anyhow!("Failed to get prompt: {}", e)) - } - - async fn get_server_client(&self, name: impl Into) -> Option { - let normalized = name_to_key(&name.into()); - self.extensions - .lock() - .await - .get(&normalized) - .map(|ext| ext.client.clone()) - } } #[cfg(test)] @@ -1383,7 +1009,9 @@ mod tests { use rmcp::model::ReadResourceResult; use rmcp::model::ServerNotification; - use super::super::tool_execution::ToolCallNotificationEmitter; + use super::super::tool_execution::{ToolCallContext, ToolCallNotificationEmitter}; + use futures::StreamExt; + use rmcp::model::{CallToolRequestParams, GetPromptResult, Resource}; use std::sync::atomic::AtomicUsize; use tokio::sync::{mpsc, Semaphore}; @@ -1407,7 +1035,7 @@ mod tests { bundled: None, available_tools, }; - self.add_client(config, None, client, None).await; + self.add_client(config, client, None).await; } } @@ -1640,7 +1268,13 @@ mod tests { let tool_call = CallToolRequestParams::new("notifications__tool".to_string()) .with_arguments(object!({})); let dispatched = extension_manager - .dispatch_tool_call(&ctx, tool_call, CancellationToken::default()) + .current_lease(&ctx.session_id, ctx.working_dir.as_deref()) + .await + .call( + tool_call, + CallRequest::from(&ctx), + CancellationToken::default(), + ) .await .expect("tool call should dispatch"); @@ -1697,7 +1331,13 @@ mod tests { .with_arguments(object!({})); let dispatched = extension_manager - .dispatch_tool_call(&ctx, tool_call, CancellationToken::default()) + .current_lease(&ctx.session_id, ctx.working_dir.as_deref()) + .await + .call( + tool_call, + CallRequest::from(&ctx), + CancellationToken::default(), + ) .await .expect("tool call should dispatch"); assert!(dispatched.result.await.is_ok()); @@ -1843,10 +1483,12 @@ mod tests { let ctx = ToolCallContext::new("session".to_string(), None, None); let result = extension_manager - .dispatch_app_tool_call( - &ctx, + .current_lease(&ctx.session_id, ctx.working_dir.as_deref()) + .await + .call_for_app( CallToolRequestParams::new("ext_a__ext_b__secret".to_string()), other, + CallRequest::from(&ctx), CancellationToken::default(), ) .await; @@ -1940,86 +1582,7 @@ mod tests { } #[tokio::test] - async fn working_dir_updates_preserve_supplied_clients() { - let data_dir = tempfile::tempdir().unwrap(); - let new_working_dir = tempfile::tempdir().unwrap(); - let extension_manager = Arc::new(ExtensionManager::new_without_provider( - data_dir.path().to_path_buf(), - )); - let config = builtin_config("external", vec![]); - extension_manager - .add_client( - config.clone(), - None, - Arc::new(NamedToolsClient(vec![Tool::new( - "ping", - "supplied tool", - Arc::new(JsonObject::new()), - )])), - None, - ) - .await; - - let original_set = ExtensionSet::new( - "session", - Some(std::env::current_dir().unwrap()), - vec![config.clone()], - ) - .unwrap(); - let original_lease = extension_manager.resolve(&original_set).await; - - extension_manager - .update_working_dir(new_working_dir.path(), None, "session") - .await - .unwrap(); - - let updated_set = ExtensionSet::new( - "session", - Some(new_working_dir.path().to_path_buf()), - vec![config], - ) - .unwrap(); - let updated_lease = extension_manager.resolve(&updated_set).await; - - assert!(original_lease.is_enabled("external")); - assert!(updated_lease.is_enabled("external")); - assert!(original_lease - .tools() - .await - .iter() - .any(|tool| tool.name == "external__ping")); - assert!(updated_lease - .tools() - .await - .iter() - .any(|tool| tool.name == "external__ping")); - } - - #[tokio::test] - async fn current_lease_excludes_extensions_from_another_working_dir() { - let data_dir = tempfile::tempdir().unwrap(); - let old_working_dir = tempfile::tempdir().unwrap(); - let new_working_dir = tempfile::tempdir().unwrap(); - let extension_manager = - ExtensionManager::new_without_provider(data_dir.path().to_path_buf()); - extension_manager - .add_client( - builtin_config("external", vec![]), - Some(old_working_dir.path().to_path_buf()), - Arc::new(MockClient {}), - None, - ) - .await; - - let lease = extension_manager - .current_lease("session", Some(new_working_dir.path())) - .await; - - assert!(!lease.is_enabled("external")); - } - - #[tokio::test] - async fn session_lease_reconciles_a_stale_working_dir() { + async fn working_dir_updates_keep_clients_that_take_the_directory_per_call() { let data_dir = tempfile::tempdir().unwrap(); let old_working_dir = tempfile::tempdir().unwrap(); let new_working_dir = tempfile::tempdir().unwrap(); @@ -2031,143 +1594,7 @@ mod tests { .session_manager .create_session( old_working_dir.path().to_path_buf(), - "moving-session".to_string(), - crate::session::SessionType::Hidden, - crate::config::GooseMode::default(), - ) - .await - .unwrap(); - manager - .add_client( - builtin_config("external", vec![]), - Some(old_working_dir.path().to_path_buf()), - Arc::new(MockClient {}), - None, - ) - .await; - - manager - .update_working_dir(new_working_dir.path(), None, &session.id) - .await - .unwrap(); - let lease = manager - .current_session_lease(&session.id, old_working_dir.path()) - .await; - - assert_eq!(lease.working_dir(), Some(new_working_dir.path())); - assert!(lease.is_enabled("external")); - } - - #[tokio::test] - async fn app_dispatch_reconciles_a_stale_working_dir() { - let data_dir = tempfile::tempdir().unwrap(); - let old_working_dir = tempfile::tempdir().unwrap(); - let new_working_dir = tempfile::tempdir().unwrap(); - let manager = Arc::new(ExtensionManager::new_without_provider( - data_dir.path().to_path_buf(), - )); - let session = manager - .get_context() - .session_manager - .create_session( - old_working_dir.path().to_path_buf(), - "moving-app-session".to_string(), - crate::session::SessionType::Hidden, - crate::config::GooseMode::default(), - ) - .await - .unwrap(); - manager - .add_client( - builtin_config("external", vec![]), - Some(old_working_dir.path().to_path_buf()), - Arc::new(NamedToolsClient(vec![app_tool("ping")])), - None, - ) - .await; - manager - .update_working_dir(new_working_dir.path(), None, &session.id) - .await - .unwrap(); - - let ctx = - ToolCallContext::new(session.id, Some(old_working_dir.path().to_path_buf()), None); - manager - .dispatch_app_tool_call( - &ctx, - CallToolRequestParams::new("external__ping".to_string()), - "external", - CancellationToken::default(), - ) - .await - .unwrap() - .result - .await - .unwrap(); - } - - #[tokio::test] - async fn session_client_uses_the_current_session_directory() { - let data_dir = tempfile::tempdir().unwrap(); - let old_working_dir = tempfile::tempdir().unwrap(); - let new_working_dir = tempfile::tempdir().unwrap(); - let manager = Arc::new(ExtensionManager::new_without_provider( - data_dir.path().to_path_buf(), - )); - let session = manager - .get_context() - .session_manager - .create_session( - old_working_dir.path().to_path_buf(), - "moving-client-session".to_string(), - crate::session::SessionType::Hidden, - crate::config::GooseMode::default(), - ) - .await - .unwrap(); - manager - .get_context() - .session_manager - .update(&session.id) - .working_dir(new_working_dir.path().to_path_buf()) - .apply() - .await - .unwrap(); - - manager - .add_session_client( - builtin_config("external", vec![]), - &session.id, - Arc::new(MockClient {}), - None, - ) - .await - .unwrap(); - - assert!(manager - .current_lease(&session.id, Some(new_working_dir.path())) - .await - .is_enabled("external")); - assert!(!manager - .current_lease(&session.id, Some(old_working_dir.path())) - .await - .is_enabled("external")); - } - - #[tokio::test] - async fn working_dir_updates_preserve_platform_client_state() { - let data_dir = tempfile::tempdir().unwrap(); - let old_working_dir = tempfile::tempdir().unwrap(); - let new_working_dir = tempfile::tempdir().unwrap(); - let manager = Arc::new(ExtensionManager::new_without_provider( - data_dir.path().to_path_buf(), - )); - let session = manager - .get_context() - .session_manager - .create_session( - old_working_dir.path().to_path_buf(), - "platform-state".to_string(), + "moving".to_string(), crate::session::SessionType::Hidden, crate::config::GooseMode::default(), ) @@ -2182,22 +1609,38 @@ mod tests { bundled: None, available_tools: vec![], }, - Some(old_working_dir.path().to_path_buf()), + None, None, Some(&session.id), ) .await .unwrap(); - let original = manager.extensions.lock().await["developer"].clone(); + manager + .add_client( + builtin_config("external", vec![]), + Arc::new(MockClient {}), + None, + ) + .await; + let before = manager.extensions.lock().await.clone(); manager .update_working_dir(new_working_dir.path(), None, &session.id) .await .unwrap(); - let updated = manager.extensions.lock().await["developer"].clone(); - assert!(Arc::ptr_eq(&original.client, &updated.client)); - assert_eq!(updated.working_dir, new_working_dir.path()); + let after = manager.extensions.lock().await.clone(); + for key in ["developer", "external"] { + assert!( + Arc::ptr_eq(&before[key], &after[key]), + "{key} was restarted" + ); + } + let lease = manager + .current_lease(&session.id, Some(old_working_dir.path())) + .await; + assert_eq!(lease.working_dir(), Some(new_working_dir.path())); + assert!(lease.is_enabled("developer") && lease.is_enabled("external")); } #[tokio::test] @@ -2215,7 +1658,7 @@ mod tests { available_tools: vec![], }; extension_manager - .add_client(config.clone(), None, Arc::new(MockClient {}), None) + .add_client(config.clone(), Arc::new(MockClient {}), None) .await; let stale = extension_manager .extensions @@ -2280,9 +1723,10 @@ mod tests { .unwrap(); let tools = extension_manager - .get_prefixed_tools("session", Some("extensionmanager".to_string())) + .current_lease("session", None) .await - .unwrap(); + .tools_for("extensionmanager") + .await; assert!(tools .iter() .all(|tool| tool.name != "extensionmanager__list_resources")); @@ -2295,16 +1739,16 @@ mod tests { extension_manager .add_client( builtin_config("resources", vec![]), - None, Arc::new(MockClient {}), Some(resource_info), ) .await; let tools = extension_manager - .get_prefixed_tools("session", Some("extensionmanager".to_string())) + .current_lease("session", None) .await - .unwrap(); + .tools_for("extensionmanager") + .await; assert!(tools .iter() .any(|tool| tool.name == "extensionmanager__list_resources")); @@ -2314,9 +1758,10 @@ mod tests { .await .unwrap(); let tools = extension_manager - .get_prefixed_tools("session", Some("extensionmanager".to_string())) + .current_lease("session", None) .await - .unwrap(); + .tools_for("extensionmanager") + .await; assert!(tools .iter() .all(|tool| tool.name != "extensionmanager__list_resources")); @@ -2351,7 +1796,6 @@ mod tests { extension_manager .add_client( builtin_config("resources", vec![]), - None, Arc::new(ResourceClient { label: "old" }), Some(resource_info.clone()), ) @@ -2370,7 +1814,6 @@ mod tests { extension_manager .add_client( builtin_config("resources", vec![]), - None, Arc::new(ResourceClient { label: "new" }), Some(resource_info), ) @@ -2435,9 +1878,10 @@ mod tests { let manager = manager.clone(); tokio::spawn(async move { manager - .get_prefixed_tools("test-session", None) + .current_lease("test-session", None) + .await + .tools() .await - .unwrap() }) }; @@ -2449,9 +1893,10 @@ mod tests { assert!(stale_result.iter().any(|tool| tool.name == "dynamic__old")); let refreshed = manager - .get_prefixed_tools("test-session", None) + .current_lease("test-session", None) .await - .unwrap(); + .tools() + .await; assert!(refreshed.iter().any(|tool| tool.name == "dynamic__new")); assert_eq!(tools_client.calls.load(Ordering::SeqCst), 2); } @@ -2506,89 +1951,6 @@ mod tests { .any(|config| config.key() == "analyze")); } - #[tokio::test] - async fn mutation_uses_the_sessions_current_working_dir() { - let data_dir = tempfile::tempdir().unwrap(); - let old_working_dir = tempfile::tempdir().unwrap(); - let new_working_dir = tempfile::tempdir().unwrap(); - let manager = Arc::new(ExtensionManager::new_without_provider( - data_dir.path().to_path_buf(), - )); - let session = manager - .get_context() - .session_manager - .create_session( - old_working_dir.path().to_path_buf(), - "moved-session".to_string(), - crate::session::SessionType::Hidden, - crate::config::GooseMode::default(), - ) - .await - .unwrap(); - manager - .get_context() - .session_manager - .update(&session.id) - .working_dir(new_working_dir.path().to_path_buf()) - .apply() - .await - .unwrap(); - - manager - .apply( - ExtensionMutation::Enable { - name: "analyze".to_string(), - }, - None, - &session.id, - ) - .await - .unwrap(); - - let extension = manager.extensions.lock().await["analyze"].clone(); - assert_eq!(extension.working_dir, new_working_dir.path()); - } - - #[tokio::test] - async fn direct_add_uses_the_sessions_current_working_dir() { - let data_dir = tempfile::tempdir().unwrap(); - let old_working_dir = tempfile::tempdir().unwrap(); - let new_working_dir = tempfile::tempdir().unwrap(); - let manager = Arc::new(ExtensionManager::new_without_provider( - data_dir.path().to_path_buf(), - )); - let session = manager - .get_context() - .session_manager - .create_session( - new_working_dir.path().to_path_buf(), - "moved-session".to_string(), - crate::session::SessionType::Hidden, - crate::config::GooseMode::default(), - ) - .await - .unwrap(); - - manager - .add_extension( - ExtensionConfig::Platform { - name: "analyze".to_string(), - display_name: None, - description: "analyze".to_string(), - bundled: None, - available_tools: vec![], - }, - Some(old_working_dir.path().to_path_buf()), - None, - Some(&session.id), - ) - .await - .unwrap(); - - let extension = manager.extensions.lock().await["analyze"].clone(); - assert_eq!(extension.working_dir, new_working_dir.path()); - } - #[test] fn test_recover_mangled_tool_name() { let tools = [("developer__shell", None), ("platform__search", None)]; diff --git a/crates/goose/src/agents/mcp_client.rs b/crates/goose/src/agents/mcp_client.rs index dc0f39eb8..34e461250 100644 --- a/crates/goose/src/agents/mcp_client.rs +++ b/crates/goose/src/agents/mcp_client.rs @@ -27,7 +27,7 @@ use rmcp::{ use serde_json::Value; use std::{ collections::HashMap, - path::PathBuf, + path::{Path, PathBuf}, sync::{ atomic::{AtomicU64, Ordering}, Arc, Mutex as StdMutex, @@ -91,20 +91,10 @@ pub trait McpClientTrait: Send + Sync { fn get_info(&self) -> Option<&InitializeResult>; - /// Return the extension's current instructions. The default reads from - /// `get_info()`, but platform extensions can override this to provide - /// dynamically computed instructions (e.g. freshly discovered skills). - fn get_instructions(&self) -> Option { + async fn get_instructions(&self, _session_id: &str, _working_dir: &Path) -> Option { self.get_info().and_then(|info| info.instructions.clone()) } - fn rebind_session( - &self, - _session: Arc, - ) -> Option> { - None - } - async fn list_resources( &self, _session_id: &str, diff --git a/crates/goose/src/agents/moim.rs b/crates/goose/src/agents/moim.rs index f57d1e595..7496e3d9b 100644 --- a/crates/goose/src/agents/moim.rs +++ b/crates/goose/src/agents/moim.rs @@ -221,6 +221,7 @@ fn turn_budget_part(turns_taken: u32, max_turns: u32) -> Option { #[cfg(test)] mod tests { use super::*; + use crate::agents::extension_manager::ExtensionSet; use crate::agents::mcp_client::McpClientTrait; use crate::agents::tool_execution::ToolCallContext; use crate::config::ExtensionConfig; @@ -334,21 +335,11 @@ mod tests { #[tokio::test] async fn turn_context_uses_the_inference_lease() { let (session_id, em, _tmp) = session_and_manager().await; - em.add_client( - moim_extension(), - None, - Arc::new(MoimClient("old context")), - None, - ) - .await; + em.add_client(moim_extension(), Arc::new(MoimClient("old context")), None) + .await; let lease = em.current_lease(&session_id, None).await; - em.add_client( - moim_extension(), - None, - Arc::new(MoimClient("new context")), - None, - ) - .await; + em.add_client(moim_extension(), Arc::new(MoimClient("new context")), None) + .await; let message = turn_context_message(&session_id, &em, &lease, 0, 100, chrono::Local::now(), None) @@ -365,7 +356,7 @@ mod tests { let (session_id, em, _tmp) = session_and_manager().await; let leased_working_dir = PathBuf::from("/leased/dir"); let lease = em - .current_lease(&session_id, Some(&leased_working_dir)) + .resolve(&ExtensionSet::new(&session_id, Some(leased_working_dir), vec![]).unwrap()) .await; let message = diff --git a/crates/goose/src/agents/platform_extensions/analyze/mod.rs b/crates/goose/src/agents/platform_extensions/analyze/mod.rs index 679c48bdf..d9d204d2f 100644 --- a/crates/goose/src/agents/platform_extensions/analyze/mod.rs +++ b/crates/goose/src/agents/platform_extensions/analyze/mod.rs @@ -281,7 +281,6 @@ mod tests { provider: Arc::new(tokio::sync::Mutex::new(None)), session_manager: Arc::new(SessionManager::new(std::env::temp_dir())), scheduler: None, - session: None, use_login_shell_path: false, } } diff --git a/crates/goose/src/agents/platform_extensions/apps.rs b/crates/goose/src/agents/platform_extensions/apps.rs index 2e615b531..e4312df2d 100644 --- a/crates/goose/src/agents/platform_extensions/apps.rs +++ b/crates/goose/src/agents/platform_extensions/apps.rs @@ -831,7 +831,6 @@ mod tests { provider: Arc::new(tokio::sync::Mutex::new(None)), session_manager: Arc::new(SessionManager::new(apps_dir.join("sessions"))), scheduler: None, - session: None, use_login_shell_path: false, }, apps_dir, diff --git a/crates/goose/src/agents/platform_extensions/chatrecall.rs b/crates/goose/src/agents/platform_extensions/chatrecall.rs index 13f990578..8c12be01e 100644 --- a/crates/goose/src/agents/platform_extensions/chatrecall.rs +++ b/crates/goose/src/agents/platform_extensions/chatrecall.rs @@ -111,9 +111,14 @@ impl ChatRecallClient { Ok(Self { info, context }) } - fn search_session_types(&self) -> Vec { - match self.context.session.as_ref().map(|s| s.session_type) { - Some(SessionType::Acp) => vec![SessionType::Acp], + async fn search_session_types(&self, current_session_id: &str) -> Vec { + let current = self + .context + .session_manager + .get_session(current_session_id, false) + .await; + match current.map(|s| s.session_type) { + Ok(SessionType::Acp) => vec![SessionType::Acp], _ => vec![SessionType::User, SessionType::Scheduled], } } @@ -205,7 +210,7 @@ impl ChatRecallClient { after_date, before_date, exclude_session_id, - self.search_session_types(), + self.search_session_types(current_session_id).await, ) .await { @@ -444,7 +449,6 @@ mod tests { provider: Arc::new(tokio::sync::Mutex::new(None)), session_manager, scheduler: None, - session: Some(Arc::new(current_session.clone())), use_login_shell_path: false, }) .unwrap(); diff --git a/crates/goose/src/agents/platform_extensions/code_execution.rs b/crates/goose/src/agents/platform_extensions/code_execution.rs index f6d9c1316..0cac073f9 100644 --- a/crates/goose/src/agents/platform_extensions/code_execution.rs +++ b/crates/goose/src/agents/platform_extensions/code_execution.rs @@ -77,26 +77,6 @@ impl CodeExecutionClient { }) } - async fn load_callback_configs( - &self, - session_id: &str, - lease: Option<&ExtensionLease>, - ) -> Option> { - let tools = match lease { - Some(lease) => lease.tools_excluding(EXTENSION_NAME).await, - None => self - .context - .extension_manager - .as_ref() - .and_then(|manager| manager.upgrade())? - .get_prefixed_tools_excluding(session_id, EXTENSION_NAME) - .await - .ok()?, - }; - - Some(Self::callback_configs(tools)) - } - fn callback_configs(tools: Vec) -> Vec { let mut cfgs = vec![]; for tool in tools { @@ -124,15 +104,8 @@ impl CodeExecutionClient { } /// Get the cached CodeMode, rebuilding if callback configs have changed - async fn get_code_mode( - &self, - session_id: &str, - lease: Option<&ExtensionLease>, - ) -> Result { - let cfgs = self - .load_callback_configs(session_id, lease) - .await - .ok_or("Failed to load callback configs")?; + async fn get_code_mode(&self, lease: &ExtensionLease) -> Result { + let cfgs = Self::callback_configs(lease.tools_excluding(EXTENSION_NAME).await); self.get_code_mode_for_configs(cfgs).await } @@ -211,10 +184,9 @@ impl CodeExecutionClient { /// Handle the list_functions tool call async fn handle_list_functions( &self, - session_id: &str, - lease: Option<&ExtensionLease>, + lease: &ExtensionLease, ) -> Result, String> { - let code_mode = self.get_code_mode(session_id, lease).await?; + let code_mode = self.get_code_mode(lease).await?; let output = code_mode.list_functions(); Ok(vec![ContentBlock::text(output.code)]) @@ -223,8 +195,7 @@ impl CodeExecutionClient { /// Handle the get_function_details tool call async fn handle_get_function_details( &self, - session_id: &str, - lease: Option<&ExtensionLease>, + lease: &ExtensionLease, arguments: Option, ) -> Result, String> { let input: GetFunctionDetailsInput = arguments @@ -233,7 +204,7 @@ impl CodeExecutionClient { .map_err(|e| format!("Failed to parse arguments: {e}"))? .ok_or("Missing arguments for get_function_details")?; - let code_mode = self.get_code_mode(session_id, lease).await?; + let code_mode = self.get_code_mode(lease).await?; let output = code_mode.get_function_details(input); Ok(vec![ContentBlock::text(output.code)]) @@ -242,8 +213,7 @@ impl CodeExecutionClient { /// Handle the execute bash tool call async fn handle_execute_bash( &self, - session_id: &str, - lease: Option<&ExtensionLease>, + lease: &ExtensionLease, arguments: Option, cancellation_token: CancellationToken, ) -> Result, String> { @@ -253,7 +223,7 @@ impl CodeExecutionClient { .map_err(|e| format!("Failed to parse arguments: {e}"))? .ok_or("Missing arguments for execute_bash")?; let command = input.command; - let code_mode = self.get_code_mode(session_id, lease).await?; + let code_mode = self.get_code_mode(lease).await?; let dispatch_token = cancellation_token.child_token(); let output = run_in_deno_runtime( @@ -288,10 +258,7 @@ impl CodeExecutionClient { .map_err(|e| format!("Failed to parse arguments: {e}"))? .ok_or("Missing arguments for execute_typescript")?; - let session_id = &ctx.session_id; - let code_mode = self - .get_code_mode(session_id, ctx.extension_lease().map(AsRef::as_ref)) - .await?; + let code_mode = self.get_code_mode(dispatching_lease(ctx)).await?; let dispatch_token = cancellation_token.child_token(); let rt = tokio::runtime::Handle::current(); let registry = self.build_callback_registry(ctx, &code_mode, dispatch_token.clone(), rt)?; @@ -386,6 +353,11 @@ where .map_err(|e| format!("Execution task failed: {e}"))? } +fn dispatching_lease(ctx: &ToolCallContext) -> &ExtensionLease { + ctx.extension_lease() + .expect("platform tool calls are dispatched through a lease") +} + fn create_tool_callback( ctx: ToolCallContext, full_name: String, @@ -409,18 +381,9 @@ fn create_tool_callback( }; let handle = rt.spawn(async move { - let dispatch_result = match ctx.extension_lease().cloned() { - Some(lease) => { - lease - .call(tool_call, CallRequest::from(&ctx), cancellation_token) - .await - } - None => { - manager - .dispatch_tool_call(&ctx, tool_call, cancellation_token) - .await - } - }; + let dispatch_result = dispatching_lease(&ctx) + .call(tool_call, CallRequest::from(&ctx), cancellation_token) + .await; match dispatch_result { Ok(dispatch_result) => match manager .applying_mutation( @@ -598,16 +561,12 @@ impl McpClientTrait for CodeExecutionClient { arguments: Option, cancellation_token: CancellationToken, ) -> Result { - let session_id = &ctx.session_id; - let lease = ctx.extension_lease().map(AsRef::as_ref); + let lease = dispatching_lease(ctx); let result = match name { - "list_functions" => self.handle_list_functions(session_id, lease).await, - "get_function_details" => { - self.handle_get_function_details(session_id, lease, arguments) - .await - } + "list_functions" => self.handle_list_functions(lease).await, + "get_function_details" => self.handle_get_function_details(lease, arguments).await, "execute_bash" => { - self.handle_execute_bash(session_id, lease, arguments, cancellation_token) + self.handle_execute_bash(lease, arguments, cancellation_token) .await } "execute_typescript" => { @@ -848,19 +807,14 @@ mod tests { bundled: None, available_tools: vec![], }, - None, Arc::new(VisibilityClient), None, ) .await; - let mut context = manager.get_context().clone(); - context.extension_manager = Some(Arc::downgrade(&manager)); - let client = CodeExecutionClient::new(context, ToolDisclosure::Catalog).unwrap(); - let configs = client - .load_callback_configs("test-session", None) - .await - .unwrap(); + let lease = manager.current_lease("test-session", None).await; + let configs = + CodeExecutionClient::callback_configs(lease.tools_excluding(EXTENSION_NAME).await); let names = configs .iter() .map(|config| config.name.as_str()) @@ -1197,7 +1151,6 @@ mod tests { temp.path().join("sessions"), )), scheduler: None, - session: None, use_login_shell_path: false, }, ToolDisclosure::Filesystem, diff --git a/crates/goose/src/agents/platform_extensions/developer/mod.rs b/crates/goose/src/agents/platform_extensions/developer/mod.rs index 7663ec6b2..c09baa521 100644 --- a/crates/goose/src/agents/platform_extensions/developer/mod.rs +++ b/crates/goose/src/agents/platform_extensions/developer/mod.rs @@ -297,7 +297,6 @@ mod tests { provider: Arc::new(tokio::sync::Mutex::new(None)), session_manager: Arc::new(SessionManager::new(data_dir)), scheduler: None, - session: None, use_login_shell_path: false, } } diff --git a/crates/goose/src/agents/platform_extensions/ext_manager.rs b/crates/goose/src/agents/platform_extensions/ext_manager.rs index c5c825d66..0ff28bf8a 100644 --- a/crates/goose/src/agents/platform_extensions/ext_manager.rs +++ b/crates/goose/src/agents/platform_extensions/ext_manager.rs @@ -28,9 +28,6 @@ pub enum ExtensionManagerToolError { #[error("Unknown tool: {tool_name}")] UnknownTool { tool_name: String }, - #[error("Extension manager not available")] - ManagerUnavailable, - #[error("Missing required parameter: {param_name}")] MissingParameter { param_name: String }, @@ -105,23 +102,15 @@ impl ExtensionManagerClient { Ok(Self { info, context }) } - async fn handle_search_available_extensions( - &self, - ) -> Result, ExtensionManagerToolError> { - let extension_manager = self - .context - .extension_manager - .as_ref() - .and_then(|weak| weak.upgrade()) - .ok_or(ExtensionManagerToolError::ManagerUnavailable)?; - let enabled = extension_manager.list_extensions().await.map_err(|e| { - ExtensionManagerToolError::OperationFailed { - message: format!("Failed to search available extensions: {}", e), - } - })?; - Ok(vec![ContentBlock::text(search_available_extensions( - &enabled, - ))]) + fn handle_search_available_extensions(ctx: &ToolCallContext) -> Vec { + let enabled: Vec = ctx + .extension_lease() + .expect("platform tool calls are dispatched through a lease") + .configs() + .iter() + .map(ExtensionConfig::key) + .collect(); + vec![ContentBlock::text(search_available_extensions(&enabled))] } async fn handle_manage_extensions( @@ -221,21 +210,11 @@ impl ExtensionManagerClient { arguments: Option, ) -> Result, ExtensionManagerToolError> { let params = arguments.map(serde_json::Value::Object).unwrap_or_default(); - let result = if let Some(lease) = ctx.extension_lease() { - lease - .list_resources(params, CancellationToken::default()) - .await - } else { - let manager = self - .context - .extension_manager - .as_ref() - .and_then(|manager| manager.upgrade()) - .ok_or(ExtensionManagerToolError::ManagerUnavailable)?; - manager - .list_resources(&ctx.session_id, params, CancellationToken::default()) - .await - }; + let result = ctx + .extension_lease() + .expect("platform tool calls are dispatched through a lease") + .list_resources(params, CancellationToken::default()) + .await; result.map_err(|error| ExtensionManagerToolError::OperationFailed { message: format!("Failed to list resources: {}", error.message), }) @@ -247,21 +226,11 @@ impl ExtensionManagerClient { arguments: Option, ) -> Result, ExtensionManagerToolError> { let params = arguments.map(serde_json::Value::Object).unwrap_or_default(); - let result = if let Some(lease) = ctx.extension_lease() { - lease - .read_resource_tool(params, CancellationToken::default()) - .await - } else { - let manager = self - .context - .extension_manager - .as_ref() - .and_then(|manager| manager.upgrade()) - .ok_or(ExtensionManagerToolError::ManagerUnavailable)?; - manager - .read_resource_tool(&ctx.session_id, params, CancellationToken::default()) - .await - }; + let result = ctx + .extension_lease() + .expect("platform tool calls are dispatched through a lease") + .read_resource_tool(params, CancellationToken::default()) + .await; result.map_err(|error| ExtensionManagerToolError::OperationFailed { message: format!("Failed to read resource: {}", error.message), }) @@ -432,7 +401,7 @@ impl McpClientTrait for ExtensionManagerClient { let session_id = &ctx.session_id; let result = match name { SEARCH_AVAILABLE_EXTENSIONS_TOOL_NAME => { - self.handle_search_available_extensions().await + Ok(Self::handle_search_available_extensions(ctx)) } MANAGE_EXTENSIONS_TOOL_NAME => { return Ok(self @@ -542,11 +511,10 @@ mod tests { fn client_for(manager: &Arc) -> ExtensionManagerClient { ExtensionManagerClient::new(PlatformExtensionContext { - extension_manager: Some(Arc::downgrade(manager)), + extension_manager: None, provider: manager.get_provider().clone(), session_manager: manager.get_context().session_manager.clone(), scheduler: None, - session: None, use_login_shell_path: false, }) .unwrap() diff --git a/crates/goose/src/agents/platform_extensions/mod.rs b/crates/goose/src/agents/platform_extensions/mod.rs index 5a266d6da..185d6dd4d 100644 --- a/crates/goose/src/agents/platform_extensions/mod.rs +++ b/crates/goose/src/agents/platform_extensions/mod.rs @@ -19,7 +19,6 @@ pub mod tom; use std::collections::HashMap; use crate::agents::mcp_client::McpClientTrait; -use crate::session::Session; use once_cell::sync::Lazy; pub use ext_manager::MANAGE_EXTENSIONS_TOOL_NAME_COMPLETE; @@ -224,9 +223,7 @@ pub static PLATFORM_EXTENSIONS: Lazy default_enabled: true, unprefixed_tools: true, hidden: false, - client_factory: |ctx| { - Some(Box::new(crate::skills::SkillsClient::new(ctx).unwrap())) - }, + client_factory: |_| Some(Box::new(crate::skills::SkillsClient::default())), }, ); @@ -244,7 +241,6 @@ pub struct PlatformExtensionContext { pub provider: crate::agents::types::SharedProvider, pub session_manager: std::sync::Arc, pub scheduler: Option>, - pub session: Option>, pub use_login_shell_path: bool, } diff --git a/crates/goose/src/agents/platform_extensions/orchestrator.rs b/crates/goose/src/agents/platform_extensions/orchestrator.rs index 409abd734..5b6ce4d8e 100644 --- a/crates/goose/src/agents/platform_extensions/orchestrator.rs +++ b/crates/goose/src/agents/platform_extensions/orchestrator.rs @@ -2,7 +2,7 @@ use crate::agents::extension::PlatformExtensionContext; use crate::agents::mcp_client::{Error, McpClientTrait}; use crate::agents::tool_execution::ToolCallContext; use crate::agents::{AgentEvent, SessionConfig}; -use crate::config::{Config, ExtensionConfig, GooseMode}; +use crate::config::{Config, GooseMode}; use crate::context_mgmt::format_message_for_compacting; use crate::conversation::message::Message; use crate::conversation::Conversation; @@ -137,26 +137,6 @@ impl OrchestratorClient { .ok_or_else(|| "Provider not available".to_string()) } - async fn parent_model_config( - &self, - provider_name: &str, - ) -> Result { - if let Some(session) = self.context.session.as_ref() { - return self.context.model_config_for_session(&session.id).await; - } - - let model_name = Config::global() - .get_goose_model() - .map_err(|_| "Could not resolve model config: missing model".to_string())?; - crate::model_config::model_config_from_user_config(provider_name, &model_name) - .map_err(|e| format!("Could not resolve model config: {e}")) - } - - fn parent_extensions(&self) -> Vec { - let extension_data = self.context.session.as_ref().map(|s| &s.extension_data); - EnabledExtensionsState::extensions_or_default(extension_data, Config::global()) - } - async fn handle_list_sessions( &self, arguments: Option, @@ -349,7 +329,7 @@ impl OrchestratorClient { conversation_text )); - let model_config = self.parent_model_config(provider.get_name()).await?; + let model_config = self.context.model_config_for_session(session_id).await?; let (response, _usage) = crate::model_config::complete_one_shot( provider.as_ref(), &model_config, @@ -381,6 +361,7 @@ impl OrchestratorClient { arguments: Option, ) -> Result { self.authorize_start_agent(session_id).await?; + let caller = self.caller_session(session_id).await?; let args = arguments.ok_or("Missing arguments")?; let working_dir = extract_string(&args, "working_dir")?; @@ -394,13 +375,7 @@ impl OrchestratorClient { let path = if raw_path.is_absolute() { raw_path } else { - let base = self - .context - .session - .as_ref() - .map(|s| s.working_dir.clone()) - .unwrap_or_else(|| PathBuf::from(".")); - base.join(&raw_path) + caller.working_dir.join(&raw_path) }; let path = path @@ -427,8 +402,11 @@ impl OrchestratorClient { .map_err(|e| format!("Failed to create agent: {}", e))?; let parent_provider = self.get_provider().await?; - let extensions = self.parent_extensions(); - let model_config = self.parent_model_config(parent_provider.get_name()).await?; + let extensions = EnabledExtensionsState::extensions_or_default( + Some(&caller.extension_data), + Config::global(), + ); + let model_config = self.context.model_config_for_session(session_id).await?; let provider = providers::create(parent_provider.get_name(), extensions) .await .map_err(|e| format!("Failed to create provider for new agent: {}", e))?; @@ -516,8 +494,15 @@ impl OrchestratorClient { if agent.provider().await.is_err() { if let Ok(parent_provider) = self.get_provider().await { - let extensions = self.parent_extensions(); - let model_config = self.parent_model_config(parent_provider.get_name()).await?; + let caller = self.caller_session(parent_session_id).await?; + let extensions = EnabledExtensionsState::extensions_or_default( + Some(&caller.extension_data), + Config::global(), + ); + let model_config = self + .context + .model_config_for_session(parent_session_id) + .await?; if let Ok(provider) = providers::create(parent_provider.get_name(), extensions).await { @@ -753,16 +738,12 @@ mod tests { use crate::session::SessionManager; use rmcp::model::{Annotations, Role, TextContent}; - fn client_for( - session_manager: Arc, - session: Option, - ) -> OrchestratorClient { + fn client_for(session_manager: Arc) -> OrchestratorClient { OrchestratorClient::new(PlatformExtensionContext { extension_manager: None, provider: Arc::new(tokio::sync::Mutex::new(None)), session_manager, scheduler: None, - session: session.map(Arc::new), use_login_shell_path: false, }) .unwrap() @@ -864,7 +845,7 @@ mod tests { let session_manager = Arc::new(SessionManager::new(temp_dir.path().to_path_buf())); let subagent = create_session(&session_manager, temp_dir.path(), SessionType::SubAgent).await; - let client = client_for(Arc::clone(&session_manager), Some(subagent.clone())); + let client = client_for(Arc::clone(&session_manager)); let result = start_agent(&client, &subagent.id, temp_dir.path()).await; @@ -883,7 +864,7 @@ mod tests { let user = create_session(&session_manager, temp_dir.path(), SessionType::User).await; let subagent = create_session(&session_manager, temp_dir.path(), SessionType::SubAgent).await; - let client = client_for(Arc::clone(&session_manager), Some(user.clone())); + let client = client_for(Arc::clone(&session_manager)); assert!(client.authorize_start_agent(&user.id).await.is_ok()); let user_tools = client @@ -914,7 +895,7 @@ mod tests { async fn unknown_caller_cannot_persist_user_session() { let temp_dir = tempfile::tempdir().unwrap(); let session_manager = Arc::new(SessionManager::new(temp_dir.path().to_path_buf())); - let client = client_for(Arc::clone(&session_manager), None); + let client = client_for(Arc::clone(&session_manager)); let result = start_agent(&client, "missing-session", temp_dir.path()).await; @@ -932,7 +913,7 @@ mod tests { let session_manager = Arc::new(SessionManager::new(temp_dir.path().to_path_buf())); let user = create_session(&session_manager, temp_dir.path(), SessionType::User).await; let subagent = create_subagent_session(&session_manager, temp_dir.path(), &user.id).await; - let client = client_for(Arc::clone(&session_manager), Some(subagent.clone())); + let client = client_for(Arc::clone(&session_manager)); let error = client .handle_send_message( @@ -964,7 +945,7 @@ mod tests { let parent = create_session(&session_manager, temp_dir.path(), SessionType::User).await; let caller = create_subagent_session(&session_manager, temp_dir.path(), &parent.id).await; let target = create_subagent_session(&session_manager, temp_dir.path(), &parent.id).await; - let client = client_for(Arc::clone(&session_manager), Some(caller.clone())); + let client = client_for(Arc::clone(&session_manager)); assert!(client .authorize_send_message(&caller.id, &target.id) @@ -984,7 +965,7 @@ mod tests { create_subagent_session(&session_manager, temp_dir.path(), &caller_parent.id).await; let target = create_subagent_session(&session_manager, temp_dir.path(), &target_parent.id).await; - let client = client_for(Arc::clone(&session_manager), Some(caller.clone())); + let client = client_for(Arc::clone(&session_manager)); let error = client .handle_send_message( @@ -1017,7 +998,7 @@ mod tests { let caller = create_subagent_session(&session_manager, temp_dir.path(), &parent.id).await; let descendant = create_subagent_session(&session_manager, temp_dir.path(), &caller.id).await; - let client = client_for(Arc::clone(&session_manager), Some(caller.clone())); + let client = client_for(Arc::clone(&session_manager)); let error = client .authorize_send_message(&caller.id, &descendant.id) @@ -1036,7 +1017,7 @@ mod tests { let session_manager = Arc::new(SessionManager::new(temp_dir.path().to_path_buf())); let caller = create_session(&session_manager, temp_dir.path(), SessionType::SubAgent).await; let target = create_session(&session_manager, temp_dir.path(), SessionType::SubAgent).await; - let client = client_for(Arc::clone(&session_manager), Some(caller.clone())); + let client = client_for(Arc::clone(&session_manager)); let error = client .authorize_send_message(&caller.id, &target.id) @@ -1055,7 +1036,7 @@ mod tests { let session_manager = Arc::new(SessionManager::new(temp_dir.path().to_path_buf())); let caller = create_session(&session_manager, temp_dir.path(), SessionType::User).await; let target = create_session(&session_manager, temp_dir.path(), SessionType::User).await; - let client = client_for(Arc::clone(&session_manager), Some(caller.clone())); + let client = client_for(Arc::clone(&session_manager)); assert!(client .authorize_send_message(&caller.id, &target.id) @@ -1068,7 +1049,7 @@ mod tests { let temp_dir = tempfile::tempdir().unwrap(); let session_manager = Arc::new(SessionManager::new(temp_dir.path().to_path_buf())); let target = create_session(&session_manager, temp_dir.path(), SessionType::User).await; - let client = client_for(Arc::clone(&session_manager), None); + let client = client_for(Arc::clone(&session_manager)); let error = client .authorize_send_message("missing-session", &target.id) diff --git a/crates/goose/src/agents/platform_extensions/summon.rs b/crates/goose/src/agents/platform_extensions/summon.rs index 5bd78ca6d..03ad16871 100644 --- a/crates/goose/src/agents/platform_extensions/summon.rs +++ b/crates/goose/src/agents/platform_extensions/summon.rs @@ -448,55 +448,12 @@ fn build_instructions_with_context(context: &str, instructions: &str) -> String result } -fn build_subagent_instructions(session: Option<&crate::session::Session>) -> String { - let Some(session) = session else { - return String::new(); - }; - - // filter the sources down to what we want even though currently that is what we get - let mut sources: Vec = discover_filesystem_sources(&session.working_dir) - .into_iter() - .filter(|s| { - matches!( - s.source_type, - SourceType::Agent | SourceType::Recipe | SourceType::Subrecipe - ) - }) - .collect(); - - // If the session is started from a recipe, also use the subrecipes for - // that recipe as delegate targets - if let Some(recipe) = session.recipe.as_ref() { - if let Some(subs) = recipe.sub_recipes.as_ref() { - let mut seen: std::collections::HashSet = - sources.iter().map(|s| s.name.clone()).collect(); - for sr in subs { - if !seen.insert(sr.name.clone()) { - continue; - } - sources.push(SourceEntry { - source_type: SourceType::Subrecipe, - name: sr.name.clone(), - description: sr.description.clone().unwrap_or_default(), - content: String::new(), - path: sr.path.clone(), - global: false, - writable: false, - supporting_files: Vec::new(), - properties: std::collections::HashMap::new(), - }); - } - } - } - +fn build_subagent_instructions(sources: &[SourceEntry]) -> String { if sources.is_empty() { return String::new(); } - sources.sort_by(|a, b| (&a.source_type, &a.name).cmp(&(&b.source_type, &b.name))); - let subagents: Vec<&SourceEntry> = sources.iter().collect(); - - let names = subagents + let names = sources .iter() .map(|s| s.name.as_str()) .collect::>() @@ -510,7 +467,7 @@ fn build_subagent_instructions(session: Option<&crate::session::Session>) -> Str ); let mut current_kind: Option = None; - for s in &subagents { + for s in sources { if current_kind != Some(s.source_type) { out.push_str(&format!("\n{}:", kind_plural(s.source_type))); current_kind = Some(s.source_type); @@ -579,9 +536,9 @@ fn is_session_id(s: &str) -> bool { pub struct SummonClient { info: InitializeResult, context: PlatformExtensionContext, - source_cache: Arc>>, - background_tasks: Arc, - completed_tasks: Arc>>, + source_cache: Mutex>, + background_tasks: BackgroundTasks, + completed_tasks: Mutex>, } type CachedSources = (Instant, PathBuf, Vec); @@ -614,24 +571,12 @@ impl SummonClient { Ok(Self { info, context, - source_cache: Arc::new(Mutex::new(None)), - background_tasks: Arc::new(BackgroundTasks(Mutex::new(HashMap::new()))), - completed_tasks: Arc::new(Mutex::new(HashMap::new())), + source_cache: Mutex::new(None), + background_tasks: BackgroundTasks(Mutex::new(HashMap::new())), + completed_tasks: Mutex::new(HashMap::new()), }) } - fn rebound(&self, session: Arc) -> Self { - let mut context = self.context.clone(); - context.session = Some(session); - Self { - info: self.info.clone(), - context, - source_cache: Arc::clone(&self.source_cache), - background_tasks: Arc::clone(&self.background_tasks), - completed_tasks: Arc::clone(&self.completed_tasks), - } - } - async fn create_subagent_session( &self, task_config: &TaskConfig, @@ -823,12 +768,6 @@ impl SummonClient { fn working_dir(&self, ctx: &ToolCallContext) -> PathBuf { ctx.working_dir .clone() - .or_else(|| { - self.context - .session - .as_ref() - .map(|session| session.working_dir.clone()) - }) .unwrap_or_else(|| std::env::current_dir().unwrap_or_default()) } @@ -1387,20 +1326,12 @@ impl SummonClient { self.validate_delegate_params(¶ms)?; - let mut session = match self + let mut session = self .context - .session - .as_deref() - .filter(|session| session.id == session_id) - { - Some(session) => session.clone(), - None => self - .context - .session_manager - .get_session(session_id, false) - .await - .map_err(|e| format!("Failed to get session: {}", e))?, - }; + .session_manager + .get_session(session_id, false) + .await + .map_err(|e| format!("Failed to get session: {}", e))?; session.working_dir = working_dir.to_path_buf(); if session.session_type == SessionType::SubAgent { @@ -2352,20 +2283,10 @@ impl McpClientTrait for SummonClient { Some(&self.info) } - fn get_instructions(&self) -> Option { - let instructions = build_subagent_instructions(self.context.session.as_deref()); - if instructions.is_empty() { - None - } else { - Some(instructions) - } - } - - fn rebind_session( - &self, - session: Arc, - ) -> Option> { - Some(Arc::new(self.rebound(session))) + async fn get_instructions(&self, session_id: &str, working_dir: &Path) -> Option { + let sources = self.get_sources(session_id, working_dir).await; + let instructions = build_subagent_instructions(&sources); + (!instructions.is_empty()).then_some(instructions) } async fn get_moim(&self, _session_id: &str, _tools: &[Tool]) -> Option { @@ -2491,7 +2412,6 @@ mod tests { provider: Arc::new(tokio::sync::Mutex::new(None)), session_manager, scheduler: None, - session: None, use_login_shell_path: false, } } @@ -2642,8 +2562,7 @@ mod tests { } #[tokio::test] - async fn rebound_client_refreshes_instructions_and_preserves_task_state() { - let data_dir = TempDir::new().unwrap(); + async fn instructions_follow_the_calling_working_dir() { let old_working_dir = TempDir::new().unwrap(); let new_working_dir = TempDir::new().unwrap(); for (working_dir, name) in [ @@ -2658,43 +2577,19 @@ mod tests { ) .unwrap(); } - let session_manager = Arc::new(crate::session::SessionManager::new( - data_dir.path().to_path_buf(), - )); - let old_session = session_manager - .create_session( - old_working_dir.path().to_path_buf(), - "old".to_string(), - SessionType::Hidden, - GooseMode::Auto, - ) + let client = SummonClient::new(create_test_context()).unwrap(); + + let old = client + .get_instructions("session", old_working_dir.path()) .await .unwrap(); - let new_session = session_manager - .create_session( - new_working_dir.path().to_path_buf(), - "new".to_string(), - SessionType::Hidden, - GooseMode::Auto, - ) + let new = client + .get_instructions("session", new_working_dir.path()) .await .unwrap(); - let mut context = create_test_context_with_session_manager(session_manager); - context.session = Some(Arc::new(old_session)); - let client = SummonClient::new(context).unwrap(); - let rebound = client.rebound(Arc::new(new_session)); - - assert!(client.get_instructions().unwrap().contains("old-agent")); - assert!(rebound.get_instructions().unwrap().contains("new-agent")); - assert!(Arc::ptr_eq( - &client.background_tasks, - &rebound.background_tasks - )); - assert!(Arc::ptr_eq( - &client.completed_tasks, - &rebound.completed_tasks - )); + assert!(old.contains("old-agent") && !old.contains("new-agent")); + assert!(new.contains("new-agent") && !new.contains("old-agent")); } #[tokio::test] @@ -2726,9 +2621,10 @@ mod tests { ) .await .unwrap(); - let mut context = create_test_context_with_session_manager(Arc::clone(&session_manager)); - context.session = Some(Arc::new(session.clone())); - let client = SummonClient::new(context).unwrap(); + let client = SummonClient::new(create_test_context_with_session_manager(Arc::clone( + &session_manager, + ))) + .unwrap(); session_manager .update(&session.id) .working_dir(new_working_dir.path().to_path_buf()) @@ -2759,23 +2655,8 @@ mod tests { } #[tokio::test] - async fn shared_background_tasks_are_cancelled_after_all_clients_drop() { - let data_dir = TempDir::new().unwrap(); - let session_manager = Arc::new(crate::session::SessionManager::new( - data_dir.path().to_path_buf(), - )); - let session = session_manager - .create_session( - data_dir.path().to_path_buf(), - "rebound".to_string(), - SessionType::Hidden, - GooseMode::Auto, - ) - .await - .unwrap(); - let client = - SummonClient::new(create_test_context_with_session_manager(session_manager)).unwrap(); - let rebound = client.rebound(Arc::new(session)); + async fn background_tasks_are_cancelled_when_the_client_drops() { + let client = SummonClient::new(create_test_context()).unwrap(); let cancellation_token = CancellationToken::new(); let task_token = cancellation_token.clone(); let handle = tokio::spawn(async move { @@ -2797,12 +2678,7 @@ mod tests { }, ); - let (first, second) = tokio::join!( - tokio::spawn(async move { drop(client) }), - tokio::spawn(async move { drop(rebound) }) - ); - first.unwrap(); - second.unwrap(); + drop(client); assert!(cancellation_token.is_cancelled()); } diff --git a/crates/goose/src/agents/prompt_manager.rs b/crates/goose/src/agents/prompt_manager.rs index 871394cb1..afced2528 100644 --- a/crates/goose/src/agents/prompt_manager.rs +++ b/crates/goose/src/agents/prompt_manager.rs @@ -542,22 +542,24 @@ mod tests { provider: Arc::new(tokio::sync::Mutex::new(None)), session_manager, scheduler: Some(scheduler), - session: Some(Arc::new(session)), use_login_shell_path: false, }; - let mut extensions: Vec = PLATFORM_EXTENSIONS - .values() - .filter_map(|def| { - let client = (def.client_factory)(context.clone())?; - let instructions = client.get_instructions().unwrap_or_default(); - let has_resources = client - .get_info() - .and_then(|i| i.capabilities.resources.as_ref()) - .is_some(); - Some(ExtensionInfo::new(def.name, &instructions, has_resources)) - }) - .collect(); + let mut extensions = Vec::new(); + for def in PLATFORM_EXTENSIONS.values() { + let Some(client) = (def.client_factory)(context.clone()) else { + continue; + }; + let instructions = client + .get_instructions(&session.id, &session.working_dir) + .await + .unwrap_or_default(); + let has_resources = client + .get_info() + .and_then(|i| i.capabilities.resources.as_ref()) + .is_some(); + extensions.push(ExtensionInfo::new(def.name, &instructions, has_resources)); + } extensions.sort_by(|a, b| a.name.cmp(&b.name)); diff --git a/crates/goose/src/agents/reply_parts.rs b/crates/goose/src/agents/reply_parts.rs index fe2166dd8..4d832e3a5 100644 --- a/crates/goose/src/agents/reply_parts.rs +++ b/crates/goose/src/agents/reply_parts.rs @@ -225,7 +225,7 @@ impl Agent { let tools = prepare_inference_tools(tools, code_execution_active); - let extensions_info = lease.instructions(); + let extensions_info = lease.instructions().await; let model_config = self.effective_model_config_for_session(&session.id).await?; let goose_mode = *self.current_goose_mode.lock().await; diff --git a/crates/goose/src/agents/state_machine/inference_preparation.rs b/crates/goose/src/agents/state_machine/inference_preparation.rs index 6f40e9e88..a19398e9f 100644 --- a/crates/goose/src/agents/state_machine/inference_preparation.rs +++ b/crates/goose/src/agents/state_machine/inference_preparation.rs @@ -1,6 +1,7 @@ //! Goose-specific inference request preparation. use crate::agents::extension_manager::{ExtensionLease, ExtensionManager}; +use crate::agents::state_machine::awaits_tool_responses; use crate::agents::PromptManager; use crate::config::GooseMode; use crate::session::Session; @@ -30,10 +31,18 @@ impl InferenceRequestPreparer for GooseInferenceRequestPreparer<'_> { .extension_manager .current_session_snapshot(session) .await; - *self - .extension_lease - .lock() - .expect("extension lease unavailable") = Some(Arc::new(lease)); + // Tool requests run under the lease of the inference that made them, so an + // approval answered after that lease is gone expires instead of picking up a new one. + let awaiting = match &session.conversation { + Some(conversation) => awaits_tool_responses(messages_since_kickoff(conversation)?), + None => false, + }; + if !awaiting { + *self + .extension_lease + .lock() + .expect("extension lease unavailable") = Some(Arc::new(lease)); + } Ok(Some(session)) } diff --git a/crates/goose/src/agents/state_machine/ops_toolcalling.rs b/crates/goose/src/agents/state_machine/ops_toolcalling.rs index 41174c059..a4d3c6760 100644 --- a/crates/goose/src/agents/state_machine/ops_toolcalling.rs +++ b/crates/goose/src/agents/state_machine/ops_toolcalling.rs @@ -357,7 +357,7 @@ impl<'a> ToolExecutionOperation<'a> { async fn resolve_lease(&self, session: &Session) -> Arc { let lease = Arc::new( self.extension_manager - .current_session_lease(&session.id, &session.working_dir) + .current_lease(&session.id, Some(&session.working_dir)) .await, ); *self.lease.lock().expect("extension lease unavailable") = Some(Arc::clone(&lease)); @@ -478,21 +478,11 @@ impl<'a> ToolExecutionOperation<'a> { conversation: &Conversation, emit: &Emitter, ) -> Result> { - let prompts = match self - .extension_manager - .list_prompts(&session.id, emit.cancel_token().clone()) + let prompts = self + .lease(session) .await - { - Ok(prompts) => prompts, - Err(error) => { - return Self::command_response( - conversation, - format!("Failed to list prompts: {}", error.message), - emit, - ) - .await; - } - }; + .list_prompts(emit.cancel_token().clone()) + .await; let extension_filter = command.params_str.split_whitespace().next(); if let Some(filter) = extension_filter { if !prompts.contains_key(filter) { @@ -541,21 +531,11 @@ impl<'a> ToolExecutionOperation<'a> { ) .await; }; - let prompts = match self - .extension_manager - .list_prompts(&session.id, emit.cancel_token().clone()) + let prompts = self + .lease(session) .await - { - Ok(prompts) => prompts, - Err(error) => { - return Self::command_response( - conversation, - format!("Failed to list prompts: {}", error.message), - emit, - ) - .await; - } - }; + .list_prompts(emit.cancel_token().clone()) + .await; let found = prompts.iter().find_map(|(extension, prompts)| { prompts .iter() @@ -597,9 +577,9 @@ impl<'a> ToolExecutionOperation<'a> { .map(|(key, value)| (key.to_string(), value.trim_matches('"').to_string())) .collect(); let result = match self - .extension_manager + .lease(session) + .await .get_prompt( - &session.id, &extension, prompt_name, serde_json::to_value(arguments)?, @@ -857,7 +837,7 @@ impl Operation for ToolExecutionOperation<'_> { return Ok(prompt_parts); } - let mut extensions = lease.instructions(); + let mut extensions = lease.instructions().await; extensions.retain(|extension| extension.name != crate::skills::EXTENSION_NAME); if extensions.is_empty() { return Ok(prompt_parts); diff --git a/crates/goose/src/agents/state_machine/tests/agent_reply.rs b/crates/goose/src/agents/state_machine/tests/agent_reply.rs index bd94f10bc..1ca78a00f 100644 --- a/crates/goose/src/agents/state_machine/tests/agent_reply.rs +++ b/crates/goose/src/agents/state_machine/tests/agent_reply.rs @@ -91,7 +91,6 @@ async fn agent_with_calculator() -> Result<( .extension_manager .add_client( calculator_config(), - Some(temp_dir.path().to_path_buf()), calculator.clone(), calculator.get_info().cloned(), ) @@ -249,7 +248,6 @@ async fn state_machine_confirmation_through_agent_resumes_tool_call() -> Result< .extension_manager .add_client( calculator_config(), - Some(new_working_dir.path().to_path_buf()), replacement.clone(), replacement.get_info().cloned(), ) diff --git a/crates/goose/src/agents/state_machine/tests/pipeline.rs b/crates/goose/src/agents/state_machine/tests/pipeline.rs index bcb3a32db..13cff42b4 100644 --- a/crates/goose/src/agents/state_machine/tests/pipeline.rs +++ b/crates/goose/src/agents/state_machine/tests/pipeline.rs @@ -871,7 +871,6 @@ async fn build_test_pipeline( extension_manager .add_client( extension, - Some(session.working_dir.clone()), calculator.clone(), calculator.get_info().cloned(), ) diff --git a/crates/goose/src/goose_apps/app.rs b/crates/goose/src/goose_apps/app.rs index 8009da6bd..5ec48c919 100644 --- a/crates/goose/src/goose_apps/app.rs +++ b/crates/goose/src/goose_apps/app.rs @@ -1,5 +1,4 @@ -use crate::agents::ExtensionManager; -use rmcp::model::ErrorData; +use crate::agents::extension_manager::ExtensionLease; use serde::{Deserialize, Serialize}; use tokio_util::sync::CancellationToken; use tracing::warn; @@ -209,22 +208,12 @@ impl GooseApp { } } -pub async fn fetch_mcp_apps( - extension_manager: &ExtensionManager, - session_id: &str, -) -> Result, ErrorData> { +pub async fn fetch_mcp_apps(lease: &ExtensionLease) -> Vec { let mut apps = Vec::new(); - let ui_resources = extension_manager.get_ui_resources(session_id).await?; - - for (extension_name, resource) in ui_resources { - match extension_manager - .read_resource( - session_id, - &resource.uri, - &extension_name, - CancellationToken::default(), - ) + for (extension_name, resource) in lease.ui_resources().await { + match lease + .read_resource(&resource.uri, &extension_name, CancellationToken::default()) .await { Ok(read_result) => { @@ -309,5 +298,5 @@ pub async fn fetch_mcp_apps( } } - Ok(apps) + apps } diff --git a/crates/goose/src/skills/client.rs b/crates/goose/src/skills/client.rs index 1f321d309..c9c4e83c9 100644 --- a/crates/goose/src/skills/client.rs +++ b/crates/goose/src/skills/client.rs @@ -1,6 +1,5 @@ use super::discover_skills_with_config; use super::loaded_skill_context_with_args; -use crate::agents::extension::PlatformExtensionContext; use crate::agents::mcp_client::{Error, McpClientTrait}; use crate::agents::ToolCallContext; use crate::config::Config; @@ -18,30 +17,24 @@ pub static EXTENSION_NAME: &str = "skills"; pub struct SkillsClient { info: InitializeResult, - working_dir: PathBuf, exclude_builtin_skills: bool, config: &'static Config, } -impl SkillsClient { - pub fn new(context: PlatformExtensionContext) -> anyhow::Result { - let working_dir = context - .session - .as_ref() - .map(|s| s.working_dir.clone()) - .unwrap_or_else(|| std::env::current_dir().unwrap_or_default()); - +impl Default for SkillsClient { + fn default() -> Self { let info = InitializeResult::new(ServerCapabilities::builder().enable_tools().build()) .with_server_info(Implementation::new(EXTENSION_NAME, "1.0.0").with_title("Skills")); - Ok(Self { + Self { info, - working_dir, exclude_builtin_skills: false, config: Config::global(), - }) + } } +} +impl SkillsClient { /// Controls whether Goose's bundled skills are exposed by this client. /// Bundled skills are enabled by default. pub fn with_builtin_skills(mut self, enabled: bool) -> Self { @@ -55,8 +48,8 @@ impl SkillsClient { self } - fn discover_skills(&self) -> Vec { - discover_skills_with_config(Some(&self.working_dir), self.config) + fn discover_skills(&self, working_dir: &Path) -> Vec { + discover_skills_with_config(Some(working_dir), self.config) .into_iter() .filter(|skill| { !self.exclude_builtin_skills || skill.source_type != SourceType::BuiltinSkill @@ -111,7 +104,7 @@ impl McpClientTrait for SkillsClient { async fn call_tool( &self, - _ctx: &ToolCallContext, + ctx: &ToolCallContext, name: &str, arguments: Option, _cancellation_token: CancellationToken, @@ -139,7 +132,11 @@ impl McpClientTrait for SkillsClient { .and_then(|args| args.get("args")) .and_then(|v| v.as_str()); - let skills = self.discover_skills(); + let working_dir = ctx + .working_dir + .clone() + .unwrap_or_else(|| std::env::current_dir().unwrap_or_default()); + let skills = self.discover_skills(&working_dir); if let Some(skill) = skills.iter().find(|s| s.name == skill_name) { return match loaded_skill_context_with_args(skill, args) { @@ -243,8 +240,8 @@ impl McpClientTrait for SkillsClient { Some(&self.info) } - fn get_instructions(&self) -> Option { - let sources = self.discover_skills(); + async fn get_instructions(&self, _session_id: &str, working_dir: &Path) -> Option { + let sources = self.discover_skills(working_dir); let mut skills: Vec<&SourceEntry> = sources .iter() .filter(|s| { @@ -278,7 +275,6 @@ mod tests { use crate::config::Config; use std::collections::HashMap; use std::fs; - use std::sync::Arc; use tempfile::TempDir; fn write_plugin_skill( @@ -326,21 +322,9 @@ mod tests { )]), ) .unwrap(); - let session = Arc::new(crate::session::Session { - working_dir: project.to_path_buf(), - ..crate::session::Session::default() - }); - SkillsClient::new(PlatformExtensionContext { - extension_manager: None, - provider: Arc::new(tokio::sync::Mutex::new(None)), - session_manager: Arc::new(crate::session::SessionManager::instance()), - scheduler: None, - session: Some(session), - use_login_shell_path: false, - }) - .unwrap() - .with_builtin_skills(false) - .with_config(config) + SkillsClient::default() + .with_builtin_skills(false) + .with_config(config) } fn result_text(result: &CallToolResult) -> &str { @@ -364,10 +348,12 @@ mod tests { let client = test_client(project.path(), "disabled-plugin", false); assert!(client - .get_instructions() + .get_instructions("test", project.path()) + .await .is_none_or(|instructions| !instructions.contains("disabled-plugin-skill"))); - let ctx = ToolCallContext::new("test".to_string(), None, None); + let ctx = + ToolCallContext::new("test".to_string(), Some(project.path().to_path_buf()), None); let args = serde_json::from_value(serde_json::json!({ "name": "disabled-plugin-skill" })) @@ -404,13 +390,17 @@ mod tests { write_open_plugin_manifest(project.path(), "enabled-plugin"); let client = test_client(project.path(), "enabled-plugin", true); - let instructions = client.get_instructions().unwrap(); + let instructions = client + .get_instructions("test", project.path()) + .await + .unwrap(); assert!(instructions.contains("enabled-plugin-skill")); assert!(instructions.contains("Enabled plugin metadata")); assert!(instructions.contains("custom-plugin-skill")); assert!(instructions.contains("Custom plugin metadata")); - let ctx = ToolCallContext::new("test".to_string(), None, None); + let ctx = + ToolCallContext::new("test".to_string(), Some(project.path().to_path_buf()), None); let args = serde_json::from_value(serde_json::json!({ "name": "custom-plugin-skill" })) @@ -447,7 +437,8 @@ mod tests { std::os::unix::fs::symlink(&external_plugin, &plugin_link).unwrap(); let client = test_client(project.path(), "symlinked-plugin", true); - let ctx = ToolCallContext::new("test".to_string(), None, None); + let ctx = + ToolCallContext::new("test".to_string(), Some(project.path().to_path_buf()), None); let args = serde_json::from_value(serde_json::json!({ "name": "symlinked-skill/guide.md" })) @@ -474,27 +465,18 @@ mod tests { fs::create_dir(skill_dir.join("nested")).unwrap(); fs::write(skill_dir.join("nested/guide.md"), "Nested guidance.").unwrap(); - let session = std::sync::Arc::new(crate::session::Session { - working_dir: temp_dir.path().to_path_buf(), - ..crate::session::Session::default() - }); - let client = SkillsClient::new(PlatformExtensionContext { - extension_manager: None, - provider: Arc::new(tokio::sync::Mutex::new(None)), - session_manager: Arc::new(crate::session::SessionManager::instance()), - scheduler: None, - session: Some(session), - use_login_shell_path: false, - }) - .unwrap() - .with_builtin_skills(false); + let client = SkillsClient::default().with_builtin_skills(false); assert!(client - .discover_skills() + .discover_skills(temp_dir.path()) .iter() .all(|skill| skill.source_type != SourceType::BuiltinSkill)); - let ctx = ToolCallContext::new("test".to_string(), None, None); + let ctx = ToolCallContext::new( + "test".to_string(), + Some(temp_dir.path().to_path_buf()), + None, + ); let args: JsonObject = serde_json::from_value(serde_json::json!({"name": "my-skill"})).unwrap(); let result = client @@ -528,15 +510,7 @@ mod tests { #[tokio::test] async fn test_load_skill_not_found_returns_error() { - let client = SkillsClient::new(PlatformExtensionContext { - extension_manager: None, - provider: Arc::new(tokio::sync::Mutex::new(None)), - session_manager: Arc::new(crate::session::SessionManager::instance()), - scheduler: None, - session: None, - use_login_shell_path: false, - }) - .unwrap(); + let client = SkillsClient::default(); let ctx = ToolCallContext::new("test".to_string(), None, None); let args: JsonObject = diff --git a/crates/goose/tests/mcp_integration_test.rs b/crates/goose/tests/mcp_integration_test.rs index e430c40e9..937f64d08 100644 --- a/crates/goose/tests/mcp_integration_test.rs +++ b/crates/goose/tests/mcp_integration_test.rs @@ -557,6 +557,14 @@ async fn extension_lifecycle_across_real_transports(stdio_version: ProtocolVersi assert!(load_leased_skill(&after_move) .await .contains("new workspace")); + + // `session` still names the old directory; the add follows the stored one. + fx.add(&session, &stdio).await; + let re_added = fx + .resolve(&moved_session, std::slice::from_ref(&stdio)) + .await; + let re_added_stdio = inspect_context(&re_added, "fixture_stdio__inspect_context").await; + assert_eq!(re_added_stdio.roots, after_stdio.roots); let retained_http = inspect_context(&before_move, "fixture_http__inspect_context").await; let retained_stdio = inspect_context(&before_move, "fixture_stdio__inspect_context").await; let old_root = url::Url::from_file_path(&session.working_dir) @@ -928,7 +936,13 @@ async fn test_replayed_session( Some("test-id".to_string()), ); let result = extension_manager - .dispatch_tool_call(&ctx, tool_call, CancellationToken::default()) + .current_lease(&ctx.session_id, ctx.working_dir.as_deref()) + .await + .call( + tool_call, + CallRequest::from(&ctx), + CancellationToken::default(), + ) .await; let tool_result = result?; diff --git a/crates/goose/tests/providers.rs b/crates/goose/tests/providers.rs index c6402b2d3..4875c4d1d 100644 --- a/crates/goose/tests/providers.rs +++ b/crates/goose/tests/providers.rs @@ -2,6 +2,7 @@ use anyhow::Result; use dotenvy::dotenv; use futures::StreamExt; use goose::acp::ACP_CURRENT_MODEL; +use goose::agents::extension_manager::CallRequest; use goose::agents::{Agent, AgentConfig, AgentEvent, GoosePlatform, PromptManager, SessionConfig}; use goose::config::{ExtensionConfig, GooseMode, PermissionManager}; use goose::conversation::message::{ActionRequiredData, Message, MessageContent}; @@ -306,18 +307,13 @@ impl ProviderFixture { prompt: &str, model_config: Option, ) -> Result { - let tools = self + let lease = self .agent .extension_manager - .get_prefixed_tools(&self.session_id, None) - .await - .unwrap(); - - let info = self - .agent - .extension_manager - .get_extensions_info(std::path::Path::new(".")) + .current_lease(&self.session_id, None) .await; + let tools = lease.tools().await; + let info = lease.instructions().await; let system = PromptManager::new() .builder() .with_extensions(info.into_iter()) @@ -363,7 +359,9 @@ impl ProviderFixture { let result = self .agent .extension_manager - .dispatch_tool_call(&ctx, params, CancellationToken::new()) + .current_lease(&ctx.session_id, ctx.working_dir.as_deref()) + .await + .call(params, CallRequest::from(&ctx), CancellationToken::new()) .await .unwrap() .result