use super::discover_skills; use crate::agents::extension::PlatformExtensionContext; use crate::agents::mcp_client::{Error, McpClientTrait}; use crate::agents::ToolCallContext; use async_trait::async_trait; use goose_sdk::custom_requests::{SourceEntry, SourceType}; use rmcp::model::{ CallToolResult, Content, Implementation, InitializeResult, JsonObject, ListToolsResult, ServerCapabilities, ServerNotification, Tool, }; use std::path::{Path, PathBuf}; use tokio::sync::mpsc; use tokio_util::sync::CancellationToken; pub static EXTENSION_NAME: &str = "skills"; pub struct SkillsClient { info: InitializeResult, working_dir: PathBuf, } 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()); let mut instructions = String::new(); if context.session.is_some() { let sources = discover_skills(Some(&working_dir)); let mut skills: Vec<&SourceEntry> = sources .iter() .filter(|s| { s.source_type == SourceType::Skill || s.source_type == SourceType::BuiltinSkill }) .collect(); skills.sort_by(|a, b| (&a.name, &a.directory).cmp(&(&b.name, &b.directory))); if !skills.is_empty() { instructions.push_str( "\n\nYou have these skills at your disposal, when it is clear they can help you solve a problem or you are asked to use them:", ); for skill in &skills { instructions.push_str(&format!("\n• {} - {}", skill.name, skill.description)); } } } let info = InitializeResult::new(ServerCapabilities::builder().enable_tools().build()) .with_server_info(Implementation::new(EXTENSION_NAME, "1.0.0").with_title("Skills")) .with_instructions(instructions); Ok(Self { info, working_dir }) } } #[async_trait] impl McpClientTrait for SkillsClient { async fn list_tools( &self, _session_id: &str, _next_cursor: Option, _cancellation_token: CancellationToken, ) -> Result { let schema = serde_json::json!({ "type": "object", "required": ["name"], "properties": { "name": { "type": "string", "description": "Name of the skill to load. Use \"skill-name/path\" to load a supporting file." } } }); let tool = Tool::new( "load_skill", "Load a skill's full content into your context so you can follow its instructions.\n\n\ Skills are listed in your system instructions. When you need to use one, \ load it first to get the detailed instructions.\n\n\ Examples:\n\ - load_skill(name: \"gdrive\") → Loads the gdrive skill instructions\n\ - load_skill(name: \"my-skill/template.md\") → Loads a supporting file" .to_string(), schema.as_object().unwrap().clone(), ); Ok(ListToolsResult { tools: vec![tool], next_cursor: None, meta: None, }) } async fn call_tool( &self, _ctx: &ToolCallContext, name: &str, arguments: Option, _cancellation_token: CancellationToken, ) -> Result { if name != "load_skill" { return Ok(CallToolResult::error(vec![Content::text(format!( "Unknown tool: {}", name ))])); } let skill_name = arguments .as_ref() .and_then(|args| args.get("name")) .and_then(|v| v.as_str()) .unwrap_or(""); if skill_name.is_empty() { return Ok(CallToolResult::error(vec![Content::text( "Missing required parameter: name", )])); } let skills = discover_skills(Some(&self.working_dir)); if let Some(skill) = skills.iter().find(|s| s.name == skill_name) { let mut output = format!( "# Loaded Skill: {} ({})\n\n{}\n", skill.name, skill.source_type, skill.to_load_text() ); if !skill.supporting_files.is_empty() { let skill_dir = Path::new(&skill.directory); output.push_str(&format!( "\n## Supporting Files\n\nSkill directory: {}\n\n", skill.directory )); for file in &skill.supporting_files { if let Ok(relative) = Path::new(file).strip_prefix(skill_dir) { let rel_str = relative.to_string_lossy().replace('\\', "/"); output.push_str(&format!( "- {} → load_skill(name: \"{}/{}\")\n", rel_str, skill.name, rel_str )); } } } output.push_str("\n---\nThis knowledge is now available in your context."); return Ok(CallToolResult::success(vec![Content::text(output)])); } if let Some((parent_skill_name, raw_relative_path)) = skill_name.split_once('/') { let relative_path = raw_relative_path.replace('\\', "/"); if let Some(skill) = skills.iter().find(|s| { s.name == parent_skill_name && matches!(s.source_type, SourceType::Skill | SourceType::BuiltinSkill) }) { let skill_dir = PathBuf::from(&skill.directory); let canonical_skill_dir = skill_dir .canonicalize() .unwrap_or_else(|_| skill_dir.clone()); for file_path in &skill.supporting_files { let file_path_buf = Path::new(file_path); let Ok(rel) = file_path_buf.strip_prefix(&skill_dir) else { continue; }; if rel.to_string_lossy().replace('\\', "/") != relative_path { continue; } return Ok(match file_path_buf.canonicalize() { Ok(canonical) if canonical.starts_with(&canonical_skill_dir) => { match std::fs::read_to_string(&canonical) { Ok(content) => { CallToolResult::success(vec![Content::text(format!( "# Loaded: {}\n\n{}\n\n---\nFile loaded into context.", skill_name, content ))]) } Err(e) => CallToolResult::error(vec![Content::text(format!( "Failed to read '{}': {}", skill_name, e ))]), } } Ok(_) => CallToolResult::error(vec![Content::text(format!( "Refusing to load '{}': resolves outside the skill directory", skill_name ))]), Err(e) => CallToolResult::error(vec![Content::text(format!( "Failed to resolve '{}': {}", skill_name, e ))]), }); } let available: Vec = skill .supporting_files .iter() .filter_map(|f| { Path::new(f) .strip_prefix(&skill_dir) .ok() .map(|r| r.to_string_lossy().replace('\\', "/")) }) .take(10) .collect(); return Ok(if available.is_empty() { CallToolResult::error(vec![Content::text(format!( "Skill '{}' has no supporting files.", skill.name ))]) } else { CallToolResult::error(vec![Content::text(format!( "File '{}' not found. Available: {}", skill_name, available.join(", ") ))]) }); } } let suggestions: Vec<&str> = skills .iter() .filter(|s| { s.name.to_lowercase().contains(&skill_name.to_lowercase()) || skill_name.to_lowercase().contains(&s.name.to_lowercase()) }) .take(3) .map(|s| s.name.as_str()) .collect(); Ok(if suggestions.is_empty() { CallToolResult::error(vec![Content::text(format!( "Skill '{}' not found.", skill_name ))]) } else { CallToolResult::error(vec![Content::text(format!( "Skill '{}' not found. Did you mean: {}?", skill_name, suggestions.join(", ") ))]) }) } fn get_info(&self) -> Option<&InitializeResult> { Some(&self.info) } async fn subscribe(&self) -> mpsc::Receiver { let (_tx, rx) = mpsc::channel(1); rx } } #[cfg(test)] mod tests { use super::*; use std::fs; use std::sync::Arc; use tempfile::TempDir; #[tokio::test] async fn test_load_skill_from_filesystem() { let temp_dir = TempDir::new().unwrap(); let skill_dir = temp_dir.path().join(".goose/skills/my-skill"); fs::create_dir_all(&skill_dir).unwrap(); fs::write( skill_dir.join("SKILL.md"), "---\nname: my-skill\ndescription: A test skill\n---\nDo the thing.", ) .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, session_manager: Arc::new(crate::session::SessionManager::instance()), session: Some(session), }) .unwrap(); let ctx = ToolCallContext::new("test".to_string(), None, None); let args: JsonObject = serde_json::from_value(serde_json::json!({"name": "my-skill"})).unwrap(); let result = client .call_tool(&ctx, "load_skill", Some(args), CancellationToken::new()) .await .unwrap(); assert!(!result.is_error.unwrap_or(false)); let text = match &result.content[0].raw { rmcp::model::RawContent::Text(t) => &t.text, _ => panic!("expected text"), }; assert!(text.contains("my-skill")); assert!(text.contains("Do the thing")); } #[tokio::test] async fn test_load_skill_not_found_returns_error() { let client = SkillsClient::new(PlatformExtensionContext { extension_manager: None, session_manager: Arc::new(crate::session::SessionManager::instance()), session: None, }) .unwrap(); let ctx = ToolCallContext::new("test".to_string(), None, None); let args: JsonObject = serde_json::from_value(serde_json::json!({"name": "nonexistent"})).unwrap(); let result = client .call_tool(&ctx, "load_skill", Some(args), CancellationToken::new()) .await .unwrap(); assert!(result.is_error.unwrap_or(false)); } }