aiohttp-tiny-mcp 0.3.2__tar.gz → 0.3.3__tar.gz

{aiohttp_tiny_mcp-0.3.2 → aiohttp_tiny_mcp-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohttp-tiny-mcp
-Version: 0.3.2
+Version: 0.3.3
 Summary: Remote MCP server and client library for aiohttp
 License-Expression: Apache-2.0
 License-File: LICENSE

{aiohttp_tiny_mcp-0.3.2 → aiohttp_tiny_mcp-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aiohttp-tiny-mcp"
-version = "0.3.2"
+version = "0.3.3"
 description = "Remote MCP server and client library for aiohttp"
 readme = "README.md"
 license = "Apache-2.0"

{aiohttp_tiny_mcp-0.3.2 → aiohttp_tiny_mcp-0.3.3}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "aiohttp-tiny-mcp"
-version = "0.3.2"
+version = "0.3.3"
 description = "Remote MCP server and client library for aiohttp"
 readme = "README.md"
 license = "Apache-2.0"

{aiohttp_tiny_mcp-0.3.2 → aiohttp_tiny_mcp-0.3.3}/src/aiohttp_tiny_mcp/adapter.py

@@ -174,11 +174,7 @@ class Adapter(ABC):
             if msg.is_notification:
                 raise Rejected(Failure(FailureKind.MALFORMED, "extension requests require an id"))
             call.target = msg.method
-            call.arguments = {
-                key: value
-                for key, value in msg.params.items()
-                if key not in {"_meta", "inputResponses", "requestState"}
-            }
+            call.arguments = {key: value for key, value in msg.params.items() if key != "_meta"}
         return call
 
     def build_call(self, operation: Operation, msg: Incoming, params: Params) -> Call:
@@ -331,6 +327,8 @@ class Adapter(ABC):
             return None
         if spec.definition is not None and spec.legacy_uri and not self.supports_extensions:
             return spec.definition.model_copy(update={"uri": spec.legacy_uri})
+        if spec.template is not None and spec.legacy_uri and not self.supports_extensions:
+            return spec.template.model_copy(update={"uri_template": spec.legacy_uri})
         return spec.definition if spec.definition is not None else spec.template
 
     def describe_prompt(self, spec: PromptSpec) -> PromptDef | None:

{aiohttp_tiny_mcp-0.3.2 → aiohttp_tiny_mcp-0.3.3}/src/aiohttp_tiny_mcp/console/console.js

@@ -1124,7 +1124,18 @@ function report(title, body, failed) {
   page.outcome.append(card);
 }
 
+function resourceUris(value, found = new Set()) {
+  if (!value || typeof value !== "object") return found;
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "uri" && typeof child === "string" && /^[a-z][a-z0-9+.-]*:/i.test(child)) {
+      found.add(child);
+    } else if (child && typeof child === "object") resourceUris(child, found);
+  }
+  return found;
+}
+
 function reportContents(result) {
+  const links = new Set();
   (result.contents || []).forEach((part) => {
     if (part.text === undefined) {
       reportValue(part.mimeType || "contents", part);
@@ -1135,8 +1146,23 @@ function reportContents(result) {
       report(part.mimeType || "contents", part.text);
     } else {
       reportValue(part.mimeType || "contents", held);
+      resourceUris(held, links);
     }
   });
+  if (links.size) {
+    const group = element("div", "group");
+    group.append(element("h4", null, "Read a resource"));
+    links.forEach((uri) => {
+      const button = element("button", "item", uri);
+      button.type = "button";
+      button.onclick = () => {
+        choose({ kind: "resource", item: { uri } });
+        invoke();
+      };
+      group.append(button);
+    });
+    page.outcome.append(group);
+  }
 }
 
 async function verifiedSkillFile(result, file) {
@@ -1161,23 +1187,22 @@ async function verifiedSkillFile(result, file) {
 
 function reportSkill(skill) {
   reportValue("Frontmatter", skill.frontmatter);
-  if (skill.resources === "dynamic") {
-    report("Files", "This skill has a dynamic manifest. Read its files by URI in Resources.");
-    return;
-  }
-  if (!Array.isArray(skill.resources)) throw new Error("The skill has no file manifest.");
-  reportValue("File manifest", skill.resources);
+  const dynamic = skill.resources === "dynamic";
+  if (!dynamic && !Array.isArray(skill.resources)) throw new Error("The skill has no file manifest.");
+  if (dynamic) report("Files", "Read the current instructions below. This dynamic manifest provides no file digests.");
+  else reportValue("File manifest", skill.resources);
   const files = element("div", "group");
   files.append(element("h4", null, "Read a file"));
   const selected = chosen;
   const source = client;
-  skill.resources.forEach((file) => {
-    const button = element("button", "item", `${file.uri} (${file.size} bytes)`);
+  (dynamic ? [{ uri: skill.uri }] : skill.resources).forEach((file) => {
+    const button = element("button", "item", dynamic ? file.uri : `${file.uri} (${file.size} bytes)`);
     button.type = "button";
     button.onclick = async () => {
       button.disabled = true;
       try {
-        const result = await verifiedSkillFile(await source.readResource(file.uri), file);
+        const content = await source.readResource(file.uri);
+        const result = dynamic ? content : await verifiedSkillFile(content, file);
         if (chosen === selected && client === source) reportContents(result);
       } catch (error) {
         if (chosen === selected && client === source) report("Could not read file", error.message, true);

{aiohttp_tiny_mcp-0.3.2 → aiohttp_tiny_mcp-0.3.3}/src/aiohttp_tiny_mcp/dispatcher.py

@@ -22,6 +22,7 @@ from .core import (
     Value,
 )
 from .exchange import Exchange
+from .extensions import ExtensionResult
 from .models import (
     CallToolResult,
     CompleteResult,
@@ -212,7 +213,7 @@ class Dispatcher:
                 value = value.model_dump(mode="json", by_alias=True)
             if not isinstance(value, Mapping):
                 raise TypeError(f"{method}: extension handler must return a result object")
-            return Value(result=ResultModel.model_validate(dict(value)))
+            return Value(result=ExtensionResult.model_validate(dict(value)))
         return Failure(FailureKind.UNKNOWN_METHOD, f"unknown method: {method}")
 
     async def set_log_level(self, ex: Exchange) -> Outcome:
@@ -345,6 +346,10 @@ class Dispatcher:
         definition = ex.adapter.describe_resource(spec)
         if definition is None or (isinstance(definition, ResourceDef) and definition.uri != uri):
             return Failure(FailureKind.RESOURCE_NOT_FOUND, f"resource not found: {uri}")
+        if spec.template is not None and spec.legacy_uri is not None:
+            pattern = spec.pattern if ex.adapter.supports_extensions else spec.legacy_pattern
+            if pattern is None or pattern.fullmatch(uri) is None:
+                return Failure(FailureKind.RESOURCE_NOT_FOUND, f"resource not found: {uri}")
         try:
             value = await spec.bound.call(variables, ex)
         except ValidationError as e:

aiohttp_tiny_mcp-0.3.3/src/aiohttp_tiny_mcp/extensions.py

@@ -0,0 +1,279 @@
+"""Reusable extension declarations for MCP 2026-07-28 and later."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Awaitable, Callable, Mapping
+from copy import deepcopy
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Any
+from urllib.parse import unquote
+
+from pydantic import BaseModel
+
+from .core import Failure, FailureKind, Rejected
+from .models import ResultModel
+from .schema import json_schema
+from .specs import Bound, ResourceSpec
+
+
+@dataclass(frozen=True)
+class ExtensionSpec:
+    capabilities: Mapping[str, Any]
+    min_revision: str
+    methods: Mapping[str, Bound]
+
+
+class ExtensionResult(ResultModel):
+    """Preserve result discriminators defined by an extension."""
+
+    result_type: str | None = None
+
+
+class Nothing(BaseModel):
+    pass
+
+
+class LegacyParams(BaseModel):
+    params: str = "{}"
+
+
+def map_resource_uris(value: Any, resources: list[ResourceSpec], *, legacy: bool) -> Any:
+    """Translate URI fields without changing opaque cursors or file contents."""
+    if isinstance(value, list):
+        return [map_resource_uris(item, resources, legacy=legacy) for item in value]
+    if not isinstance(value, dict):
+        return value
+    result = {}
+    for key, item in value.items():
+        if key == "uri" and isinstance(item, str):
+            for spec in resources:
+                assert spec.legacy_uri is not None
+                if spec.definition is not None:
+                    canonical = spec.definition.uri
+                else:
+                    assert spec.template is not None
+                    canonical = spec.template.uri_template
+                source, target = (
+                    (canonical, spec.legacy_uri) if legacy else (spec.legacy_uri, canonical)
+                )
+                pattern = spec.pattern if legacy else spec.legacy_pattern
+                if item == source:
+                    item = target
+                    break
+                if pattern is not None and (match := pattern.fullmatch(item)):
+                    item = ResourceSpec.VAR.sub(lambda m: match[m[1]], target)
+                    break
+            result[key] = item
+        else:
+            result[key] = map_resource_uris(item, resources, legacy=legacy)
+    return result
+
+
+class Extension:
+    """Bundle methods, capability settings, and resources for registration.
+
+    Configure the extension before passing it to ``registry.extension()``.
+    Each registry takes a snapshot of the declarations.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        *,
+        capabilities: Mapping[str, Any] | None = None,
+        min_revision: str = "2026-07-28",
+    ) -> None:
+        if (
+            not name
+            or "/" not in name
+            or any(part in ("", ".", "..") for part in name.split("/"))
+            or any(char.isspace() or char in "?#%:\\" for char in name)
+        ):
+            raise ValueError("extension name must be a namespaced identifier")
+        if min_revision < "2026-07-28":
+            raise ValueError("extensions require MCP 2026-07-28 or later")
+        self.name = name
+        self.capabilities = deepcopy(dict(capabilities or {}))
+        self.min_revision = min_revision
+        self.methods: dict[str, Bound] = {}
+        self.resources: dict[str, ResourceSpec] = {}
+
+    def method(self, name: str, fn: Callable[..., Awaitable[Any]] | None = None):
+        """Register an async handler whose first argument is a Pydantic model.
+
+        Return a result mapping or a ``ResultModel`` subclass. Additional
+        parameters use the registry's dependency providers, including Exchange.
+        Older revisions invoke the same handler through a namespaced resource.
+        Parameters use a percent-encoded JSON query value. Reading a method
+        resource can change state, depending on the handler.
+        """
+        if not name or name.startswith("rpc.") or any(char.isspace() for char in name):
+            raise ValueError(f"invalid extension method: {name!r}")
+        if (
+            any(part in ("", ".", "..") for part in name.split("/"))
+            or any(char in "?#%:{}\\" for char in name)
+            or name == "manifest.json"
+        ):
+            raise ValueError(f"invalid legacy method path: {name!r}")
+
+        def register(fn: Callable[..., Awaitable[Any]]):
+            if name in self.methods:
+                raise ValueError(f"duplicate extension method: {name}")
+            self.methods[name] = Bound.of(fn)
+            return fn
+
+        return register(fn) if fn is not None else register
+
+    def resource(
+        self,
+        uri: str,
+        fn: Callable[..., Awaitable[Any]] | None = None,
+        *,
+        legacy_path: str | None = None,
+        **kw: Any,
+    ):
+        """Bundle a resource with a legacy ``mcp-extensions://{name}/...`` URI.
+
+        By default, the legacy path is the URI after its scheme. Set
+        ``legacy_path`` to choose a different relative path within the extension.
+        """
+        path = legacy_path if legacy_path is not None else uri.split("://", 1)[-1]
+        if not path or any(part in ("", ".", "..") for part in path.split("/")):
+            raise ValueError("legacy_path must be a relative resource path")
+        if path == "manifest.json":
+            raise ValueError("manifest.json is reserved for the extension manifest")
+
+        def register(fn: Callable[..., Awaitable[Any]]):
+            if uri in self.resources:
+                raise ValueError(f"duplicate extension resource: {uri}")
+            spec = ResourceSpec.build(uri, fn, **kw)
+            spec.legacy_uri = f"mcp-extensions://{self.name}/{path}"
+            alias = ResourceSpec.build(spec.legacy_uri, fn)
+            if set(ResourceSpec.VAR.findall(uri)) != set(ResourceSpec.VAR.findall(path)):
+                raise ValueError("legacy_path must use the same template variables as the URI")
+            spec.legacy_pattern = alias.pattern
+            self.resources[uri] = spec
+            return fn
+
+        return register(fn) if fn is not None else register
+
+    def method_resources(self) -> tuple[dict[str, ResourceSpec], dict[str, Any]]:
+        """Build legacy resource routes around every registered method."""
+        from .exchange import Exchange
+
+        resources = [spec.model_copy(deep=True) for spec in self.resources.values()]
+        routes: dict[str, ResourceSpec] = {}
+        entries = {}
+
+        def reader(bound: Bound):
+            async def read(args: LegacyParams, ex) -> dict:
+                try:
+                    params = json.loads(unquote(args.params))
+                except (ValueError, UnicodeError) as error:
+                    raise Rejected(
+                        Failure(FailureKind.INVALID_PARAMS, "Invalid JSON params")
+                    ) from error
+                if not isinstance(params, dict):
+                    raise Rejected(Failure(FailureKind.INVALID_PARAMS, "params must be an object"))
+                params = map_resource_uris(params, resources, legacy=False)
+                value = await bound.call(params, ex)
+                if isinstance(value, BaseModel):
+                    value = value.model_dump(mode="json", by_alias=True, exclude_none=True)
+                if not isinstance(value, Mapping):
+                    raise TypeError("extension handler must return a result object")
+                return map_resource_uris(dict(value), resources, legacy=True)
+
+            read.__annotations__["ex"] = Exchange
+            return read
+
+        for name in sorted(self.methods):
+            bound = self.methods[name].model_copy(deep=True)
+            uri = f"mcp-extensions://{self.name}/{name}"
+            schema = json_schema(bound.args_model)
+            entry = {
+                "uriTemplate": uri + "?params={params}",
+                "inputSchema": schema,
+                "description": (bound.fn.__doc__ or "").strip(),
+            }
+            if isinstance(bound.returns, type) and issubclass(bound.returns, BaseModel):
+                entry["outputSchema"] = json_schema(bound.returns)
+            if not schema.get("required"):
+                entry["uri"] = uri
+            handler = reader(bound)
+            for address in [entry["uriTemplate"], *([uri] if "uri" in entry else [])]:
+                spec = ResourceSpec.build(
+                    address,
+                    handler,
+                    name=name,
+                    mime_type="application/json",
+                    description=(
+                        f"Invoke {name}; this can change state. "
+                        "params is a percent-encoded JSON object. "
+                        + (bound.fn.__doc__ or "").strip()
+                    ),
+                )
+                spec.legacy_only = True
+                routes[address] = spec
+            entries[name] = entry
+        return routes, entries
+
+    def manifest_resource(
+        self, routes: dict[str, ResourceSpec] | None = None, methods: dict[str, Any] | None = None
+    ) -> ResourceSpec:
+        """Describe the extension to clients that only support resources."""
+        manifest = {
+            "name": self.name,
+            "instructions": (
+                "Use resources/read to invoke a method URI. For arguments, substitute "
+                "percent-encoded JSON for {params} in its uriTemplate. Each read invokes "
+                "the handler and can change state. Results are JSON resource contents; "
+                "failures are JSON-RPC errors. Follow returned resource URIs to read files."
+            ),
+            "capabilities": self.capabilities,
+            "methods": sorted(self.methods),
+            "resources": sorted(
+                [
+                    spec.legacy_uri
+                    for spec in self.resources.values()
+                    if spec.legacy_uri is not None and spec.definition is not None
+                ]
+                + [uri for uri, spec in (routes or {}).items() if spec.definition is not None]
+            ),
+        }
+        templates = sorted(
+            [
+                spec.legacy_uri
+                for spec in self.resources.values()
+                if spec.template is not None and spec.legacy_uri is not None
+            ]
+            + [uri for uri, spec in (routes or {}).items() if spec.template is not None]
+        )
+        if templates:
+            manifest["resourceTemplates"] = templates
+        if methods:
+            manifest["methodResources"] = methods
+        content = json.dumps(manifest, ensure_ascii=False)
+
+        async def read(args: Nothing) -> str:
+            return content
+
+        spec = ResourceSpec.build(
+            f"mcp-extensions://{self.name}/manifest.json",
+            read,
+            name=f"{self.name} manifest",
+            mime_type="application/json",
+            description="Compatibility resource routes, parameter schemas, and file URIs.",
+        )
+        spec.legacy_only = True
+        return spec
+
+    def snapshot(self) -> ExtensionSpec:
+        return ExtensionSpec(
+            capabilities=MappingProxyType(deepcopy(self.capabilities)),
+            min_revision=self.min_revision,
+            methods=MappingProxyType(
+                {name: bound.model_copy(deep=True) for name, bound in self.methods.items()}
+            ),
+        )

{aiohttp_tiny_mcp-0.3.2 → aiohttp_tiny_mcp-0.3.3}/src/aiohttp_tiny_mcp/registry.py

@@ -85,9 +85,21 @@ class Registry:
             if any(name in spec.methods for spec in self.extensions.values()):
                 raise ValueError(f"duplicate extension method: {name}")
             self.check(name, bound)
-        manifest = extension.manifest_resource()
+        routes, methods = extension.method_resources()
+        manifest = extension.manifest_resource(routes, methods)
         assert manifest.definition is not None
-        resources = {**extension.resources, manifest.definition.uri: manifest}
+        if manifest.definition.uri in extension.resources:
+            raise ValueError("duplicate extension manifest resource")
+        if set(routes) & set(extension.resources):
+            raise ValueError("duplicate extension method resource")
+        resources = {**extension.resources, **routes, manifest.definition.uri: manifest}
+        templates = {
+            address
+            for spec in self.resources_templated
+            if spec.template is not None
+            for address in (spec.template.uri_template, spec.legacy_uri)
+            if address is not None
+        }
         claimed: set[str] = set()
         for uri, resource in resources.items():
             for address in {uri, resource.legacy_uri}:
@@ -97,6 +109,7 @@ class Registry:
                     address in claimed
                     or address in self.resources_fixed
                     or address in self.resource_aliases
+                    or address in templates
                 ):
                     raise ValueError(f"duplicate resource: {address}")
                 claimed.add(address)
@@ -104,9 +117,17 @@ class Registry:
         self.extensions[extension.name] = extension.snapshot()
         for uri, resource in resources.items():
             resource = resource.model_copy(deep=True)
-            self.resources_fixed[uri] = resource
-            if resource.legacy_uri is not None:
-                self.resource_aliases[resource.legacy_uri] = resource
+            if resource.definition is not None:
+                self.resources_fixed[uri] = resource
+                if resource.legacy_uri is not None:
+                    self.resource_aliases[resource.legacy_uri] = resource
+            else:
+                if resource.legacy_only:
+                    # Method query routes take precedence over file templates
+                    # such as skills/{name}, whose matcher also accepts '?'.
+                    self.resources_templated.insert(0, resource)
+                else:
+                    self.resources_templated.append(resource)
 
     def provide(self, kind: type, source: Any) -> None:
         """Bind a type to where it comes from. Call before registering
@@ -176,7 +197,8 @@ class Registry:
             else:
                 template = spec.template.uri_template if spec.template is not None else uri
                 if any(
-                    item.template is not None and item.template.uri_template == template
+                    item.template is not None
+                    and template in (item.template.uri_template, item.legacy_uri)
                     for item in self.resources_templated
                 ):
                     raise ValueError(f"duplicate resource template: {template}")
@@ -210,6 +232,8 @@ class Registry:
             return fixed, {}
         for spec in self.resources_templated:
             m = spec.pattern.match(uri)
+            if m is None and spec.legacy_pattern is not None:
+                m = spec.legacy_pattern.match(uri)
             if m:
                 return spec, m.groupdict()
         return None

{aiohttp_tiny_mcp-0.3.2 → aiohttp_tiny_mcp-0.3.3}/src/aiohttp_tiny_mcp/specs.py

@@ -153,6 +153,7 @@ class ResourceSpec(Model):
     cache_ttl_ms: int | None = None
     cache_scope: Literal["public", "private"] | None = None
     legacy_uri: str | None = None
+    legacy_pattern: Any = None
     legacy_only: bool = False
 
     VAR: ClassVar[re.Pattern] = re.compile(r"\{([A-Za-z_][A-Za-z0-9_]*)\}")

aiohttp_tiny_mcp-0.3.2/src/aiohttp_tiny_mcp/extensions.py

@@ -1,143 +0,0 @@
-"""Reusable extension declarations for MCP 2026-07-28 and later."""
-
-from __future__ import annotations
-
-import json
-from collections.abc import Awaitable, Callable, Mapping
-from copy import deepcopy
-from dataclasses import dataclass
-from types import MappingProxyType
-from typing import Any
-
-from pydantic import BaseModel
-
-from .specs import Bound, ResourceSpec
-
-
-@dataclass(frozen=True)
-class ExtensionSpec:
-    capabilities: Mapping[str, Any]
-    min_revision: str
-    methods: Mapping[str, Bound]
-
-
-class Nothing(BaseModel):
-    pass
-
-
-class Extension:
-    """Bundle methods, capability settings, and resources for registration.
-
-    Configure the extension before passing it to ``registry.extension()``.
-    Each registry takes a snapshot of the declarations.
-    """
-
-    def __init__(
-        self,
-        name: str,
-        *,
-        capabilities: Mapping[str, Any] | None = None,
-        min_revision: str = "2026-07-28",
-    ) -> None:
-        if (
-            not name
-            or "/" not in name
-            or any(part in ("", ".", "..") for part in name.split("/"))
-            or any(char.isspace() or char in "?#%:\\" for char in name)
-        ):
-            raise ValueError("extension name must be a namespaced identifier")
-        if min_revision < "2026-07-28":
-            raise ValueError("extensions require MCP 2026-07-28 or later")
-        self.name = name
-        self.capabilities = deepcopy(dict(capabilities or {}))
-        self.min_revision = min_revision
-        self.methods: dict[str, Bound] = {}
-        self.resources: dict[str, ResourceSpec] = {}
-
-    def method(self, name: str, fn: Callable[..., Awaitable[Any]] | None = None):
-        """Register an async handler whose first argument is a Pydantic model.
-
-        Return a result mapping or a ``ResultModel`` subclass. Additional
-        parameters use the registry's dependency providers, including Exchange.
-        """
-        if not name or name.startswith("rpc.") or any(char.isspace() for char in name):
-            raise ValueError(f"invalid extension method: {name!r}")
-
-        def register(fn: Callable[..., Awaitable[Any]]):
-            if name in self.methods:
-                raise ValueError(f"duplicate extension method: {name}")
-            self.methods[name] = Bound.of(fn)
-            return fn
-
-        return register(fn) if fn is not None else register
-
-    def resource(
-        self,
-        uri: str,
-        fn: Callable[..., Awaitable[Any]] | None = None,
-        *,
-        legacy_path: str | None = None,
-        **kw: Any,
-    ):
-        """Bundle a resource with a legacy ``mcp-extenstion://{name}/...`` URI.
-
-        By default, the legacy path is the URI after its scheme. Set
-        ``legacy_path`` to choose a different relative path within the extension.
-        """
-        path = legacy_path if legacy_path is not None else uri.split("://", 1)[-1]
-        if not path or any(part in ("", ".", "..") for part in path.split("/")):
-            raise ValueError("legacy_path must be a relative resource path")
-        if path == "manifest.json":
-            raise ValueError("manifest.json is reserved for the extension manifest")
-
-        def register(fn: Callable[..., Awaitable[Any]]):
-            if uri in self.resources:
-                raise ValueError(f"duplicate extension resource: {uri}")
-            spec = ResourceSpec.build(uri, fn, **kw)
-            if spec.definition is None:
-                raise ValueError("extension resources must use fixed URIs")
-            spec.legacy_uri = f"mcp-extenstion://{self.name}/{path}"
-            self.resources[uri] = spec
-            return fn
-
-        return register(fn) if fn is not None else register
-
-    def manifest_resource(self) -> ResourceSpec:
-        """Describe the extension to clients that only support resources."""
-        content = json.dumps(
-            {
-                "name": self.name,
-                "capabilities": self.capabilities,
-                "methods": sorted(self.methods),
-                "resources": sorted(
-                    spec.legacy_uri
-                    for spec in self.resources.values()
-                    if spec.legacy_uri is not None
-                ),
-            },
-            ensure_ascii=False,
-        )
-
-        async def read(args: Nothing) -> str:
-            return content
-
-        spec = ResourceSpec.build(
-            f"mcp-extenstion://{self.name}/manifest.json",
-            read,
-            name=f"{self.name} manifest",
-            mime_type="application/json",
-            description=(
-                f"Extension metadata and resource URIs. Methods require MCP {self.min_revision}+."
-            ),
-        )
-        spec.legacy_only = True
-        return spec
-
-    def snapshot(self) -> ExtensionSpec:
-        return ExtensionSpec(
-            capabilities=MappingProxyType(deepcopy(self.capabilities)),
-            min_revision=self.min_revision,
-            methods=MappingProxyType(
-                {name: bound.model_copy(deep=True) for name, bound in self.methods.items()}
-            ),
-        )