🚀 The fast, Pythonic way to build MCP servers and clients.
Add experimental Skills discovery to SkillsDirectoryProvider (#5704)
nate nowack9921d5eaa06a
diff --git a/docs/docs.json b/docs/docs.jsonindex 1b59476f0..f7f7073c9 100644--- a/docs/docs.json+++ b/docs/docs.json@@ -138,6 +138,7 @@"servers/providers/filesystem","servers/providers/proxy","servers/providers/skills",+ "servers/providers/experimental-skills","servers/composition","servers/providers/custom"]diff --git a/docs/servers/middleware.mdx b/docs/servers/middleware.mdxindex 6cc2f6eec..3cf6ffd27 100644--- a/docs/servers/middleware.mdx+++ b/docs/servers/middleware.mdx@@ -710,6 +710,22 @@ class AuthMiddleware(Middleware):Do not return error values or skip `call_next()` to indicate errors—raise exceptions for proper error propagation.+### Authorizing Resource Access++To restrict which resources a caller can read, implement `check_resource_access` rather than `on_read_resource`. The default `on_read_resource` calls it before every read, and features that describe resources without reading them, such as [Skills discovery](/servers/providers/experimental-skills), call it too, so a resource the caller cannot read is not advertised either. Raise `AuthorizationError` to deny access.++```python+from fastmcp.exceptions import AuthorizationError+from fastmcp.server.middleware import Middleware, MiddlewareContext++class InternalResourceGuard(Middleware):+ async def check_resource_access(self, context: MiddlewareContext):+ if str(context.message.uri).startswith("internal://"):+ raise AuthorizationError("Access denied")+```++If you also override `on_read_resource`, call `super().on_read_resource(context, call_next)` so the check still runs. `AuthMiddleware` implements this hook for its resource checks.+### Modifying RequestsChange the message before passing it down the chain.diff --git a/docs/servers/providers/experimental-skills.mdx b/docs/servers/providers/experimental-skills.mdxnew file mode 100644index 000000000..28ce4503d--- /dev/null+++ b/docs/servers/providers/experimental-skills.mdx@@ -0,0 +1,82 @@+---+title: Experimental Skills Extension+sidebarTitle: Skills Extension (Experimental)+description: Publish filesystem skills through standard MCP skills discovery+icon: flask+---++The existing `SkillsDirectoryProvider` can opt into experimental Skills discovery, letting clients discover filesystem skills through `skills/list` and `skills/get`, with frontmatter and a complete file manifest. Files remain ordinary MCP resources, readable through `resources/read`.++<Warning>+This API is experimental and may change without a deprecation period. It builds on the [MCP Skills extension](https://github.com/modelcontextprotocol/ext-skills/blob/main/specification/stable/skills.mdx). Directory reads, host-side activation, approval, installation, and execution are not implemented.+</Warning>++## Publish skills++Set `experimental_skills=True` on `SkillsDirectoryProvider`, register it directly on your server, and register `SkillsExtension` with the same provider instance. The configured directory contains skill directories; each skill needs a UTF-8 `SKILL.md` with valid Agent Skills frontmatter.++```python+from fastmcp import FastMCP+from fastmcp.skills.extension import SkillsExtension+from fastmcp.server.providers.skills import SkillsDirectoryProvider++mcp = FastMCP("Skills")+skills = SkillsDirectoryProvider("./skills", experimental_skills=True)+mcp.add_provider(skills)+mcp.add_extension(SkillsExtension(providers=[skills]))++if __name__ == "__main__":+ mcp.run(transport="http")+```++For example, `skills/review/SKILL.md` can contain:++```markdown+---+name: review+description: Review a code change for correctness and compatibility.+---++Read the changed code and verify the behavior it promises.+```++Its URI is `skill://review/SKILL.md`. A nested skill at `skills/team/review/SKILL.md` uses `skill://team/review/SKILL.md`. Parent manifests include all supporting files, including nested skills; each nested skill also has its own discovery entry.++The default `supporting_files="template"` exposes the main files and existing synthetic `_manifest` entries as resources and supporting files through resource templates. Use `supporting_files="resources"` to include each supporting file in `resources/list`.++## Discover and read++Explicitly enable the typed client extension and use a modern protocol connection. Listing retrieves metadata; read only the files you need.++```python+from fastmcp import Client+from fastmcp.skills import SkillsClientExtension++async def inspect_skills() -> None:+ async with Client(+ "http://localhost:8000/mcp",+ mode="auto",+ extensions=[SkillsClientExtension()],+ ) as client:+ entries = await client.list_skills()+ for entry in entries:+ print(entry.uri, entry.frontmatter.description)+```++`client.get_skill(uri)` refreshes one entry. Each static manifest includes the URI, byte size, and SHA-256 digest of every file. A host must verify resource contents against those records before using them, preserve the originating server's identity, and apply the extension's approval rules. The typed client methods transport entries; they do not activate or approve skills.++## Validation and updates++Listing scans the directories and hashes their current bytes. Looking up a skill by URI hashes only that skill; resource reads resolve their path directly without scanning the skill collection. Reads remain live, preserving CRLF newlines and binary content. If a file changes between discovery and reading, the host detects the mismatch and refreshes the entry. This is a point-in-time manifest, not an atomic filesystem snapshot.++Malformed skills are omitted with a warning. Duplicate root-relative skill paths are all omitted. Frontmatter must have unique string keys and JSON-compatible values; timestamps, binary scalars, non-finite numbers, and YAML aliases are rejected. Skill roots and their contents must not be symbolic links. Skills over the extension's limits of 512 files or 16 MiB in total are omitted. Every file in a skill directory is published, including hidden files, so keep version control directories and editor files out of skill roots.++The entire entry is omitted when any supporting resource or template is unavailable to the caller or resolves to a different backing file. Resource reads claimed by the extension bypass `ResponseCachingMiddleware`, so refreshing a manifest cannot leave the host repeatedly receiving old cached bytes.++## Supported composition++Use directly registered providers with `experimental_skills=True`. Server and provider transforms, namespacing, mounted skill sources, and proxies are not supported. Resource authorization uses `Middleware.check_resource_access`, the policy hook also called by the default `on_read_resource`. `AuthMiddleware` implements this hook, including transport handling and scope checks. Custom resource authorization should implement this hook; custom `on_read_resource` overrides must call `super()` to apply it. Arbitrary restrictions or content changes in other middleware hooks cannot be inferred by discovery and are unsupported unless the middleware keeps the skill metadata consistent.++Without `experimental_skills=True`, the [Skills Provider](/servers/providers/skills) keeps its existing behavior, including permissive frontmatter, synthetic `_manifest` resources, first-root duplicate precedence, and the `reload` setting. Opting in enables strict validation, nested skill identities, duplicate rejection, and live byte-preserving reads. The same `SkillProvider` resource implementation serves both modes, including the existing synthetic `_manifest`. Strict frontmatter validation only determines eligibility for `skills/list` and `skills/get`; files without valid frontmatter remain readable as ordinary resources. Experimental resources use generic descriptions without parsing the main file, so malformed frontmatter or non-UTF-8 bytes cannot prevent resource listing or manifest reads. Author-provided descriptions remain available in valid Skills discovery entries. The main file must be `SKILL.md`. Experimental reads are always live, regardless of `reload`.++Removing the extension registration disables standard skills discovery while the provider continues serving resources in its selected mode.diff --git a/docs/servers/providers/skills.mdx b/docs/servers/providers/skills.mdxindex 69b486cf8..e28e0e6bd 100644--- a/docs/servers/providers/skills.mdx+++ b/docs/servers/providers/skills.mdx@@ -11,6 +11,8 @@ import { VersionBadge } from '/snippets/version-badge.mdx'Agent skills are directories containing instructions and supporting files that teach an AI assistant how to perform specific tasks. Tools like Claude Code, Cursor, and VS Code Copilot each have their own skills directories where users can add custom capabilities. The Skills Provider exposes these skill directories as MCP resources, making skills discoverable and shareable across different AI tools and clients.+To opt into standard MCP `skills/list` and `skills/get` discovery, see [Experimental Skills Extension](/servers/providers/experimental-skills). The experimental option is disabled by default.+## Why Skills as ResourcesSkills live in platform-specific directories (`~/.claude/skills/`, `~/.cursor/skills/`, etc.) and typically contain a main instruction file plus supporting reference materials. When you want to share skills between tools or access them from a custom client, you need a way to discover and retrieve these files programmatically.diff --git a/fastmcp_slim/fastmcp/server/extensions.py b/fastmcp_slim/fastmcp/server/extensions.pyindex 5ea4be6d5..462a5d036 100644--- a/fastmcp_slim/fastmcp/server/extensions.py+++ b/fastmcp_slim/fastmcp/server/extensions.py@@ -236,6 +236,10 @@ class ServerExtension:"""return {}+ def _requires_live_resource(self, uri: str) -> bool:+ """Whether an extension requires this resource to bypass response caching."""+ return False+def methods(self) -> Sequence[MethodBinding]:"""New request methods this extension serves (additive)."""return ()diff --git a/fastmcp_slim/fastmcp/server/middleware/authorization.py b/fastmcp_slim/fastmcp/server/middleware/authorization.pyindex 42f3cad81..2fd7e9219 100644--- a/fastmcp_slim/fastmcp/server/middleware/authorization.py+++ b/fastmcp_slim/fastmcp/server/middleware/authorization.py@@ -31,7 +31,7 @@ import mcp_types as mtfrom fastmcp.exceptions import AuthorizationError, InsufficientScopeErrorfrom fastmcp.prompts.base import Prompt, PromptResult-from fastmcp.resources.base import Resource, ResourceResult+from fastmcp.resources.base import Resourcefrom fastmcp.resources.template import ResourceTemplatefrom fastmcp.server.dependencies import get_access_tokenfrom fastmcp.server.middleware.middleware import (@@ -280,17 +280,15 @@ class AuthMiddleware(Middleware):return authorized_resources- async def on_read_resource(- self,- context: MiddlewareContext[mt.ReadResourceRequestParams],- call_next: CallNext[mt.ReadResourceRequestParams, ResourceResult],- ) -> ResourceResult:- """Check auth before resource read."""+ async def check_resource_access(+ self, context: MiddlewareContext[mt.ReadResourceRequestParams]+ ) -> None:+ """Apply the resource policy shared by reads and extension discovery."""# STDIO has no auth concept, skip enforcementfrom fastmcp.server.context import _current_transportif _current_transport.get() == "stdio":- return await call_next(context)+ return# Get the resource being readuri = context.message.uri@@ -339,8 +337,6 @@ class AuthMiddleware(Middleware):f"Authorization failed for resource '{uri}': insufficient permissions")- return await call_next(context)-async def on_list_resource_templates(self,context: MiddlewareContext[mt.ListResourceTemplatesRequest],diff --git a/fastmcp_slim/fastmcp/server/middleware/caching.py b/fastmcp_slim/fastmcp/server/middleware/caching.pyindex a0258cdea..1b43da59e 100644--- a/fastmcp_slim/fastmcp/server/middleware/caching.py+++ b/fastmcp_slim/fastmcp/server/middleware/caching.py@@ -532,6 +532,14 @@ class ResponseCachingMiddleware(Middleware):if _is_continuation_leg(context):return await call_next(context)+ if (+ context.fastmcp_context is not None+ and context.fastmcp_context.fastmcp._requires_live_resource(+ str(context.message.uri)+ )+ ):+ return await call_next(context)+cache_key: str = _make_read_resource_cache_key(msg=context.message, auth_key=_get_auth_partition_key())diff --git a/fastmcp_slim/fastmcp/server/middleware/middleware.py b/fastmcp_slim/fastmcp/server/middleware/middleware.pyindex 87a1b9914..2dc89730d 100644--- a/fastmcp_slim/fastmcp/server/middleware/middleware.py+++ b/fastmcp_slim/fastmcp/server/middleware/middleware.py@@ -243,11 +243,21 @@ class Middleware:) -> ToolResult:return await call_next(context)+ async def check_resource_access(+ self, context: MiddlewareContext[mt.ReadResourceRequestParams]+ ) -> None:+ """Authorize resource access without reading content.++ Raise AuthorizationError to deny access. Resource authorization policies+ should live here so reads and extension metadata use the same checks.+ """+async def on_read_resource(self,context: MiddlewareContext[mt.ReadResourceRequestParams],call_next: CallNext[mt.ReadResourceRequestParams, ResourceResult],) -> ResourceResult:+ await self.check_resource_access(context)return await call_next(context)async def on_get_prompt(diff --git a/fastmcp_slim/fastmcp/server/mixins/extensions.py b/fastmcp_slim/fastmcp/server/mixins/extensions.pyindex 9851af1f8..8161c38da 100644--- a/fastmcp_slim/fastmcp/server/mixins/extensions.py+++ b/fastmcp_slim/fastmcp/server/mixins/extensions.py@@ -44,6 +44,12 @@ class ExtensionsMixin:),]+ def _requires_live_resource(self: FastMCP, uri: str) -> bool:+ return any(+ extension._requires_live_resource(uri)+ for extension in self._extensions.values()+ )+def add_extension(self: FastMCP, extension: ServerExtension) -> None:"""Register a server extension (SEP-2133).diff --git a/fastmcp_slim/fastmcp/server/providers/skills/_common.py b/fastmcp_slim/fastmcp/server/providers/skills/_common.pyindex 08067cd8a..e64c85a57 100644--- a/fastmcp_slim/fastmcp/server/providers/skills/_common.py+++ b/fastmcp_slim/fastmcp/server/providers/skills/_common.py@@ -31,6 +31,14 @@ class SkillInfo:main_file: str # Name of main file (e.g., "SKILL.md")files: list[SkillFileInfo] = field(default_factory=list)frontmatter: dict[str, Any] = field(default_factory=dict)+ preserve_bytes: bool = False++ @property+ def uri_prefix(self) -> str:+ from urllib.parse import quote++ name = quote(self.name, safe="/") if self.preserve_bytes else self.name+ return f"skill://{name}/"def _parse_frontmatter_line_based(frontmatter_text: str) -> dict[str, Any]:diff --git a/fastmcp_slim/fastmcp/server/providers/skills/directory_provider.py b/fastmcp_slim/fastmcp/server/providers/skills/directory_provider.pyindex 93678abf0..c0b09fcd4 100644--- a/fastmcp_slim/fastmcp/server/providers/skills/directory_provider.py+++ b/fastmcp_slim/fastmcp/server/providers/skills/directory_provider.py@@ -2,16 +2,32 @@from __future__ import annotations+from collections import Counterfrom collections.abc import Sequencefrom pathlib import Path-from typing import Literal+from typing import Any, Literal+from urllib.parse import quote, unquote-from mcp.shared.path_security import PathEscapeError+import yaml+from anyio.to_thread import run_sync+from mcp.server.context import ServerRequestContext+from mcp.shared.path_security import PathEscapeError, safe_join+from fastmcp.exceptions import AuthorizationErrorfrom fastmcp.resources.base import Resourcefrom fastmcp.resources.template import ResourceTemplate+from fastmcp.server.dependencies import get_contextfrom fastmcp.server.providers.aggregate import AggregateProvider-from fastmcp.server.providers.skills.skill_provider import SkillProvider+from fastmcp.server.providers.skills._common import SkillInfo, scan_skill_files+from fastmcp.server.providers.skills.skill_provider import (+ SkillFileResource,+ SkillFileTemplate,+ SkillProvider,+ SkillResource,+)+from fastmcp.skills._resources import is_skill_file+from fastmcp.skills._snapshot import Snapshot, snapshot+from fastmcp.skills.models import Skillfrom fastmcp.utilities.logging import get_loggerfrom fastmcp.utilities.versions import VersionSpec@@ -29,6 +45,8 @@ class SkillsDirectoryProvider(AggregateProvider):Args:roots: Root directory(ies) containing skill folders. Can be a single pathor a sequence of paths.+ experimental_skills: Opt into experimental SEP-2640 discovery, strict+ manifests, nested skills, and live byte-preserving reads. Defaults to False.reload: If True, re-discover skills on each request. Defaults to False.main_file_name: Name of the main skill file. Defaults to "SKILL.md".supporting_files: How supporting files are exposed in child SkillProviders:@@ -60,20 +78,28 @@ class SkillsDirectoryProvider(AggregateProvider):reload: bool = False,main_file_name: str = "SKILL.md",supporting_files: Literal["template", "resources"] = "template",+ *,+ experimental_skills: bool = False,) -> None:super().__init__()# Normalize to sequence: single path becomes listif isinstance(roots, (str, Path)):roots = [roots]- self._roots = [Path(r).resolve() for r in roots]+ self._experimental_skills = experimental_skills+ if experimental_skills and main_file_name != "SKILL.md":+ raise ValueError("experimental_skills requires main_file_name='SKILL.md'")+ self._roots = [+ Path(r).absolute() if experimental_skills else Path(r).resolve()+ for r in roots+ ]self._reload = reloadself._main_file_name = main_file_nameself._supporting_files = supporting_filesself._discovered = False- # Discover skills at init- self._discover_skills()+ if not experimental_skills:+ self._discover_skills()def _discover_skills(self) -> None:"""Scan root directories and create SkillProvider per valid skill folder."""@@ -144,22 +170,30 @@ class SkillsDirectoryProvider(AggregateProvider):# Override list methods to support reloadasync def _list_resources(self) -> Sequence[Resource]:+ if self._experimental_skills:+ return await self._protocol_list_resources()await self._ensure_discovered()return await super()._list_resources()async def _list_resource_templates(self) -> Sequence[ResourceTemplate]:+ if self._experimental_skills:+ return await self._protocol_list_resource_templates()await self._ensure_discovered()return await super()._list_resource_templates()async def _get_resource(self, uri: str, version: VersionSpec | None = None) -> Resource | None:+ if self._experimental_skills:+ return await self._protocol_get_resource(uri, version)await self._ensure_discovered()return await super()._get_resource(uri, version)async def _get_resource_template(self, uri: str, version: VersionSpec | None = None) -> ResourceTemplate | None:+ if self._experimental_skills:+ return await self._protocol_get_resource_template(uri, version)await self._ensure_discovered()return await super()._get_resource_template(uri, version)@@ -169,3 +203,252 @@ class SkillsDirectoryProvider(AggregateProvider):f"SkillsDirectoryProvider(roots={roots_repr!r}, "f"reload={self._reload}, skills={len(self.providers)})")++ def _candidate_directories(self) -> list[tuple[str, Path]]:+ candidates: list[tuple[str, Path]] = []+ for root in self._roots:+ if root.is_symlink():+ logger.warning("Ignoring symlink Skills root: %s", root)+ continue+ if not root.is_dir():+ continue+ for main in sorted(root.rglob("SKILL.md")):+ directory = main.parent+ if not main.is_file() or directory == root:+ continue+ if any(+ p.is_symlink()+ for p in (directory, *directory.parents)+ if p == root or root in p.parents+ ):+ continue+ candidates.append((directory.relative_to(root).as_posix(), directory))+ return candidates++ def _directories(self) -> list[tuple[str, Path]]:+ candidates = self._candidate_directories()+ counts = Counter(name for name, _ in candidates)+ for name, count in counts.items():+ if count > 1:+ logger.warning("Omitting duplicate skill path: %s", name)+ return [(name, path) for name, path in candidates if counts[name] == 1]++ def _snapshots(self) -> list[Snapshot]:+ snapshots: list[Snapshot] = []+ for name, path in self._directories():+ try:+ snapshots.append(snapshot(path, name))+ except (OSError, ValueError, yaml.YAMLError, RecursionError) as exc:+ logger.warning("Omitting invalid skill %s: %s", path, exc)+ return snapshots++ def _resource_provider(+ self, root: Path, name: str, relative: str | None = None+ ) -> SkillProvider:+ # Ordinary resources do not require valid skill frontmatter or UTF-8.+ # Only listings and synthetic manifests need a complete file inventory.+ info = SkillInfo(+ name=name,+ description=f"Skill: {name}",+ path=root,+ main_file="SKILL.md",+ files=[+ file+ for file in scan_skill_files(root)+ if is_skill_file(root, file.path)+ ]+ if relative is None or relative == "_manifest"+ else [],+ preserve_bytes=True,+ )+ return SkillProvider(+ root, supporting_files=self._supporting_files, _skill_info=info+ )++ async def _protocol_list_resources(self) -> Sequence[Resource]:+ resources: dict[str, Resource] = {}+ for name, root in await run_sync(self._directories):+ try:+ provider = await run_sync(self._resource_provider, root, name)+ except (OSError, ValueError):+ continue+ for resource in await provider.list_resources():+ resources[str(resource.uri)] = resource+ return list(resources.values())++ def _directories_for_name(self, name: str) -> list[Path]:+ directories = []+ for root in self._roots:+ try:+ directory = safe_join(root, name)+ except (PathEscapeError, OSError, RuntimeError):+ continue+ lexical = root / name+ if any(+ path.is_symlink()+ for path in (lexical, *lexical.parents)+ if path == root or root in path.parents+ ):+ continue+ if (directory / "SKILL.md").is_file():+ directories.append(lexical)+ return directories++ def _uri_parts(self, uri: str) -> list[str] | None:+ if not uri.startswith("skill://"):+ return None+ encoded = uri[len("skill://") :]+ decoded = unquote(encoded)+ parts = decoded.split("/")+ if (+ quote(decoded, safe="/") != encoded+ or len(parts) < 2+ or any(part in {"", ".", ".."} for part in parts)+ or "\\" in decoded+ ):+ return None+ return parts++ def _resolve_file(self, uri: str) -> tuple[Path, str] | None:+ parts = self._uri_parts(uri)+ if parts is None:+ return None+ for length in range(len(parts) - 1, 0, -1):+ directories = self._directories_for_name("/".join(parts[:length]))+ if len(directories) > 1:+ return None+ if directories:+ return directories[0], "/".join(parts[length:])+ return None++ async def _protocol_get_resource(+ self, uri: str, version: VersionSpec | None = None+ ) -> Resource | None:+ resolved = self._resolve_file(uri)+ if resolved is None:+ return None+ root, relative = resolved+ if (+ relative not in {"SKILL.md", "_manifest"}+ and self._supporting_files != "resources"+ ):+ return None+ if relative != "_manifest" and not await run_sync(+ is_skill_file, root, relative+ ):+ return None+ parts = self._uri_parts(uri)+ assert parts is not None+ name = "/".join(parts[: -len(relative.split("/"))])+ if relative == "_manifest":+ provider = await run_sync(self._resource_provider, root, name, relative)+ else:+ provider = self._resource_provider(root, name, relative)+ return await provider.get_resource(uri, version)++ async def _protocol_list_resource_templates(self) -> Sequence[ResourceTemplate]:+ if self._supporting_files != "template":+ return []+ templates: list[ResourceTemplate] = []+ for name, root in await run_sync(self._directories):+ provider = self._resource_provider(root, name, "SKILL.md")+ templates.extend(await provider.list_resource_templates())+ return templates++ async def _protocol_get_resource_template(+ self, uri: str, version: VersionSpec | None = None+ ) -> ResourceTemplate | None:+ if self._supporting_files != "template":+ return None+ resolved = self._resolve_file(uri)+ if resolved is None:+ return None+ root, relative = resolved+ if relative in {"SKILL.md", "_manifest"}:+ return None+ if not await run_sync(is_skill_file, root, relative):+ return None+ parts = self._uri_parts(uri)+ assert parts is not None+ name = "/".join(parts[: -len(relative.split("/"))])+ provider = self._resource_provider(root, name, relative)+ return await provider.get_resource_template(uri, version)++ async def _visible_entry(self, snap: Snapshot) -> Skill | None:+ server = get_context().fastmcp+ for uri, path in snap.files:+ component: Resource | ResourceTemplate | None = await server.get_resource(+ uri+ )+ if component is not None:+ if isinstance(component, SkillResource) and not component.is_manifest:+ backing = component.skill_info.path / component.skill_info.main_file+ elif isinstance(component, SkillFileResource):+ backing = component.skill_info.path / component.file_path+ else:+ return None+ if backing != path or not component.skill_info.preserve_bytes:+ return None+ else:+ component = await server.get_resource_template(uri)+ if not isinstance(component, SkillFileTemplate):+ return None+ params = component.matches(uri)+ if params is None or component.skill_info.path / params["path"] != path:+ return None+ try:+ await server._check_resource_access(uri)+ except AuthorizationError:+ return None+ return snap.entry++ async def _list_skill_entries(+ self, context: ServerRequestContext[Any, Any]+ ) -> Sequence[Skill]:+ entries = []+ for snap in await run_sync(self._snapshots):+ entry = await self._visible_entry(snap)+ if entry is not None:+ entries.append(entry)+ return entries++ async def _get_skill_entry(+ self, uri: str, context: ServerRequestContext[Any, Any]+ ) -> Skill | None:+ parts = self._uri_parts(uri)+ if parts is None or parts[-1] != "SKILL.md":+ return None+ name = "/".join(parts[:-1])+ directories = self._directories_for_name(name)+ if len(directories) != 1:+ return None+ try:+ snap = await run_sync(snapshot, directories[0], name)+ except (OSError, ValueError, yaml.YAMLError, RecursionError) as exc:+ logger.warning("Omitting invalid skill %s: %s", directories[0], exc)+ return None+ return await self._visible_entry(snap)++ def _owns_skill_resource(self, uri: str) -> bool:+ parts = self._uri_parts(uri)+ return parts is not None and any(+ self._directories_for_name("/".join(parts[:length]))+ for length in range(len(parts) - 1, 0, -1)+ )++ def _validate_skill_source(self) -> None:+ if not self._experimental_skills:+ raise ValueError("Skills discovery requires experimental_skills=True")++ async def _skill_uris(self, uri: str | None = None) -> Sequence[str]:+ self._validate_skill_source()+ if uri is None:+ candidates = await run_sync(self._candidate_directories)+ return [+ f"skill://{quote(name, safe='/')}/SKILL.md" for name, _ in candidates+ ]+ parts = self._uri_parts(uri)+ if parts is None or parts[-1] != "SKILL.md":+ return []+ directories = self._directories_for_name("/".join(parts[:-1]))+ return [uri] * len(directories)diff --git a/fastmcp_slim/fastmcp/server/providers/skills/skill_provider.py b/fastmcp_slim/fastmcp/server/providers/skills/skill_provider.pyindex a139869b8..688ac8387 100644--- a/fastmcp_slim/fastmcp/server/providers/skills/skill_provider.py+++ b/fastmcp_slim/fastmcp/server/providers/skills/skill_provider.py@@ -9,7 +9,8 @@ from pathlib import Pathfrom typing import Any, Literal, castfrom urllib.parse import quote, unquote-from mcp.shared.path_security import PathEscapeError+from anyio.to_thread import run_sync+from mcp.shared.path_security import PathEscapeError, safe_joinfrom pydantic import AnyUrlfrom fastmcp.resources.base import Resource, ResourceResult@@ -21,6 +22,7 @@ from fastmcp.server.providers.skills._common import (resolve_within,scan_skill_files,)+from fastmcp.skills._resources import read_filefrom fastmcp.utilities.logging import get_loggerfrom fastmcp.utilities.versions import VersionSpec@@ -55,6 +57,10 @@ class SkillResource(Resource):if self.is_manifest:return self._generate_manifest()else:+ if self.skill_info.preserve_bytes:+ return await run_sync(+ read_file, self.skill_info.path, self.skill_info.main_file+ )main_file_path = resolve_within(self.skill_info.path, self.skill_info.main_file)@@ -80,6 +86,8 @@ class SkillFileTemplate(ResourceTemplate):async def read(self, arguments: dict[str, Any]) -> str | bytes | ResourceResult:"""Read a file from the skill directory."""file_path = arguments.get("path", "")+ if self.skill_info.preserve_bytes:+ return await run_sync(read_file, self.skill_info.path, file_path)# Security: reject traversal, absolute-path injection, null bytes, and# symlink escapes before touching the filesystem.@@ -155,6 +163,8 @@ class SkillFileResource(Resource):async def read(self) -> str | bytes | ResourceResult:"""Read the file content."""+ if self.skill_info.preserve_bytes:+ return await run_sync(read_file, self.skill_info.path, self.file_path)# Security: reject traversal, absolute-path injection, null bytes, and# symlink escapes before touching the filesystem.try:@@ -216,15 +226,20 @@ class SkillProvider(Provider):skill_path: str | Path,main_file_name: str = "SKILL.md",supporting_files: Literal["template", "resources"] = "template",+ *,+ _skill_info: SkillInfo | None = None,) -> None:super().__init__()- self._skill_path = Path(skill_path).resolve()+ self._skill_path = (+ _skill_info.path if _skill_info is not None else Path(skill_path).resolve()+ )self._main_file_name = main_file_nameself._supporting_files = supporting_files- self._skill_info: SkillInfo | None = None+ self._skill_info = _skill_info# Load at init to catch errors early- self._load_skill()+ if self._skill_info is None:+ self._load_skill()def _load_skill(self) -> None:"""Load and parse the skill directory."""@@ -293,7 +308,7 @@ class SkillProvider(Provider):resources.append(SkillResource(uri=AnyUrl(- f"skill://{skill.name}/{quote(self._main_file_name, safe='/')}"+ f"{skill.uri_prefix}{quote(self._main_file_name, safe='/')}"),name=f"{skill.name}/{self._main_file_name}",description=skill.description,@@ -306,7 +321,7 @@ class SkillProvider(Provider):# Synthetic manifestresources.append(SkillResource(- uri=AnyUrl(f"skill://{skill.name}/_manifest"),+ uri=AnyUrl(f"{skill.uri_prefix}_manifest"),name=f"{skill.name}/_manifest",description=f"File listing for {skill.name}",mime_type="application/json",@@ -326,7 +341,7 @@ class SkillProvider(Provider):resources.append(SkillFileResource(uri=AnyUrl(- f"skill://{skill.name}/{quote(file_info.path, safe='/')}"+ f"{skill.uri_prefix}{quote(file_info.path, safe='/')}"),name=f"{skill.name}/{file_info.path}",description=f"File from {skill.name} skill",@@ -344,19 +359,10 @@ class SkillProvider(Provider):"""Get a resource by URI."""skill = self.skill_info- # Parse URI: skill://{skill_name}/{file_path}- if not uri.startswith("skill://"):- return None-- path_part = uri[len("skill://") :]- parts = path_part.split("/", 1)- if len(parts) != 2:- return None-- skill_name, file_path = parts- if skill_name != skill.name:+ if not uri.startswith(skill.uri_prefix):return None- file_path = unquote(file_path)+ skill_name = skill.name+ file_path = unquote(uri[len(skill.uri_prefix) :])if file_path == "_manifest":return SkillResource(@@ -377,18 +383,19 @@ class SkillProvider(Provider):is_manifest=False,)elif self._supporting_files == "resources":- # Check if it's a known supporting file- for file_info in skill.files:- if file_info.path == file_path:- mime_type, _ = mimetypes.guess_type(file_path)- return SkillFileResource(- uri=AnyUrl(uri),- name=f"{skill_name}/{file_path}",- description=f"File from {skill_name} skill",- mime_type=mime_type or "application/octet-stream",- skill_info=skill,- file_path=file_path,- )+ known = any(file_info.path == file_path for file_info in skill.files)+ if skill.preserve_bytes:+ known = safe_join(skill.path, file_path).is_file()+ if known:+ mime_type, _ = mimetypes.guess_type(file_path)+ return SkillFileResource(+ uri=AnyUrl(uri),+ name=f"{skill_name}/{file_path}",+ description=f"File from {skill_name} skill",+ mime_type=mime_type or "application/octet-stream",+ skill_info=skill,+ file_path=file_path,+ )return None@@ -401,7 +408,7 @@ class SkillProvider(Provider):skill = self.skill_inforeturn [SkillFileTemplate(- uri_template=f"skill://{skill.name}/{{path*}}",+ uri_template=f"{skill.uri_prefix}{{path*}}",name=f"{skill.name}_files",description=f"Access files within {skill.name}",mime_type="application/octet-stream",@@ -424,24 +431,16 @@ class SkillProvider(Provider):skill = self.skill_info- if not uri.startswith("skill://"):- return None-- path_part = uri[len("skill://") :]- parts = path_part.split("/", 1)- if len(parts) != 2:- return None-- skill_name, file_path = parts- if skill_name != skill.name:+ if not uri.startswith(skill.uri_prefix):return None+ file_path = uri[len(skill.uri_prefix) :]# Don't match known resources (main file, manifest)if file_path == "_manifest" or file_path == self._main_file_name:return Nonereturn SkillFileTemplate(- uri_template=f"skill://{skill.name}/{{path*}}",+ uri_template=f"{skill.uri_prefix}{{path*}}",name=f"{skill.name}_files",description=f"Access files within {skill.name}",mime_type="application/octet-stream",diff --git a/fastmcp_slim/fastmcp/server/server.py b/fastmcp_slim/fastmcp/server/server.pyindex 9a2a6329a..3cb0ff2d8 100644--- a/fastmcp_slim/fastmcp/server/server.py+++ b/fastmcp_slim/fastmcp/server/server.py@@ -1531,6 +1531,20 @@ class FastMCP(raise ToolError(f"Error calling tool {name!r}") from eraise ToolError(f"Error calling tool {name!r}: {e}") from e+ async def _check_resource_access(+ self, uri: str, version: VersionSpec | None = None+ ) -> None:+ async with fastmcp.server.context.Context(fastmcp=self) as ctx:+ context = MiddlewareContext(+ message=mcp_types.ReadResourceRequestParams(+ uri=uri, _meta=_version_request_meta(version)+ ),+ method="resources/read",+ fastmcp_context=ctx,+ )+ for middleware in self.middleware:+ await middleware.check_resource_access(context)+async def read_resource(self,uri: str,diff --git a/fastmcp_slim/fastmcp/skills/_resources.py b/fastmcp_slim/fastmcp/skills/_resources.pynew file mode 100644index 000000000..fa82af1d6--- /dev/null+++ b/fastmcp_slim/fastmcp/skills/_resources.py@@ -0,0 +1,44 @@+"""Byte-preserving resource reads for strict filesystem skills."""++from __future__ import annotations++import mimetypes+from contextlib import suppress+from pathlib import Path++from mcp.shared.path_security import PathEscapeError, safe_join++from fastmcp.resources.base import ResourceContent, ResourceResult+++def _has_symlink(root: Path, relative_path: str) -> bool:+ lexical_path = root / relative_path+ return root.is_symlink() or any(+ ancestor.is_symlink()+ for ancestor in (lexical_path, *lexical_path.parents)+ if ancestor == root or root in ancestor.parents+ )+++def is_skill_file(root: Path, relative_path: str) -> bool:+ """Whether `read_file` would serve this path."""+ try:+ path = safe_join(root, relative_path)+ except (PathEscapeError, OSError, RuntimeError):+ return False+ return not _has_symlink(root, relative_path) and path.is_file()+++def read_file(root: Path, relative_path: str) -> ResourceResult:+ path = safe_join(root, relative_path)+ if _has_symlink(root, relative_path):+ raise ValueError("skill files must not be symlinks")+ if not path.is_file():+ raise ValueError("skill resource must be a regular file")+ content = path.read_bytes()+ mime_type = mimetypes.guess_type(path.name)[0] or "application/octet-stream"+ value: str | bytes = content+ if mime_type.startswith("text/"):+ with suppress(UnicodeDecodeError):+ value = content.decode("utf-8")+ return ResourceResult([ResourceContent(value, mime_type=mime_type)])diff --git a/fastmcp_slim/fastmcp/skills/_snapshot.py b/fastmcp_slim/fastmcp/skills/_snapshot.pynew file mode 100644index 000000000..59d6221cb--- /dev/null+++ b/fastmcp_slim/fastmcp/skills/_snapshot.py@@ -0,0 +1,133 @@+"""Strict filesystem snapshots for experimental Skills publication."""++from __future__ import annotations++import hashlib+import math+import re+from dataclasses import dataclass+from pathlib import Path+from typing import Any+from urllib.parse import quote++import yaml+from mcp.shared.path_security import safe_join+from yaml.nodes import MappingNode++from fastmcp.skills.models import Skill, SkillFrontmatter, SkillResource++# SEP-2640 per-skill limits; servers should not serve skills that exceed them.+MAX_SKILL_RESOURCES = 512+MAX_SKILL_BYTES = 16 * 1024 * 1024+++class _FrontmatterLoader(yaml.SafeLoader):+ def compose_node(self, parent: Any, index: Any) -> Any:+ # Aliases let a few bytes expand into an arbitrarily large document.+ if self.check_event(yaml.AliasEvent):+ raise ValueError("frontmatter must not use YAML aliases")+ return super().compose_node(parent, index)++ def construct_mapping(+ self, node: MappingNode, deep: bool = False+ ) -> dict[str, Any]:+ result: dict[str, Any] = {}+ for key_node, value_node in node.value:+ key = self.construct_object(key_node, deep=deep)+ if not isinstance(key, str):+ raise ValueError("frontmatter mapping keys must be strings")+ if key in result:+ raise ValueError(f"duplicate frontmatter key: {key}")+ result[key] = self.construct_object(value_node, deep=deep)+ return result+++def _validate_json(value: Any, ancestors: set[int]) -> None:+ if value is None or type(value) in (str, bool, int):+ return+ if type(value) is float and math.isfinite(value):+ return+ if type(value) not in (dict, list):+ raise ValueError("frontmatter must contain only finite JSON values")+ if id(value) in ancestors:+ raise ValueError("frontmatter must not contain recursive aliases")+ ancestors.add(id(value))+ try:+ children = value.values() if isinstance(value, dict) else value+ for child in children:+ _validate_json(child, ancestors)+ finally:+ ancestors.remove(id(value))+++def parse_frontmatter(content: bytes) -> SkillFrontmatter:+ text = content.decode("utf-8-sig")+ match = re.match(r"\A---\r?\n(.*?)\r?\n---(?:\r?\n|\Z)", text, re.DOTALL)+ if match is None:+ raise ValueError("SKILL.md must begin with YAML frontmatter")+ value = yaml.load(match.group(1), Loader=_FrontmatterLoader) # noqa: S506 - SafeLoader subclass rejects duplicate keys+ if not isinstance(value, dict):+ raise ValueError("frontmatter must be a mapping")+ _validate_json(value, set())+ return SkillFrontmatter.model_validate(value)+++def scan_files(root: Path) -> list[Path]:+ if root.is_symlink() or not root.is_dir():+ raise ValueError("skill root must be a directory, not a symlink")+ files: list[Path] = []+ for path in sorted(root.rglob("*")):+ if path.is_symlink():+ raise ValueError(f"skill contains a symlink: {path.relative_to(root)}")+ if path.is_file():+ files.append(path)+ elif not path.is_dir():+ raise ValueError(+ f"skill contains a non-regular file: {path.relative_to(root)}"+ )+ return files+++@dataclass(frozen=True)+class Snapshot:+ entry: Skill+ files: tuple[tuple[str, Path], ...]+++def snapshot(root: Path, skill_path: str) -> Snapshot:+ paths = scan_files(root)+ main = root / "SKILL.md"+ if main not in paths:+ raise ValueError("skill must contain SKILL.md")+ if len(paths) > MAX_SKILL_RESOURCES:+ raise ValueError(f"skill has more than {MAX_SKILL_RESOURCES} files")+ if sum(path.stat().st_size for path in paths) > MAX_SKILL_BYTES:+ raise ValueError(f"skill is larger than {MAX_SKILL_BYTES} bytes")+ records: list[SkillResource] = []+ files: list[tuple[str, Path]] = []+ frontmatter: SkillFrontmatter | None = None+ for path in paths:+ safe_join(root, path.relative_to(root).as_posix())+ content = path.read_bytes()+ uri = f"skill://{quote(skill_path, safe='/')}/{quote(path.relative_to(root).as_posix(), safe='/')}"+ records.append(+ SkillResource(+ uri=uri,+ digest=f"sha256:{hashlib.sha256(content).hexdigest()}",+ size=len(content),+ )+ )+ files.append((uri, path))+ if path == main:+ frontmatter = parse_frontmatter(content)+ if scan_files(root) != paths:+ raise ValueError("skill files changed while building the manifest")+ if sum(record.size for record in records) > MAX_SKILL_BYTES:+ raise ValueError(f"skill is larger than {MAX_SKILL_BYTES} bytes")+ assert frontmatter is not None+ entry = Skill(+ uri=f"skill://{quote(skill_path, safe='/')}/SKILL.md",+ frontmatter=frontmatter,+ resources=records,+ )+ return Snapshot(entry=entry, files=tuple(files))diff --git a/fastmcp_slim/fastmcp/skills/_source.py b/fastmcp_slim/fastmcp/skills/_source.pyindex d37a1a69f..3f37a713d 100644--- a/fastmcp_slim/fastmcp/skills/_source.py+++ b/fastmcp_slim/fastmcp/skills/_source.py@@ -21,3 +21,15 @@ class _SkillSource(Protocol):async def _get_skill_entry(self, uri: str, context: ServerRequestContext[Any, Any]) -> Skill | None: ...++ def _validate_skill_source(self) -> None:+ """Reject sources that have not opted into protocol publication."""+ ...++ async def _skill_uris(self, uri: str | None = None) -> Sequence[str]:+ """Return identities before authorization/validation, preserving duplicates."""+ ...++ def _owns_skill_resource(self, uri: str) -> bool:+ """Whether manifest coherence requires this URI to be read live."""+ ...diff --git a/fastmcp_slim/fastmcp/skills/extension.py b/fastmcp_slim/fastmcp/skills/extension.pyindex c5933e238..1a491ab66 100644--- a/fastmcp_slim/fastmcp/skills/extension.py+++ b/fastmcp_slim/fastmcp/skills/extension.py@@ -11,6 +11,7 @@ from mcp.shared.exceptions import MCPErrorfrom mcp_types import INVALID_PARAMSfrom mcp_types.version import MODERN_PROTOCOL_VERSIONS+from fastmcp.server.context import Contextfrom fastmcp.server.extensions import MethodBinding, ServerExtensionfrom fastmcp.server.mixins.mcp_operations import _apply_paginationfrom fastmcp.server.providers.base import Provider@@ -70,10 +71,16 @@ class SkillsExtension(ServerExtension):f"{type(provider).__name__} is not a SkillsExtension source")+ provider._validate_skill_source()+@propertydef _sources(self) -> tuple[_SkillSource, ...]:return cast("tuple[_SkillSource, ...]", self._providers)+ def _requires_live_resource(self, uri: str) -> bool:+ """Keep manifest-backed resources coherent with current file bytes."""+ return any(source._owns_skill_resource(uri) for source in self._sources)+def methods(self) -> Sequence[MethodBinding]:return (MethodBinding(@@ -100,11 +107,13 @@ class SkillsExtension(ServerExtension):) -> ListSkillsResult:self._validate_live_configuration()- source_entries = await gather(- source._list_skill_entries(context) for source in self._sources- )+ async with Context(fastmcp=self.server):+ source_entries = await gather(+ source._list_skill_entries(context) for source in self._sources+ )+ identities = await gather(source._skill_uris() for source in self._sources)entries = [entry for group in source_entries for entry in group]- counts = Counter(entry.uri for entry in entries)+ counts = Counter(uri for group in identities for uri in group)collisions = sorted(uri for uri, count in counts.items() if count > 1)if collisions:logger.warning(@@ -127,9 +136,17 @@ class SkillsExtension(ServerExtension):) -> GetSkillResult:self._validate_live_configuration()- results = await gather(- source._get_skill_entry(params.uri, context) for source in self._sources- )+ async with Context(fastmcp=self.server):+ identities = await gather(+ source._skill_uris(params.uri) for source in self._sources+ )+ if sum(group.count(params.uri) for group in identities) != 1:+ raise MCPError(+ code=INVALID_PARAMS, message=f"Unknown skill URI: {params.uri}"+ )+ results = await gather(+ source._get_skill_entry(params.uri, context) for source in self._sources+ )matches = [entry for entry in results if entry is not None]if len(matches) != 1 or matches[0].uri != params.uri:raise MCPError(diff --git a/tests/experimental/skills/README.md b/tests/experimental/skills/README.mdnew file mode 100644index 000000000..43edee649--- /dev/null+++ b/tests/experimental/skills/README.md@@ -0,0 +1,45 @@+# Experimental Skills validation++This experiment targets the stable Skills extension at+`modelcontextprotocol/ext-skills@e083f6d` and builds on FastMCP PR #5057.+It opts the existing `SkillsDirectoryProvider` into filesystem publication and+standard discovery through `experimental_skills=True` and the single+`SkillsExtension`. It does not implement+host activation or the optional directory-read method.++The October 16 review includes the upstream schema correction adding optional+`_meta` to skill entries. The additional directory-read cache requirements do not+apply because this implementation does not advertise directory reads.++The upstream conformance runner at+`modelcontextprotocol/conformance@c37eec888e1c6ff140af79987a40008548b7cc5f`+was run against an HTTP server with a real CRLF `SKILL.md` and supporting file:++```sh+node dist/index.js server --url http://127.0.0.1:18764/mcp \+ --scenario sep-2640-skills-enumeration --spec-version 2026-07-28 --force+node dist/index.js server --url http://127.0.0.1:18764/mcp \+ --scenario sep-2640-skills-manifest --spec-version 2026-07-28 --force+node dist/index.js server --url http://127.0.0.1:18764/mcp \+ --scenario sep-2640-skills-directory --spec-version 2026-07-28 --force+```++Enumeration passed 32 checks. Manifest validation passed four checks with two+SHOULD-level warnings: resources retain their existing names (such as+`review/SKILL.md`) and FastMCP's standard `_meta.fastmcp` metadata instead of+switching to frontmatter names and the Skills-specific metadata prefix. The directory+scenario passed wire validation and skipped optional directory checks because+`directoryRead` is not advertised.++Local protocol tests cover both supporting-file publication modes, nested+skills, binary data, component and global middleware authorization, shared access+policies, additive legacy resources, URI aliases, resource shadowing, duplicate+identities, malformed frontmatter, cache refresh, and nonregular files. Snapshot+tests also verify duplicate YAML keys, recursive aliases, JSON-incompatible+values, raw byte digests, symlinks, and unreadable path rejection.++Lookup scaling tests instrument real filesystem operations in both publication+modes. Listing visits the collection twice and scans each skill twice, independent+of its number of supporting files. A single lookup scans and hashes only the+requested skill, and a resource read performs no recursive scans. The tests also+verify that a newly added skill is immediately addressable.diff --git a/tests/experimental/skills/__init__.py b/tests/experimental/skills/__init__.pynew file mode 100644index 000000000..09ddb4386--- /dev/null+++ b/tests/experimental/skills/__init__.py@@ -0,0 +1 @@+"""Tests for experimental filesystem skills."""diff --git a/tests/experimental/skills/test_lookup_scaling.py b/tests/experimental/skills/test_lookup_scaling.pynew file mode 100644index 000000000..a3d09484b--- /dev/null+++ b/tests/experimental/skills/test_lookup_scaling.py@@ -0,0 +1,78 @@+from __future__ import annotations++from pathlib import Path+from typing import Literal++import pytest++from fastmcp import Client, FastMCP+from fastmcp.server.providers.skills import SkillsDirectoryProvider+from fastmcp.skills import SkillsClientExtension+from fastmcp.skills.extension import SkillsExtension++[email protected]("mode", ["template", "resources"])+async def test_discovery_work_scales_with_requested_files(+ tmp_path: Path,+ monkeypatch: pytest.MonkeyPatch,+ mode: Literal["template", "resources"],+):+ for index in range(20):+ directory = tmp_path / f"skill-{index}"+ directory.mkdir()+ (directory / "SKILL.md").write_text(+ f"---\nname: skill-{index}\ndescription: Test skill\n---\n"+ )+ for file_index in range(4):+ (directory / f"file-{file_index}.txt").write_text("supporting file")++ scans: list[Path] = []+ reads: list[Path] = []+ original_rglob = Path.rglob+ original_read_bytes = Path.read_bytes++ def counted_rglob(path, *args, **kwargs):+ scans.append(path)+ return original_rglob(path, *args, **kwargs)++ def counted_read_bytes(path):+ reads.append(path)+ return original_read_bytes(path)++ provider = SkillsDirectoryProvider(+ tmp_path, experimental_skills=True, supporting_files=mode+ )+ server = FastMCP("Skills", providers=[provider])+ server.add_extension(SkillsExtension(providers=[provider]))+ async with Client(+ server, mode="auto", extensions=[SkillsClientExtension()]+ ) as client:+ with monkeypatch.context() as instrumentation:+ instrumentation.setattr(Path, "rglob", counted_rglob)+ instrumentation.setattr(Path, "read_bytes", counted_read_bytes)+ entries = await client.list_skills()+ assert len(entries) == 20+ assert len(scans) <= 2 + 2 * len(entries)+ assert len(reads) == 100++ scans.clear()+ reads.clear()+ entry = await client.get_skill("skill://skill-0/SKILL.md")+ assert entry.uri == "skill://skill-0/SKILL.md"+ assert len(scans) <= 2+ assert len(reads) == 5+ assert all(path.parent == tmp_path / "skill-0" for path in reads)++ scans.clear()+ contents = await client.read_resource("skill://skill-0/file-0.txt")+ assert contents[0].text == "supporting file"+ assert scans == []++ added = tmp_path / "added"+ added.mkdir()+ (added / "SKILL.md").write_text(+ "---\nname: added\ndescription: Added live\n---\n"+ )+ assert (+ await client.get_skill("skill://added/SKILL.md")+ ).frontmatter.name == "added"diff --git a/tests/experimental/skills/test_opt_in.py b/tests/experimental/skills/test_opt_in.pynew file mode 100644index 000000000..11467039f--- /dev/null+++ b/tests/experimental/skills/test_opt_in.py@@ -0,0 +1,73 @@+from pathlib import Path++import pytest++from fastmcp import Client, FastMCP+from fastmcp.server.providers.skills import SkillsDirectoryProvider+from fastmcp.skills import SkillsClientExtension+from fastmcp.skills.extension import SkillsExtension++[email protected]("explicit_default", [False, True])+async def test_default_provider_keeps_legacy_publication(+ tmp_path: Path, explicit_default: bool+):+ root = tmp_path / "review"+ root.mkdir()+ (root / "SKILL.md").write_bytes(b"# No frontmatter\r\nLoose instructions\r\n")+ kwargs = {"experimental_skills": False} if explicit_default else {}+ provider = SkillsDirectoryProvider(tmp_path, **kwargs)+ server = FastMCP("Legacy skills", providers=[provider])+ async with Client(server) as client:+ resources = await client.list_resources()+ assert {str(resource.uri) for resource in resources} == {+ "skill://review/SKILL.md",+ "skill://review/_manifest",+ }+ contents = await client.read_resource("skill://review/SKILL.md")+ assert contents[0].text == "# No frontmatter\nLoose instructions\n"+ assert client.server_capabilities is not None+ assert "io.modelcontextprotocol/skills" not in (+ client.server_capabilities.extensions or {}+ )+ with pytest.raises(ValueError, match="experimental_skills=True"):+ server.add_extension(SkillsExtension(providers=[provider]))+++def test_experimental_mode_requires_standard_main_file(tmp_path: Path):+ with pytest.raises(ValueError, match="main_file_name"):+ SkillsDirectoryProvider(+ tmp_path, main_file_name="README.md", experimental_skills=True+ )+++async def test_experimental_discovery_is_additive_to_resources(tmp_path: Path):+ directory = tmp_path / "review"+ directory.mkdir()+ (directory / "SKILL.md").write_bytes(b"# Permissive existing skill\n")+ (directory / "notes.txt").write_text("supporting content")+ provider = SkillsDirectoryProvider(tmp_path, experimental_skills=True)+ server = FastMCP("Skills", providers=[provider])+ server.add_extension(SkillsExtension(providers=[provider]))+ async with Client(+ server, mode="auto", extensions=[SkillsClientExtension()]+ ) as client:+ assert {str(resource.uri) for resource in await client.list_resources()} == {+ "skill://review/SKILL.md",+ "skill://review/_manifest",+ }+ assert (await client.read_resource("skill://review/SKILL.md"))[+ 0+ ].text == "# Permissive existing skill\n"+ assert (await client.read_resource("skill://review/notes.txt"))[+ 0+ ].text == "supporting content"+ assert (+ "notes.txt"+ in (await client.read_resource("skill://review/_manifest"))[0].text+ )+ assert await client.list_skills() == []+ (directory / "SKILL.md").write_text(+ "---\nname: review\ndescription: Review code\n---\n"+ )+ assert len(await client.list_skills()) == 1diff --git a/tests/experimental/skills/test_provider.py b/tests/experimental/skills/test_provider.pynew file mode 100644index 000000000..007161204--- /dev/null+++ b/tests/experimental/skills/test_provider.py@@ -0,0 +1,349 @@+from __future__ import annotations++import base64+import hashlib+import sys+from pathlib import Path+from typing import Literal++import pytest+from mcp.shared.exceptions import MCPError+from mcp_types import INVALID_PARAMS, BlobResourceContents, TextResourceContents++from fastmcp import Client, FastMCP+from fastmcp.exceptions import AuthorizationError+from fastmcp.server.middleware import Middleware+from fastmcp.server.middleware.caching import ResponseCachingMiddleware+from fastmcp.server.providers.skills import SkillsDirectoryProvider+from fastmcp.skills import SkillsClientExtension+from fastmcp.skills.extension import SkillsExtension++[email protected]("mode", ["template", "resources"])+async def test_filesystem_skills_round_trip(+ tmp_path: Path, mode: Literal["template", "resources"]+):+ root = tmp_path / "team" / "review"+ root.mkdir(parents=True)+ (root / "SKILL.md").write_bytes(+ b"---\r\nname: review\r\ndescription: Review changes\r\n---\r\n# Review\r\n"+ )+ (root / "notes.md").write_bytes(b"line one\r\nline two\r\n")+ (root / "image.bin").write_bytes(b"\x00\xff\r\n")+ nested = root / "child"+ nested.mkdir()+ (nested / "SKILL.md").write_text(+ "---\nname: child\ndescription: Child skill\n---\n"+ )+ provider = SkillsDirectoryProvider(+ tmp_path, experimental_skills=True, supporting_files=mode+ )+ server = FastMCP("Skills")+ server.add_provider(provider)+ server.add_extension(SkillsExtension(providers=[provider]))+ async with Client(+ server, mode="auto", extensions=[SkillsClientExtension()]+ ) as client:+ entries = await client.list_skills()+ assert [entry.uri for entry in entries] == [+ "skill://team/review/SKILL.md",+ "skill://team/review/child/SKILL.md",+ ]+ for entry in entries:+ assert await client.get_skill(entry.uri) == entry+ assert isinstance(entry.resources, list)+ for record in entry.resources:+ contents = await client.read_resource(record.uri)+ assert len(contents) == 1+ content = contents[0]+ if isinstance(content, TextResourceContents):+ data = content.text.encode()+ else:+ assert isinstance(content, BlobResourceContents)+ data = base64.b64decode(content.blob)+ assert len(data) == record.size+ assert f"sha256:{hashlib.sha256(data).hexdigest()}" == record.digest+++async def test_shadowed_supporting_file_hides_entire_skill(tmp_path: Path):+ root = tmp_path / "review"+ root.mkdir()+ (root / "SKILL.md").write_text("---\nname: review\ndescription: Review code\n---\n")+ (root / "notes.md").write_text("original")+ provider = SkillsDirectoryProvider(tmp_path, experimental_skills=True)+ server = FastMCP("Skills")+ server.add_provider(provider)+ server.add_extension(SkillsExtension(providers=[provider]))++ @server.resource("skill://review/notes.md")+ def shadow() -> str:+ return "different bytes"++ async with Client(+ server, mode="auto", extensions=[SkillsClientExtension()]+ ) as client:+ assert await client.list_skills() == []+ with pytest.raises(MCPError, match="Unknown skill URI"):+ await client.get_skill("skill://review/SKILL.md")+++async def test_cache_does_not_hide_file_changes(tmp_path: Path):+ root = tmp_path / "review"+ root.mkdir()+ (root / "SKILL.md").write_text("---\nname: review\ndescription: Review code\n---\n")+ notes = root / "notes.md"+ notes.write_text("before")+ provider = SkillsDirectoryProvider(tmp_path, experimental_skills=True)+ server = FastMCP("Skills", middleware=[ResponseCachingMiddleware()])+ server.add_provider(provider)+ server.add_extension(SkillsExtension(providers=[provider]))+ async with Client(+ server, mode="auto", extensions=[SkillsClientExtension()]+ ) as client:+ before = await client.read_resource("skill://review/notes.md")+ assert before[0].text == "before"+ notes.write_text("after")+ entry = await client.get_skill("skill://review/SKILL.md")+ after = await client.read_resource("skill://review/notes.md")+ assert after[0].text == "after"+ assert isinstance(entry.resources, list)+ record = next(+ record for record in entry.resources if record.uri.endswith("notes.md")+ )+ assert record.digest == f"sha256:{hashlib.sha256(b'after').hexdigest()}"++[email protected]("mode", ["template", "resources"])+async def test_denied_supporting_component_hides_skill(+ tmp_path: Path, mode: Literal["template", "resources"]+):+ class RestrictedProvider(SkillsDirectoryProvider):+ async def _get_resource(self, uri, version=None):+ resource = await super()._get_resource(uri, version)+ if resource is not None and uri.endswith("notes.md"):+ resource.auth = lambda context: False+ return resource++ async def _get_resource_template(self, uri, version=None):+ template = await super()._get_resource_template(uri, version)+ if template is not None:+ template.auth = lambda context: False+ return template++ root = tmp_path / "review"+ root.mkdir()+ (root / "SKILL.md").write_text("---\nname: review\ndescription: Review code\n---\n")+ (root / "notes.md").write_text("private")+ provider = RestrictedProvider(+ tmp_path, experimental_skills=True, supporting_files=mode+ )+ server = FastMCP("Skills")+ server.add_provider(provider)+ server.add_extension(SkillsExtension(providers=[provider]))+ async with Client(+ server, mode="auto", extensions=[SkillsClientExtension()]+ ) as client:+ assert await client.list_skills() == []+ with pytest.raises(MCPError, match="Unknown skill URI"):+ await client.get_skill("skill://review/SKILL.md")+++async def test_duplicate_and_malformed_skills_leave_unrelated_entries(tmp_path: Path):+ roots = [tmp_path / "one", tmp_path / "two"]+ for root in roots:+ directory = root / "review"+ directory.mkdir(parents=True)+ (directory / "SKILL.md").write_text(+ "---\nname: review\ndescription: Review code\n---\n"+ )+ good = roots[0] / "other"+ good.mkdir()+ (good / "SKILL.md").write_text(+ "---\nname: other\ndescription: Another skill\n---\n"+ )+ bad = roots[0] / "invalid"+ bad.mkdir()+ (bad / "SKILL.md").write_bytes(b"\xff")+ provider = SkillsDirectoryProvider(roots, experimental_skills=True)+ server = FastMCP("Skills")+ server.add_provider(provider)+ server.add_extension(SkillsExtension(providers=[provider]))+ async with Client(+ server, mode="auto", extensions=[SkillsClientExtension()]+ ) as client:+ assert [entry.uri for entry in await client.list_skills()] == [+ "skill://other/SKILL.md"+ ]+++async def test_denied_main_cannot_fall_back_to_template(tmp_path: Path):+ class RestrictedProvider(SkillsDirectoryProvider):+ async def _get_resource(self, uri, version=None):+ resource = await super()._get_resource(uri, version)+ if resource is not None:+ resource.auth = lambda context: False+ return resource++ root = tmp_path / "review"+ root.mkdir()+ (root / "SKILL.md").write_text(+ "---\nname: review\ndescription: Private skill\n---\nsecret"+ )+ provider = RestrictedProvider(tmp_path, experimental_skills=True)+ server = FastMCP("Skills")+ server.add_provider(provider)+ server.add_extension(SkillsExtension(providers=[provider]))+ async with Client(+ server, mode="auto", extensions=[SkillsClientExtension()]+ ) as client:+ assert await client.list_skills() == []+ with pytest.raises(MCPError):+ await client.get_skill("skill://review/SKILL.md")+ for uri in (+ "skill://review/SKILL.md",+ "skill://review/SK%49LL.md",+ "skill://review/%53KILL.md",+ "skill://review/./SKILL.md",+ "skill://review//SKILL.md",+ "skill://review/child/../SKILL.md",+ ):+ with pytest.raises(MCPError):+ await client.read_resource(uri)++[email protected]("local_duplicate", [False, True])+async def test_duplicate_identities_across_providers_are_omitted(+ tmp_path: Path, local_duplicate: bool+):+ providers = []+ for name in ("one", "two"):+ root = tmp_path / name / "review"+ root.mkdir(parents=True)+ (root / "SKILL.md").write_text(f"---\nname: review\ndescription: {name}\n---\n")+ providers.append(SkillsDirectoryProvider(root.parent, experimental_skills=True))+ if local_duplicate:+ providers[0] = SkillsDirectoryProvider(+ [tmp_path / "one", tmp_path / "one"], experimental_skills=True+ )+ server = FastMCP("Skills")+ for provider in providers:+ server.add_provider(provider)+ server.add_extension(SkillsExtension(providers=providers))+ async with Client(+ server, mode="auto", extensions=[SkillsClientExtension()]+ ) as client:+ assert await client.list_skills() == []+ with pytest.raises(MCPError, match="Unknown skill URI"):+ await client.get_skill("skill://review/SKILL.md")++[email protected]("mode", ["template", "resources"])[email protected]("deny_main", [False, True])+async def test_global_resource_authorization_hides_skill(+ tmp_path: Path, mode: Literal["template", "resources"], deny_main: bool+):+ from fastmcp.server.middleware.authorization import AuthMiddleware++ root = tmp_path / "review"+ root.mkdir()+ (root / "SKILL.md").write_text(+ "---\nname: review\ndescription: Private instructions\n---\n"+ )+ (root / "notes.md").write_text("private supporting file")+ denied = {"review/SKILL.md"} if deny_main else {"review/notes.md", "review_files"}+ provider = SkillsDirectoryProvider(+ tmp_path, supporting_files=mode, experimental_skills=True+ )+ server = FastMCP(+ "Skills",+ providers=[provider],+ middleware=[AuthMiddleware(auth=lambda ctx: ctx.component.name not in denied)],+ )+ server.add_extension(SkillsExtension(providers=[provider]))+ async with Client(+ server, mode="auto", extensions=[SkillsClientExtension()]+ ) as client:+ with pytest.raises(MCPError):+ await client.read_resource(+ "skill://review/SKILL.md" if deny_main else "skill://review/notes.md"+ )+ assert await client.list_skills() == []+ with pytest.raises(MCPError, match="Unknown skill URI"):+ await client.get_skill("skill://review/SKILL.md")+ denied.clear()+ assert len(await client.list_skills()) == 1+ assert (+ await client.get_skill("skill://review/SKILL.md")+ ).frontmatter.name == "review"++[email protected]("mode", ["template", "resources"])+async def test_shared_access_policy_controls_reads_and_skill_metadata(+ tmp_path: Path, mode+):+ blocked = {"skill://review/notes.md"}++ class ResourcePolicy(Middleware):+ async def check_resource_access(self, context):+ if str(context.message.uri) in blocked:+ raise AuthorizationError("Private supporting file")++ root = tmp_path / "review"+ root.mkdir()+ (root / "SKILL.md").write_text("---\nname: review\ndescription: Review code\n---\n")+ (root / "notes.md").write_text("private")+ provider = SkillsDirectoryProvider(+ tmp_path, experimental_skills=True, supporting_files=mode+ )+ server = FastMCP("Skills", providers=[provider], middleware=[ResourcePolicy()])+ server.add_extension(SkillsExtension(providers=[provider]))+ async with Client(+ server, mode="auto", extensions=[SkillsClientExtension()]+ ) as client:+ with pytest.raises(MCPError, match="Private supporting file"):+ await client.read_resource("skill://review/notes.md")+ assert await client.list_skills() == []+ with pytest.raises(MCPError, match="Unknown skill URI"):+ await client.get_skill("skill://review/SKILL.md")+ blocked.clear()+ assert (await client.read_resource("skill://review/notes.md"))[+ 0+ ].text == "private"+ assert len(await client.list_skills()) == 1+ assert (+ await client.get_skill("skill://review/SKILL.md")+ ).frontmatter.name == "review"+++async def test_unserved_supporting_file_is_invalid_params(tmp_path: Path):+ root = tmp_path / "review"+ root.mkdir()+ (root / "SKILL.md").write_text("---\nname: review\ndescription: Review\n---\n")+ server = FastMCP("Skills")+ server.add_provider(SkillsDirectoryProvider(tmp_path, experimental_skills=True))+ async with Client(server) as client:+ with pytest.raises(MCPError) as error:+ await client.read_resource("skill://review/missing.txt")+ assert error.value.error.code == INVALID_PARAMS++[email protected](sys.platform == "win32", reason="Symlinks need privileges")+async def test_symlinked_supporting_file_is_not_listed(tmp_path: Path):+ root = tmp_path / "skills" / "review"+ root.mkdir(parents=True)+ (root / "SKILL.md").write_text("---\nname: review\ndescription: Review\n---\n")+ (root / "notes.txt").write_text("notes")+ (root / "link.txt").symlink_to(root / "notes.txt")+ server = FastMCP("Skills")+ server.add_provider(+ SkillsDirectoryProvider(+ tmp_path / "skills", experimental_skills=True, supporting_files="resources"+ )+ )+ async with Client(server) as client:+ uris = {str(resource.uri) for resource in await client.list_resources()}+ assert "skill://review/notes.txt" in uris+ assert "skill://review/link.txt" not in uris+ with pytest.raises(MCPError) as error:+ await client.read_resource("skill://review/link.txt")+ assert error.value.error.code == INVALID_PARAMSdiff --git a/tests/experimental/skills/test_resource_fallback.py b/tests/experimental/skills/test_resource_fallback.pynew file mode 100644index 000000000..281c5e09f--- /dev/null+++ b/tests/experimental/skills/test_resource_fallback.py@@ -0,0 +1,80 @@+import base64+import hashlib+import json+from pathlib import Path+from typing import Literal++import pytest+from mcp.shared.exceptions import MCPError+from mcp_types import BlobResourceContents, TextResourceContents++from fastmcp import Client, FastMCP+from fastmcp.server.providers.skills import SkillsDirectoryProvider+from fastmcp.skills import SkillsClientExtension+from fastmcp.skills.extension import SkillsExtension++[email protected]("mode", ["template", "resources"])+ "main",+ [+ b"\xff\xfeNot UTF-8",+ b"---\nname: invalid\ndescription: [one, two]\n---\nBody\n",+ b"---\nname: invalid\ndescription: {nested: value}\n---\nBody\n",+ ],+ ids=["invalid-utf8", "list-description", "mapping-description"],+)+async def test_invalid_skill_remains_an_ordinary_resource(+ tmp_path: Path, mode: Literal["template", "resources"], main: bytes+):+ invalid = tmp_path / "invalid"+ invalid.mkdir()+ files = {"SKILL.md": main, "notes.txt": b"supporting\r\nbytes\n"}+ for name, data in files.items():+ (invalid / name).write_bytes(data)+ valid = tmp_path / "valid"+ valid.mkdir()+ (valid / "SKILL.md").write_bytes(+ b"---\nname: valid\ndescription: Valid neighbor\n---\n"+ )+ provider = SkillsDirectoryProvider(+ tmp_path, experimental_skills=True, supporting_files=mode+ )+ server = FastMCP("Skills", providers=[provider])+ server.add_extension(SkillsExtension(providers=[provider]))+ async with Client(+ server, mode="auto", extensions=[SkillsClientExtension()]+ ) as client:+ resources = {str(r.uri): r for r in await client.list_resources()}+ assert "skill://invalid/SKILL.md" in resources+ assert "skill://invalid/_manifest" in resources+ assert "skill://valid/SKILL.md" in resources+ assert isinstance(resources["skill://invalid/SKILL.md"].description, str)+ if mode == "resources":+ assert "skill://invalid/notes.txt" in resources+ for name, expected in files.items():+ content = (await client.read_resource(f"skill://invalid/{name}"))[0]+ if isinstance(content, TextResourceContents):+ actual = content.text.encode()+ else:+ assert isinstance(content, BlobResourceContents)+ actual = base64.b64decode(content.blob)+ assert actual == expected+ manifest = (await client.read_resource("skill://invalid/_manifest"))[0]+ assert isinstance(manifest, TextResourceContents)+ manifest_data = json.loads(manifest.text)+ manifest_data["files"].sort(key=lambda entry: entry["path"])+ assert manifest_data == {+ "skill": "invalid",+ "files": [+ {+ "path": name,+ "size": len(data),+ "hash": f"sha256:{hashlib.sha256(data).hexdigest()}",+ }+ for name, data in sorted(files.items())+ ],+ }+ assert [s.uri for s in await client.list_skills()] == ["skill://valid/SKILL.md"]+ with pytest.raises(MCPError, match="Unknown skill URI"):+ await client.get_skill("skill://invalid/SKILL.md")diff --git a/tests/experimental/skills/test_resources.py b/tests/experimental/skills/test_resources.pynew file mode 100644index 000000000..89bfdb3b7--- /dev/null+++ b/tests/experimental/skills/test_resources.py@@ -0,0 +1,15 @@+from __future__ import annotations++import os+from pathlib import Path++import pytest++from fastmcp.skills._resources import read_file++[email protected](not hasattr(os, "mkfifo"), reason="requires named pipes")+def test_fifo_is_rejected_without_blocking(tmp_path: Path):+ os.mkfifo(tmp_path / "pipe")+ with pytest.raises(ValueError, match="regular file"):+ read_file(tmp_path, "pipe")diff --git a/tests/experimental/skills/test_snapshot.py b/tests/experimental/skills/test_snapshot.pynew file mode 100644index 000000000..0ab596275--- /dev/null+++ b/tests/experimental/skills/test_snapshot.py@@ -0,0 +1,112 @@+from __future__ import annotations++import hashlib+import sys+from pathlib import Path++import pytest++from fastmcp.skills import _snapshot+from fastmcp.skills._snapshot import parse_frontmatter, snapshot+++def test_snapshot_preserves_raw_bytes_and_frontmatter(tmp_path: Path):+ root = tmp_path / "review"+ root.mkdir()+ main = b"---\r\nname: review\r\ndescription: Review code\r\ncustom:\r\n enabled: true\r\n count: 2\r\n values: [null, 1.5, text]\r\n---\r\n# Review\r\n"+ (root / "SKILL.md").write_bytes(main)+ binary = b"\x00\xff\r\n"+ (root / "data.bin").write_bytes(binary)+ entry = snapshot(root, "team/review").entry+ assert entry.frontmatter.root["custom"] == {+ "enabled": True,+ "count": 2,+ "values": [None, 1.5, "text"],+ }+ assert isinstance(entry.resources, list)+ assert sorted((r.uri, r.size, r.digest) for r in entry.resources) == [+ (+ f"skill://team/review/{name}",+ len(content),+ f"sha256:{hashlib.sha256(content).hexdigest()}",+ )+ for name, content in [("SKILL.md", main), ("data.bin", binary)]+ ]+++ "extra",+ [+ "name: review",+ "custom: {a: 1, a: 2}",+ "custom: {1: value}",+ "custom: 2026-10-12",+ "custom: .nan",+ "custom: .inf",+ "custom: !!binary SGVsbG8=",+ "custom: !!set {a: null}",+ "custom: &cycle [*cycle]",+ "custom: {a: &x 1, b: *x}",+ "metadata: {count: 2}",+ ],+)+def test_rejects_lossy_or_invalid_frontmatter(extra: str):+ data = f"---\nname: review\ndescription: Review code\n{extra}\n---\n".encode()+ with pytest.raises(ValueError):+ parse_frontmatter(data)+++def test_snapshot_rejects_name_mismatch(tmp_path: Path):+ (tmp_path / "SKILL.md").write_text(+ "---\nname: review\ndescription: Review code\n---\n"+ )+ with pytest.raises(ValueError, match="must equal"):+ snapshot(tmp_path, "other")++[email protected]("directory", [False, True])+def test_snapshot_rejects_symlinks(tmp_path: Path, directory: bool):+ root = tmp_path / "review"+ root.mkdir()+ (root / "SKILL.md").write_text("---\nname: review\ndescription: Review code\n---\n")+ target = tmp_path / "outside"+ if directory:+ target.mkdir()+ else:+ target.write_text("outside")+ (root / "linked").symlink_to(target, target_is_directory=directory)+ with pytest.raises(ValueError, match="symlink"):+ snapshot(root, "review")+++ sys.platform == "win32", reason="Colon paths are NTFS streams on Windows"+)+def test_rejects_paths_not_supported_by_resource_reader(tmp_path: Path):+ (tmp_path / "SKILL.md").write_text(+ "---\nname: review\ndescription: Review code\n---\n"+ )+ (tmp_path / "C:notes.md").write_text("unreadable")+ with pytest.raises(ValueError):+ snapshot(tmp_path, "review")+++def test_frontmatter_tolerates_utf8_bom():+ data = "\ufeff---\nname: review\ndescription: Review code\n---\n".encode()+ assert parse_frontmatter(data).root["name"] == "review"+++ ("limit", "value"),+ [("MAX_SKILL_RESOURCES", 1), ("MAX_SKILL_BYTES", 64)],+)+def test_snapshot_rejects_skills_over_spec_limits(+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch, limit: str, value: int+):+ (tmp_path / "SKILL.md").write_text(+ "---\nname: review\ndescription: Review code\n---\n"+ )+ (tmp_path / "notes.md").write_bytes(b"x" * 64)+ monkeypatch.setattr(_snapshot, limit, value)+ with pytest.raises(ValueError, match="skill"):+ snapshot(tmp_path, "review")diff --git a/tests/server/middleware/test_extension_resource_caching.py b/tests/server/middleware/test_extension_resource_caching.pynew file mode 100644index 000000000..8a9265b96--- /dev/null+++ b/tests/server/middleware/test_extension_resource_caching.py@@ -0,0 +1,34 @@+import pytest++from fastmcp import Client, FastMCP+from fastmcp.server.extensions import ServerExtension+from fastmcp.server.middleware.caching import ResponseCachingMiddleware++[email protected]("register_extension", [False, True])+async def test_extension_live_reads_do_not_disable_unrelated_caching(+ register_extension: bool,+):+ class LiveReads(ServerExtension):+ identifier = "example.com/live-reads"++ def _requires_live_resource(self, uri: str) -> bool:+ return uri == "data://live"++ calls = {"live": 0, "cached": 0}+ server = FastMCP("Caching", middleware=[ResponseCachingMiddleware()])+ if register_extension:+ server.add_extension(LiveReads())++ @server.resource("data://{name}")+ def resource(name: str) -> str:+ calls[name] += 1+ return str(calls[name])++ async with Client(server) as client:+ for name in calls:+ await client.read_resource(f"data://{name}")+ contents = await client.read_resource(f"data://{name}")+ expected = 2 if name == "live" and register_extension else 1+ assert contents[0].text == str(expected)+ assert calls == {"live": 2 if register_extension else 1, "cached": 1}diff --git a/tests/skills/test_extension.py b/tests/skills/test_extension.pyindex 7ea19a049..bc7566c68 100644--- a/tests/skills/test_extension.py+++ b/tests/skills/test_extension.py@@ -64,6 +64,15 @@ class MemorySkillProvider(Provider):}self.contexts: list[ServerRequestContext[Any, Any]] = []+ def _validate_skill_source(self) -> None:+ pass++ async def _skill_uris(self, uri: str | None = None) -> Sequence[str]:+ return [key for key in self.addressable if uri is None or key == uri]++ def _owns_skill_resource(self, uri: str) -> bool:+ return False+async def _list_skill_entries(self, context: ServerRequestContext[Any, Any]) -> Sequence[Skill]: