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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohttp-tiny-mcp
-Version: 0.3.2
+Version: 0.3.4
 Summary: Remote MCP server and client library for aiohttp
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -146,7 +146,11 @@ async def deploy(args: Deploy, ex: Exchange) -> str:
     return f"deployed {args.service}"
 
 
-app = Endpoint(registry).app("/mcp")
+app = Endpoint(
+    registry,
+    # Behind a reverse proxy, uncomment this and let the proxy check Origin.
+    # trust_proxy_origin_validation=True,
+).app("/mcp")
 
 if __name__ == "__main__":
     web.run_app(app, host="127.0.0.1", port=8080)

{aiohttp_tiny_mcp-0.3.2 → aiohttp_tiny_mcp-0.3.4}/README.md

@@ -104,7 +104,11 @@ async def deploy(args: Deploy, ex: Exchange) -> str:
     return f"deployed {args.service}"
 
 
-app = Endpoint(registry).app("/mcp")
+app = Endpoint(
+    registry,
+    # Behind a reverse proxy, uncomment this and let the proxy check Origin.
+    # trust_proxy_origin_validation=True,
+).app("/mcp")
 
 if __name__ == "__main__":
     web.run_app(app, host="127.0.0.1", port=8080)

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

@@ -1,6 +1,6 @@
 [project]
 name = "aiohttp-tiny-mcp"
-version = "0.3.2"
+version = "0.3.4"
 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.4}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "aiohttp-tiny-mcp"
-version = "0.3.2"
+version = "0.3.4"
 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.4}/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.4}/src/aiohttp_tiny_mcp/console/console.css

@@ -71,6 +71,8 @@ body {
 }
 
 .field { display: flex; align-items: center; gap: 6px; }
+.field.grow { flex: 1 1 12em; min-width: 0; }
+.field.grow > input { flex: 1 1 auto; min-width: 8em; }
 .field > span { color: var(--ink-soft); font-size: 12px; }
 
 input[type="text"], input[type="number"], select, textarea {

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

@@ -384,6 +384,34 @@ const page = {
 let client = null;
 let chosen = null;
 let endpointUrl = null;
+//: Where the page was told the endpoint is. The field starts from it and may add a query.
+let configuredEndpoint = null;
+
+// The endpoint field: the path, plus any query string a person adds, such as
+// `?mcp=2025-06-18` to pin a revision or whatever the server reads from the URL.
+// The value is kept for the next visit while its path is still the configured one,
+// so a server moved elsewhere is not chased at a stale address.
+function endpointKey() {
+  return `mcp-console-endpoint:${location.pathname}`;
+}
+
+function rememberedEndpoint() {
+  const kept = localStorage.getItem(endpointKey());
+  if (!kept) return null;
+  const url = new URL(kept, location.origin);
+  return url.pathname === configuredEndpoint.pathname ? kept : null;
+}
+
+function chosenEndpoint() {
+  const typed = page.endpoint.value.trim() || configuredEndpoint.pathname;
+  const url = new URL(typed, location.origin);
+  if (url.origin !== location.origin) {
+    throw new Error(`The endpoint must be on this server, not ${url.origin}.`);
+  }
+  page.endpoint.value = url.pathname + url.search;
+  localStorage.setItem(endpointKey(), page.endpoint.value);
+  return url;
+}
 
 function element(tag, className, text) {
   const made = document.createElement(tag);
@@ -1124,7 +1152,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 +1174,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 +1215,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);
@@ -1272,6 +1325,7 @@ function disconnect() {
   page.refresh.disabled = true;
   page.revision.disabled = false;
   page.answerable.disabled = false;
+  page.endpoint.disabled = false;
   page.connect.textContent = "Connect";
   say("not connected", "");
 }
@@ -1280,9 +1334,11 @@ async function connect() {
   page.connect.disabled = true;
   page.revision.disabled = true;
   page.answerable.disabled = true;
+  page.endpoint.disabled = true;
   say("connecting", "");
   page.outcome.textContent = "";
   try {
+    endpointUrl = chosenEndpoint();
     client = new Client(endpointUrl.href, page.revision.value, {
       answerable: page.answerable.checked,
       onFrame: record,
@@ -1305,6 +1361,7 @@ async function connect() {
     page.refresh.disabled = true;
     page.revision.disabled = false;
     page.answerable.disabled = false;
+    page.endpoint.disabled = false;
     page.connect.textContent = "Connect";
     say(error.message, "off");
     report("Could not connect", connectionHelp(error), true);
@@ -1315,7 +1372,7 @@ async function connect() {
 
 function connectionHelp(error) {
   const lines = [error.message];
-  if (error instanceof TypeError || /fetch/i.test(error.message)) {
+  if (endpointUrl && (error instanceof TypeError || /fetch/i.test(error.message))) {
     lines.push("", `The request to ${endpointUrl.href} did not reach a server.`);
   }
   return lines.join("\n");
@@ -1384,8 +1441,14 @@ function start() {
   const remembered = localStorage.getItem("mcp-console-revision");
   page.revision.value = REVISIONS[remembered] ? remembered : Object.keys(REVISIONS)[0];
 
-  endpointUrl = new URL(document.documentElement.dataset.endpoint || "/mcp", location.origin);
-  page.endpoint.textContent = endpointUrl.pathname;
+  configuredEndpoint = new URL(document.documentElement.dataset.endpoint || "/mcp", location.origin);
+  page.endpoint.value = rememberedEndpoint() || configuredEndpoint.pathname + configuredEndpoint.search;
+  page.endpoint.onkeydown = (event) => {
+    if (event.key === "Enter" && !client) {
+      event.preventDefault();
+      connect();
+    }
+  };
 
   page.connect.onclick = () => (client ? disconnect() : connect());
   page.refresh.onclick = async () => {

{aiohttp_tiny_mcp-0.3.2 → aiohttp_tiny_mcp-0.3.4}/src/aiohttp_tiny_mcp/console/index.html

@@ -11,10 +11,10 @@
 
 <header class="bar">
   <h1>{{TITLE}}</h1>
-  <span class="field">
+  <label class="field grow" title="The path the server serves MCP on. A query string is sent as typed">
     <span>Endpoint</span>
-    <code id="endpoint" class="endpoint"></code>
-  </span>
+    <input id="endpoint" class="endpoint" type="text" spellcheck="false" autocomplete="off">
+  </label>
   <label class="field">
     <span>Revision</span>
     <select id="revision" class="revision"></select>

{aiohttp_tiny_mcp-0.3.2 → aiohttp_tiny_mcp-0.3.4}/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.2 → aiohttp_tiny_mcp-0.3.4}/src/aiohttp_tiny_mcp/endpoint.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+import re
 from collections.abc import Mapping
 from contextlib import suppress
 from dataclasses import replace
@@ -51,6 +52,24 @@ log = logging.getLogger("aiohttp_tiny_mcp")
 MAY_ASK = frozenset({Operation.CALL_TOOL, Operation.GET_PROMPT, Operation.READ_RESOURCE})
 
 
+def origin_pattern(spec: str) -> re.Pattern[str]:
+    """Compile an allowed origin with wildcards.
+
+    `*` matches one host label, `**` matches one or more labels, so
+    `https://*.example.com` admits `https://app.example.com` and `https://**.example.com`
+    admits `https://a.b.example.com` as well. Everything else matches literally.
+    """
+    parts = []
+    for piece in re.split(r"(\*\*|\*)", spec):
+        if piece == "**":
+            parts.append(r"[^./]+(?:\.[^./]+)*")
+        elif piece == "*":
+            parts.append(r"[^./]+")
+        else:
+            parts.append(re.escape(piece))
+    return re.compile("".join(parts))
+
+
 class Endpoint:
     """The MCP endpoint, in the spec's sense: one path that accepts POST.
 
@@ -81,6 +100,7 @@ class Endpoint:
         self.adapters = adapters or AdapterSet.default()
         self.dispatcher = Dispatcher(registry)
         self.allowed_origins = allowed_origins
+        self.origin_patterns = [origin_pattern(o) for o in allowed_origins or () if "*" in o]
         self.trust_proxy_origin_validation = trust_proxy_origin_validation
         self.compress = compress
 
@@ -187,8 +207,11 @@ class Endpoint:
             return
         if origin == self.own_origin(request):
             return
-        if self.allowed_origins is None or origin not in self.allowed_origins:
-            raise Rejected(Failure(FailureKind.ORIGIN_REJECTED, "origin not allowed"))
+        if self.allowed_origins is not None and origin in self.allowed_origins:
+            return
+        if any(pattern.fullmatch(origin) for pattern in self.origin_patterns):
+            return
+        raise Rejected(Failure(FailureKind.ORIGIN_REJECTED, "origin not allowed"))
 
     def own_origin(self, request: web.Request) -> str:
         """Origin of pages served by this endpoint. A rebound page retains the attacker's origin

aiohttp_tiny_mcp-0.3.4/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.4}/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.4}/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()}
-            ),
-        )