aiohttp-tiny-mcp 0.3.6__tar.gz → 0.4.0__tar.gz

{aiohttp_tiny_mcp-0.3.6 → aiohttp_tiny_mcp-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohttp-tiny-mcp
-Version: 0.3.6
+Version: 0.4.0
 Summary: Remote MCP server and client library for aiohttp
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -235,7 +235,7 @@ Start with [the documentation overview](https://mosquito.github.io/aiohttp-tiny-
 2. [Quickstart](https://mosquito.github.io/aiohttp-tiny-mcp/quickstart.html): a complete server, launch command, and client call.
 3. [How the server fits together](https://mosquito.github.io/aiohttp-tiny-mcp/pieces.html): a conversation across two workers and each object's lifetime.
 4. [Using Exchange](https://mosquito.github.io/aiohttp-tiny-mcp/guide/exchange.html): request context, progress, questions, and state.
-5. [Authentication](https://mosquito.github.io/aiohttp-tiny-mcp/guide/auth.html): bearer-token verification and OAuth resource metadata.
+5. [Authentication](https://mosquito.github.io/aiohttp-tiny-mcp/guide/auth.html): Basic, Bearer, custom subclasses, multiple policies, and permissions.
 6. [Stores and hubs](https://mosquito.github.io/aiohttp-tiny-mcp/deployment/stores.html): shared backend contracts and deployment requirements.
 7. [Extensions and skills](https://mosquito.github.io/aiohttp-tiny-mcp/guide/extensions.html): custom methods, skill directories, and resources for older clients.
 

{aiohttp_tiny_mcp-0.3.6 → aiohttp_tiny_mcp-0.4.0}/README.md

@@ -193,7 +193,7 @@ Start with [the documentation overview](https://mosquito.github.io/aiohttp-tiny-
 2. [Quickstart](https://mosquito.github.io/aiohttp-tiny-mcp/quickstart.html): a complete server, launch command, and client call.
 3. [How the server fits together](https://mosquito.github.io/aiohttp-tiny-mcp/pieces.html): a conversation across two workers and each object's lifetime.
 4. [Using Exchange](https://mosquito.github.io/aiohttp-tiny-mcp/guide/exchange.html): request context, progress, questions, and state.
-5. [Authentication](https://mosquito.github.io/aiohttp-tiny-mcp/guide/auth.html): bearer-token verification and OAuth resource metadata.
+5. [Authentication](https://mosquito.github.io/aiohttp-tiny-mcp/guide/auth.html): Basic, Bearer, custom subclasses, multiple policies, and permissions.
 6. [Stores and hubs](https://mosquito.github.io/aiohttp-tiny-mcp/deployment/stores.html): shared backend contracts and deployment requirements.
 7. [Extensions and skills](https://mosquito.github.io/aiohttp-tiny-mcp/guide/extensions.html): custom methods, skill directories, and resources for older clients.
 

{aiohttp_tiny_mcp-0.3.6 → aiohttp_tiny_mcp-0.4.0}/pyproject.toml

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

{aiohttp_tiny_mcp-0.3.6 → aiohttp_tiny_mcp-0.4.0}/pyproject.toml.orig

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

{aiohttp_tiny_mcp-0.3.6 → aiohttp_tiny_mcp-0.4.0}/src/aiohttp_tiny_mcp/__init__.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from .auth import Authentication, Authorization, BasicAuth, Principal, StaticBasicAuth, Unauthorized
 from .client import Client
 from .client_base import ClientError, Elicitor
 from .core import (
@@ -47,6 +48,9 @@ __all__ = [
     "Answer",
     "AnswerAction",
     "AudioContent",
+    "Authentication",
+    "Authorization",
+    "BasicAuth",
     "BlobResourceContents",
     "CallToolResult",
     "Client",
@@ -68,6 +72,7 @@ __all__ = [
     "NeedInput",
     "namespace",
     "PromptMessage",
+    "Principal",
     "Registry",
     "SseEndpoint",
     "RequestStates",
@@ -75,8 +80,10 @@ __all__ = [
     "SessionRecord",
     "SessionStore",
     "StdioClient",
+    "StaticBasicAuth",
     "TextContent",
     "TextResourceContents",
+    "Unauthorized",
     "elicit",
     "elicit_accept",
     "elicit_cancel",

aiohttp_tiny_mcp-0.4.0/src/aiohttp_tiny_mcp/auth.py

@@ -0,0 +1,274 @@
+"""Extensible HTTP authentication, Basic credentials, and OAuth Bearer tokens."""
+
+from __future__ import annotations
+
+import time
+from abc import ABC, abstractmethod
+from base64 import b64decode
+from binascii import Error as Base64Error
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass, field
+from secrets import compare_digest
+from typing import Any, Protocol, runtime_checkable
+from urllib.parse import urlsplit
+
+from aiohttp import web
+
+WELL_KNOWN = "/.well-known/oauth-protected-resource"
+
+
+@dataclass(frozen=True, slots=True)
+class Principal:
+    """Identity and claims returned by a token verifier."""
+
+    subject: str | None = None
+    client_id: str = ""
+    issuer: str | None = None
+    scopes: frozenset[str] = frozenset()
+    expires_at: float | None = None
+    claims: Mapping[str, Any] = field(default_factory=dict)
+    namespace: str | None = None
+
+    def holds(self, wanted: Iterable[str]) -> frozenset[str]:
+        """Return required scopes absent from this principal."""
+        return frozenset(wanted) - self.scopes
+
+    @property
+    def expired(self) -> bool:
+        return self.expires_at is not None and self.expires_at < time.time()
+
+    @property
+    def identity(self) -> str:
+        """Return an issuer-qualified subject or client identifier."""
+        if self.subject:
+            return f"{self.issuer or ''}|{self.subject}"
+        return f"{self.issuer or ''}|client:{self.client_id}"
+
+
+@runtime_checkable
+class TokenVerifier(Protocol):
+    """Verify a bearer token for this resource."""
+
+    async def verify(self, token: str) -> Principal | None: ...
+
+
+class Unauthorized(Exception):
+    """Authentication or authorization failed."""
+
+    def __init__(self, error: str, description: str, status: int = 401) -> None:
+        super().__init__(description)
+        self.error = error
+        self.description = description
+        self.status = status
+
+
+class Authentication(ABC):
+    """Subclass this policy and pass an instance to `Registry(auth=...)`.
+
+    Implement `authenticate` and `challenge`. Return a verified `Principal`
+    or `None` for invalid credentials. Raise `Unauthorized` for a specific
+    refusal. HTTP endpoints enforce expiry, required scopes, session ownership,
+    and namespaces after authentication. Policies publish no metadata by default.
+    """
+
+    bind_sessions: bool = True
+    namespace_from_token: bool = True
+    required_scopes: Sequence[str] = ()
+
+    def __init__(
+        self,
+        *,
+        bind_sessions: bool = True,
+        namespace_from_token: bool = True,
+        required_scopes: Sequence[str] = (),
+    ) -> None:
+        self.bind_sessions = bind_sessions
+        self.namespace_from_token = namespace_from_token
+        self.required_scopes = tuple(required_scopes)
+
+    @abstractmethod
+    async def authenticate(self, request: web.Request) -> Principal | None:
+        """Verify this HTTP request. The full request is available to the policy."""
+
+    @abstractmethod
+    def challenge(self, refusal: Unauthorized) -> str:
+        """Return the WWW-Authenticate value for this policy."""
+
+    def check(self, principal: Principal | None) -> Principal:
+        """Reject invalid identities and missing server-wide scopes."""
+        if principal is None or principal.expired:
+            raise Unauthorized("invalid_credentials", "valid credentials required")
+        missing = principal.holds(self.required_scopes)
+        if missing:
+            raise Unauthorized(
+                "insufficient_scope",
+                f"missing scope: {', '.join(sorted(missing))}",
+                status=403,
+            )
+        return principal
+
+    @property
+    def metadata_path(self) -> str | None:
+        """Return an optional metadata route, relative to the site root."""
+        return None
+
+    def metadata(self) -> dict[str, Any]:
+        """Return metadata when the policy declares a metadata path."""
+        return {}
+
+
+class BasicAuth(Authentication):
+    """Subclass `verify` to authenticate Basic credentials against your user store.
+
+    Credentials use standard Base64 and UTF-8. Query credentials are not read.
+    Use `StaticBasicAuth` for one configured username and password.
+    """
+
+    def __init__(
+        self,
+        *,
+        realm: str = "mcp",
+        bind_sessions: bool = True,
+        namespace_from_token: bool = True,
+        required_scopes: Sequence[str] = (),
+    ) -> None:
+        super().__init__(
+            bind_sessions=bind_sessions,
+            namespace_from_token=namespace_from_token,
+            required_scopes=required_scopes,
+        )
+        if not realm.isascii() or any(ord(char) < 32 or ord(char) == 127 for char in realm):
+            raise ValueError("realm must contain only printable ASCII characters")
+        self.realm = realm
+
+    @abstractmethod
+    async def verify(self, username: str, password: str) -> Principal | None:
+        """Return the verified identity, or None when credentials do not match."""
+
+    async def authenticate(self, request: web.Request) -> Principal | None:
+        header = request.headers.get("Authorization", "")
+        parts = header.split()
+        if len(parts) != 2 or parts[0].lower() != "basic":
+            return None
+        try:
+            decoded = b64decode(parts[1], validate=True).decode("utf-8")
+        except (ValueError, Base64Error, UnicodeDecodeError):
+            return None
+        username, separator, password = decoded.partition(":")
+        if not separator or any(ord(char) < 32 or ord(char) == 127 for char in decoded):
+            return None
+        return await self.verify(username, password)
+
+    def challenge(self, refusal: Unauthorized) -> str:
+        realm = self.realm.replace("\\", "\\\\").replace('"', '\\"')
+        return f'Basic realm="{realm}", charset="UTF-8"'
+
+
+class StaticBasicAuth(BasicAuth):
+    """Basic authentication for one configured account. Use HTTPS in production."""
+
+    def __init__(
+        self,
+        username: str,
+        password: str,
+        *,
+        realm: str = "mcp",
+        scopes: Iterable[str] = (),
+        bind_sessions: bool = True,
+        namespace_from_token: bool = True,
+        required_scopes: Sequence[str] = (),
+    ) -> None:
+        super().__init__(
+            realm=realm,
+            bind_sessions=bind_sessions,
+            namespace_from_token=namespace_from_token,
+            required_scopes=required_scopes,
+        )
+        if ":" in username or any(
+            ord(char) < 32 or ord(char) == 127 for char in username + password
+        ):
+            raise ValueError("Basic credentials cannot contain controls or a colon in the username")
+        if not username or not password:
+            raise ValueError("username and password must be non-empty")
+        self._username = username.encode("utf-8")
+        self._password = password.encode("utf-8")
+        self._principal = Principal(subject=username, scopes=frozenset(scopes))
+
+    async def verify(self, username: str, password: str) -> Principal | None:
+        matched = compare_digest(username.encode("utf-8"), self._username)
+        matched &= compare_digest(password.encode("utf-8"), self._password)
+        return self._principal if matched else None
+
+
+@dataclass(frozen=True)
+class Authorization(Authentication):
+    """Configuration for an OAuth protected resource server."""
+
+    verifier: TokenVerifier
+    resource: str
+    authorization_servers: Sequence[str] = ()
+    scopes_supported: Sequence[str] | None = None
+    required_scopes: Sequence[str] = ()
+    resource_name: str | None = None
+    documentation: str | None = None
+    bind_sessions: bool = True
+    namespace_from_token: bool = True
+
+    @property
+    def metadata_path(self) -> str:
+        """Return this resource's RFC 9728 metadata path."""
+        path = urlsplit(self.resource).path.rstrip("/")
+        return f"{WELL_KNOWN}{path}"
+
+    def metadata(self) -> dict[str, Any]:
+        """Build this resource's RFC 9728 metadata document."""
+        found: dict[str, Any] = {"resource": self.resource}
+        if self.authorization_servers:
+            found["authorization_servers"] = list(self.authorization_servers)
+        if self.scopes_supported is not None:
+            found["scopes_supported"] = list(self.scopes_supported)
+        if self.resource_name:
+            found["resource_name"] = self.resource_name
+        if self.documentation:
+            found["resource_documentation"] = self.documentation
+        found["bearer_methods_supported"] = ["header"]
+        return found
+
+    def challenge(self, refusal: Unauthorized) -> str:
+        """Build a Bearer challenge with a metadata URL."""
+        parts = [
+            f'error="{refusal.error}"',
+            f'error_description="{refusal.description}"',
+            f'resource_metadata="{self.metadata_url}"',
+        ]
+        return "Bearer " + ", ".join(parts)
+
+    @property
+    def metadata_url(self) -> str:
+        split = urlsplit(self.resource)
+        return f"{split.scheme}://{split.netloc}{self.metadata_path}"
+
+    async def principal(self, authorization: str | None) -> Principal:
+        """Verify an Authorization header and return its principal."""
+        if not authorization or not authorization.lower().startswith("bearer "):
+            raise Unauthorized("invalid_request", "authorization required")
+        found = await self.verifier.verify(authorization[len("bearer ") :].strip())
+        if found is None or found.expired:
+            raise Unauthorized("invalid_token", "the token is not valid for this resource")
+        return self.check(found)
+
+    async def authenticate(self, request: web.Request) -> Principal:
+        """Verify the request's Bearer header using the configured token verifier."""
+        return await self.principal(request.headers.get("Authorization"))
+
+
+__all__ = [
+    "WELL_KNOWN",
+    "Authentication",
+    "Authorization",
+    "BasicAuth",
+    "Principal",
+    "StaticBasicAuth",
+    "TokenVerifier",
+    "Unauthorized",
+]

{aiohttp_tiny_mcp-0.3.6 → aiohttp_tiny_mcp-0.4.0}/src/aiohttp_tiny_mcp/endpoint.py

@@ -7,15 +7,14 @@ import json
 import logging
 import re
 from collections.abc import Mapping
-from contextlib import suppress
 from dataclasses import replace
-from functools import cached_property
+from functools import cached_property, partial
 from typing import Any
 
 from aiohttp import web
 
 from .adapter import Adapter
-from .auth import Authorization, Unauthorized
+from .auth import Authentication, Principal, Unauthorized
 from .core import (
     Call,
     DecodeFailure,
@@ -46,10 +45,12 @@ from .sessions import (
 )
 from .sse import SSEResponse
 from .subscriptions import relays, wanted
+from .tasks import stop
 
 log = logging.getLogger("aiohttp_tiny_mcp")
 
 MAY_ASK = frozenset({Operation.CALL_TOOL, Operation.GET_PROMPT, Operation.READ_RESOURCE})
+AUTH_POLICY: web.RequestKey[Authentication] = web.RequestKey("mcp_auth_policy", Authentication)
 
 
 def origin_pattern(spec: str) -> re.Pattern[str]:
@@ -127,10 +128,10 @@ class Endpoint:
     ) -> list[web.RouteDef]:
         """The endpoint, and where a client looks to find out how to reach it.
 
-        The metadata route is included whenever tokens are verified, because a
-        client that has no token learns where to get one from there and
-        nowhere else. Pass `metadata=False` where this application cannot
-        serve that path -- see `metadata_routes`.
+        Metadata routes are included when a policy declares them. OAuth Bearer
+        policies publish protected-resource metadata; Basic policies do not.
+        Pass `metadata=False` when this application cannot serve those paths.
+        See `metadata_routes`.
         """
         log.debug("MCP endpoint at %s, named %r", path, name)
         found = [web.route("*", path, self.view, name=name)]
@@ -141,33 +142,40 @@ class Endpoint:
     def metadata_routes(self, *, name: str | None = "mcp") -> list[web.RouteDef]:
         """RFC 9728 metadata, for the application that owns the site root.
 
-        Empty where nothing verifies tokens. The path comes from the resource
+        Empty when no policy declares metadata. The path comes from the resource
         URL, and RFC 8615 puts a well-known URI directly under the authority,
         so a prefix must not reach it: an endpoint mounted with `add_subapp`
         takes `routes(metadata=False)` and leaves these to the root
         application.
         """
-        auth = self.registry.auth
-        if auth is None:
-            log.debug("no resource metadata route: nothing verifies tokens")
-            return []
-        log.debug("resource metadata at %s, for resource %s", auth.metadata_path, auth.resource)
-        return [
-            web.get(
-                auth.metadata_path,
-                self.metadata,
-                name=f"{name}-resource-metadata" if name else None,
+        found: list[web.RouteDef] = []
+        documents: dict[str, dict[str, Any]] = {}
+        for auth in self.registry.auth_policies:
+            path = auth.metadata_path
+            if path is None:
+                continue
+            document = auth.metadata()
+            if path in documents:
+                if documents[path] != document:
+                    raise ValueError(f"conflicting authentication metadata at {path}")
+                continue
+            documents[path] = document
+            suffix = f"-policy{len(found)}" if found else ""
+            found.append(
+                web.get(
+                    path,
+                    partial(self.metadata, auth=auth),
+                    name=f"{name}-resource-metadata{suffix}" if name else None,
+                )
             )
-        ]
+        return found
 
-    async def metadata(self, request: web.Request) -> web.Response:
+    async def metadata(self, request: web.Request, *, auth: Authentication) -> web.Response:
         """RFC 9728: what this resource is and who issues tokens for it."""
-        auth = self.registry.auth
-        assert auth is not None, "the metadata route is only added with auth"
         return web.json_response(auth.metadata(), headers={"Cache-Control": "public, max-age=3600"})
 
-    async def verified(self, request: web.Request) -> Any:
-        """Who is calling, or `None` where nothing verifies tokens.
+    async def verified(self, request: web.Request) -> Principal | None:
+        """Return the verified caller, or None when no authentication is configured.
 
         Raises `Unauthorized`, which the caller turns into the refusal a
         client can act on. The namespace is set from what was verified, so
@@ -175,19 +183,34 @@ class Endpoint:
         checked rather than by a header the caller chose. An application that
         set its own namespace first keeps it.
         """
-        auth = self.registry.auth
-        if auth is None:
+        policies = self.registry.auth_policies
+        if not policies:
             return None
-        principal = await auth.principal(request.headers.get("Authorization"))
-        if auth.namespace_from_token and current() is None:
-            namespace.set(principal.identity)
-        return principal
+        refusals: list[Unauthorized] = []
+        for auth in policies:
+            try:
+                principal = auth.check(await auth.authenticate(request))
+            except Unauthorized as refusal:
+                refusals.append(refusal)
+                continue
+            request[AUTH_POLICY] = auth
+            if auth.namespace_from_token and current() is None:
+                namespace.set(
+                    principal.namespace if principal.namespace is not None else principal.identity
+                )
+            return principal
+        # Preserve scope failures when another policy merely found no credentials.
+        raise next((refusal for refusal in refusals if refusal.status == 403), refusals[-1])
 
-    def refuse(self, auth: Authorization, refusal: Unauthorized) -> web.Response:
+    def refuse(self, refusal: Unauthorized) -> web.Response:
         return web.json_response(
             {"error": refusal.error, "error_description": refusal.description},
             status=refusal.status,
-            headers={"WWW-Authenticate": auth.challenge(refusal)},
+            headers={
+                "WWW-Authenticate": ", ".join(
+                    auth.challenge(refusal) for auth in self.registry.auth_policies
+                )
+            },
         )
 
     def setup(
@@ -282,7 +305,7 @@ class Endpoint:
             principal = await self.verified(request)
         except Unauthorized as refusal:
             assert self.registry.auth is not None
-            return self.refuse(self.registry.auth, refusal)
+            return self.refuse(refusal)
 
         raw = await request.read()
         pre = Preamble.of(raw, request.headers, request.query)
@@ -395,7 +418,7 @@ class Endpoint:
             principal = await self.verified(request)
         except Unauthorized as refusal:
             assert self.registry.auth is not None
-            return self.refuse(self.registry.auth, refusal)
+            return self.refuse(refusal)
 
         try:
             record = await self.load_session(request, principal)
@@ -419,9 +442,7 @@ class Endpoint:
                 if transport is None or transport.is_closing():
                     break
         finally:
-            relay.cancel()
-            with suppress(asyncio.CancelledError, ConnectionError):
-                await relay
+            await stop(relay)
         return response
 
     async def relay_notifications(
@@ -457,7 +478,9 @@ class Endpoint:
                 log.debug("ignoring Last-Event-ID %r: not from this hub", last)
         return await hub.subscribe(where, wait=wait)
 
-    def owns(self, record: SessionRecord | None, principal: Any) -> bool:
+    def owns(
+        self, record: SessionRecord | None, principal: Principal | None, request: web.Request
+    ) -> bool:
         """Whether this caller may use this session.
 
         A session id travels in a header, so a copied one is a credential.
@@ -465,7 +488,7 @@ class Endpoint:
         held in this process, which is what lets a session opened on one
         worker be used on another.
         """
-        auth = self.registry.auth
+        auth = request.get(AUTH_POLICY)
         if record is None or auth is None or not auth.bind_sessions:
             return True
         owner = stored_owner(record)
@@ -495,7 +518,7 @@ class Endpoint:
         if not session_id:
             return None
         record = await self.registry.session_store.get(scoped(session_id))
-        if record is None or not self.owns(record, principal):
+        if record is None or not self.owns(record, principal, request):
             raise Rejected(Failure(FailureKind.SESSION_NOT_FOUND, "session not found"))
         await self.registry.session_store.touch(
             scoped(session_id), ttl_seconds=self.registry.session_ttl_seconds
@@ -578,10 +601,7 @@ class Endpoint:
             ex.cancel()
             raise
         finally:
-            if not task.done():
-                task.cancel()
-                with suppress(asyncio.CancelledError):
-                    await task
+            await stop(task)
 
 
 MCP_ENDPOINT = web.AppKey("mcp_endpoint", Endpoint)

{aiohttp_tiny_mcp-0.3.6 → aiohttp_tiny_mcp-0.4.0}/src/aiohttp_tiny_mcp/extensions.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import dataclasses
 import json
 from collections.abc import Awaitable, Callable, Iterable, Mapping
 from copy import deepcopy
@@ -57,7 +58,7 @@ class ExtensionSpec:
     methods: Mapping[str, Bound]
     #: Broadcast method to the params field that carries its topic, or None for one
     #: every listener of the method gets.
-    notifications: Mapping[str, str | None] = MappingProxyType({})
+    notifications: Mapping[str, str | None] = dataclasses.field(default_factory=dict)
 
 
 class ExtensionResult(ResultModel):

{aiohttp_tiny_mcp-0.3.6 → aiohttp_tiny_mcp-0.4.0}/src/aiohttp_tiny_mcp/http_sse.py

@@ -6,13 +6,13 @@ import asyncio
 import json
 import logging
 from collections.abc import Coroutine
-from contextlib import suppress
 from dataclasses import replace
 from typing import Any
 
 from aiohttp import web
 
 from .adapter import Adapter
+from .auth import Principal, Unauthorized
 from .core import (
     Call,
     DecodeFailure,
@@ -41,6 +41,7 @@ from .sessions import (
 )
 from .sse import SSEResponse
 from .subscriptions import relays, wanted
+from .tasks import stop
 
 log = logging.getLogger(__name__)
 
@@ -100,10 +101,14 @@ class SseEndpoint:
         """Open a stream and send its POST address."""
         try:
             self.origins.check_origin(request)
+            principal = await self.origins.verified(request)
         except Rejected as e:
             return self.origins.render_failure(self.adapter, e.failure)
+        except Unauthorized as refusal:
+            assert self.registry.auth is not None
+            return self.origins.refuse(refusal)
 
-        session_id = await self.open_session()
+        session_id = await self.open_session(principal.identity if principal is not None else None)
         where = topic(STREAM, session_id)
         hub = self.registry.hub
         wait = self.registry.hub_poll_seconds
@@ -126,12 +131,12 @@ class SseEndpoint:
             await self.registry.session_store.delete(scoped(session_id))
         return response
 
-    async def open_session(self) -> str:
+    async def open_session(self, owner: str | None = None) -> str:
         """Create the short-lived session represented by an open stream."""
         session_id = new_session_id()
         await self.registry.session_store.create(
             scoped(session_id),
-            handshake_data(VERSION, {}),
+            handshake_data(VERSION, {}, owner),
             ttl_seconds=self.registry.session_ttl_seconds,
         )
         return session_id
@@ -148,11 +153,7 @@ class SseEndpoint:
                 if transport is None or transport.is_closing():
                     break
         finally:
-            for task in tasks:
-                task.cancel()
-            for task in tasks:
-                with suppress(asyncio.CancelledError, ConnectionError):
-                    await task
+            await stop(*tasks)
 
     async def relay(self, response: SSEResponse, events: Subscription) -> None:
         """Write everything published for this connection, until cancelled."""
@@ -193,13 +194,20 @@ class SseEndpoint:
         """Take one message and answer 202. The reply goes to the stream."""
         try:
             self.origins.check_origin(request)
+            principal = await self.origins.verified(request)
         except Rejected as e:
             return self.origins.render_failure(self.adapter, e.failure)
+        except Unauthorized as refusal:
+            assert self.registry.auth is not None
+            return self.origins.refuse(refusal)
 
         session_id = request.query.get("session_id", "")
         record = await self.registry.session_store.get(scoped(session_id)) if session_id else None
-        if record is None:
+        if record is None or not self.origins.owns(record, principal, request):
             return web.json_response({"error": "no such session"}, status=404)
+        await self.registry.session_store.touch(
+            scoped(session_id), ttl_seconds=self.registry.session_ttl_seconds
+        )
 
         raw = await request.read()
         log.debug("<- [%s] %s", VERSION, raw.decode("utf-8", "replace"))
@@ -214,7 +222,9 @@ class SseEndpoint:
             return web.Response(status=202)
 
         for item in items:
-            await self.serve(adapter, item, session_id, record, where)
+            await self.serve(
+                adapter, item, session_id, record, where, request=request, principal=principal
+            )
         return web.Response(status=202)
 
     async def serve(
@@ -224,6 +234,9 @@ class SseEndpoint:
         session_id: str,
         record: SessionRecord,
         where: str,
+        *,
+        request: web.Request,
+        principal: Principal | None,
     ) -> None:
         hub = self.registry.hub
         if isinstance(item, DecodeFailure):
@@ -241,7 +254,8 @@ class SseEndpoint:
         session = Session(
             self.registry.session_store, session_id, record, self.registry.session_ttl_seconds
         )
-        ex = Exchange(self.registry, self.origins, adapter, item, session=session)
+        ex = Exchange(self.registry, request, adapter, item, session=session)
+        ex.principal = principal
         ex.send = lambda payload: hub.publish(where, payload)
 
         try:
@@ -270,31 +284,48 @@ class SseEndpoint:
         return path[: -len(self.sse_path)] if path.endswith(self.sse_path) else ""
 
     def routes(
-        self, sse_path: str | None = None, message_path: str | None = None
+        self,
+        sse_path: str | None = None,
+        message_path: str | None = None,
+        *,
+        metadata: bool = True,
     ) -> list[web.RouteDef]:
         """One route to listen on, one to post to.
 
         Either path may be set here or on the constructor. Both are kept,
         because the stream names the posting path to the client.
+
+        Policies that declare metadata include its routes. Use `metadata=False`
+        when another endpoint serves it or when mounting under a subapplication.
+        In a subapplication, add `metadata_routes()` to the root application.
         """
         if sse_path is not None:
             self.sse_path = sse_path
         if message_path is not None:
             self.message_path = message_path
         log.debug("HTTP+SSE stream at %s, messages at %s", self.sse_path, self.message_path)
-        return [
+        found = [
             web.get(self.sse_path, self.listen),
             web.post(self.message_path, self.receive),
         ]
+        if metadata:
+            found.extend(self.metadata_routes())
+        return found
+
+    def metadata_routes(self, *, name: str | None = "mcp-sse") -> list[web.RouteDef]:
+        """Return protected-resource metadata routes for the root application."""
+        return self.origins.metadata_routes(name=name)
 
     def setup(
         self,
         app: web.Application,
         sse_path: str | None = None,
         message_path: str | None = None,
+        *,
+        metadata: bool = True,
     ) -> web.Application:
         log.debug("adding the HTTP+SSE routes to %r", app)
-        app.add_routes(self.routes(sse_path, message_path))
+        app.add_routes(self.routes(sse_path, message_path, metadata=metadata))
         return app
 
 

{aiohttp_tiny_mcp-0.3.6 → aiohttp_tiny_mcp-0.4.0}/src/aiohttp_tiny_mcp/registry.py

@@ -2,10 +2,10 @@
 
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable, Mapping
+from collections.abc import Awaitable, Callable, Iterable, Mapping
 from typing import Any
 
-from .auth import Authorization, Principal
+from .auth import Authentication, Principal
 from .exchange import Exchange, Instance
 from .extensions import Extension, ExtensionSpec
 from .hub import NOTIFICATIONS, Cursor, Hub, MemoryHub, topic
@@ -36,7 +36,7 @@ class Registry:
         *,
         hub: Hub | None = None,
         session_store: SessionStore | None = None,
-        auth: Authorization | None = None,
+        auth: Authentication | Iterable[Authentication] | None = None,
         instructions: str | None = None,
         session_ttl_seconds: int = DEFAULT_TTL_SECONDS,
         request_state_ttl_seconds: int = STATE_TTL_SECONDS,
@@ -64,6 +64,30 @@ class Registry:
         self.extensions: dict[str, ExtensionSpec] = {}
         self.resource_aliases: dict[str, ResourceSpec] = {}
 
+    @property
+    def auth(self) -> Authentication | tuple[Authentication, ...] | None:
+        """Configured authentication policies. Iterables are consumed once."""
+        return self._auth
+
+    @auth.setter
+    def auth(self, value: Authentication | Iterable[Authentication] | None) -> None:
+        if value is None or isinstance(value, Authentication):
+            self._auth = value
+            return
+        policies = tuple(value)
+        if not policies or not all(isinstance(policy, Authentication) for policy in policies):
+            raise ValueError("auth must contain at least one Authentication policy")
+        self._auth = policies
+
+    @property
+    def auth_policies(self) -> tuple[Authentication, ...]:
+        """Authentication alternatives in registration order."""
+        if self._auth is None:
+            return ()
+        if isinstance(self._auth, Authentication):
+            return (self._auth,)
+        return self._auth
+
     def extension(self, extension: Extension) -> None:
         """Install an extension and its resources after checking all declarations.
 
@@ -205,7 +229,7 @@ class Registry:
                 if self.auth is None:
                     raise TypeError(
                         f"{what}: parameter {name!r} wants a Principal, but this registry "
-                        f"has no auth= -- pass an Authorization to verify tokens first"
+                        f"has no auth= -- pass an Authentication policy to verify callers first"
                     )
                 continue
             if kind not in self.providers and kind is not Exchange:

{aiohttp_tiny_mcp-0.3.6 → aiohttp_tiny_mcp-0.4.0}/src/aiohttp_tiny_mcp/stdio.py

@@ -11,6 +11,7 @@ import json
 import logging
 import sys
 from collections.abc import Callable, Mapping
+from contextlib import suppress
 from dataclasses import replace
 from typing import Any
 
@@ -26,6 +27,7 @@ from .dispatcher import Dispatcher
 from .exchange import Exchange, is_reply, relay_reply
 from .protocol.selection import AdapterSet
 from .registry import Registry
+from .tasks import stop
 
 log = logging.getLogger("aiohttp_tiny_mcp")
 
@@ -155,9 +157,9 @@ async def serve_stdio(
         tasks = []
         for exchange, task in list(active.values()):
             exchange.cancel()
-            task.cancel()
             tasks.append(task)
-        await asyncio.gather(*tasks, return_exceptions=True)
+        with suppress(Exception):
+            await stop(*tasks)
 
 
 async def stdin_reader() -> asyncio.StreamReader:

aiohttp_tiny_mcp-0.4.0/src/aiohttp_tiny_mcp/tasks.py

@@ -0,0 +1,37 @@
+"""Ending a task that may not honour its first cancellation."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+STOP_GRACE_SECONDS = 1.0
+
+
+async def stop(*tasks: asyncio.Task[Any], grace: float = STOP_GRACE_SECONDS) -> None:
+    """Cancel `tasks` and return when every one of them has ended.
+
+    One cancellation is not always enough. A library may catch it, and on
+    Python before 3.12 `asyncio.wait_for` drops it when the future it waits
+    on completes in the same loop turn: psycopg_pool waits for a connection
+    that way, and a sibling task that is cancelled first hands its
+    connection back at exactly that moment. A task still running after
+    `grace` seconds is cancelled again, at whatever it awaits by then.
+
+    A cancelled task and one that ended with `ConnectionError` are what
+    stopping looks like. Any other exception is raised, the first one found.
+    """
+    pending = {task for task in tasks if not task.done()}
+    while pending:
+        for task in pending:
+            task.cancel()
+        _, pending = await asyncio.wait(pending, timeout=grace)
+    for task in tasks:
+        if task.cancelled():
+            continue
+        error = task.exception()
+        if error is not None and not isinstance(error, ConnectionError):
+            raise error
+
+
+__all__ = ["STOP_GRACE_SECONDS", "stop"]

aiohttp_tiny_mcp-0.3.6/src/aiohttp_tiny_mcp/auth.py

@@ -1,129 +0,0 @@
-"""Bearer-token verification for an OAuth protected MCP resource."""
-
-from __future__ import annotations
-
-import time
-from collections.abc import Iterable, Mapping, Sequence
-from dataclasses import dataclass, field
-from typing import Any, Protocol, runtime_checkable
-from urllib.parse import urlsplit
-
-WELL_KNOWN = "/.well-known/oauth-protected-resource"
-
-
-@dataclass(frozen=True, slots=True)
-class Principal:
-    """Identity and claims returned by a token verifier."""
-
-    subject: str | None = None
-    client_id: str = ""
-    issuer: str | None = None
-    scopes: frozenset[str] = frozenset()
-    expires_at: float | None = None
-    claims: Mapping[str, Any] = field(default_factory=dict)
-
-    def holds(self, wanted: Iterable[str]) -> frozenset[str]:
-        """Return required scopes absent from this principal."""
-        return frozenset(wanted) - self.scopes
-
-    @property
-    def expired(self) -> bool:
-        return self.expires_at is not None and self.expires_at < time.time()
-
-    @property
-    def identity(self) -> str:
-        """Return an issuer-qualified subject or client identifier."""
-        if self.subject:
-            return f"{self.issuer or ''}|{self.subject}"
-        return f"{self.issuer or ''}|client:{self.client_id}"
-
-
-@runtime_checkable
-class TokenVerifier(Protocol):
-    """Verify a bearer token for this resource."""
-
-    async def verify(self, token: str) -> Principal | None: ...
-
-
-class Unauthorized(Exception):
-    """Authentication or authorization failed."""
-
-    def __init__(self, error: str, description: str, status: int = 401) -> None:
-        super().__init__(description)
-        self.error = error
-        self.description = description
-        self.status = status
-
-
-@dataclass(frozen=True)
-class Authorization:
-    """Configuration for an OAuth protected resource server."""
-
-    verifier: TokenVerifier
-    resource: str
-    authorization_servers: Sequence[str] = ()
-    scopes_supported: Sequence[str] | None = None
-    required_scopes: Sequence[str] = ()
-    resource_name: str | None = None
-    documentation: str | None = None
-    bind_sessions: bool = True
-    namespace_from_token: bool = True
-
-    @property
-    def metadata_path(self) -> str:
-        """Return this resource's RFC 9728 metadata path."""
-        path = urlsplit(self.resource).path.rstrip("/")
-        return f"{WELL_KNOWN}{path}"
-
-    def metadata(self) -> dict[str, Any]:
-        """Build this resource's RFC 9728 metadata document."""
-        found: dict[str, Any] = {"resource": self.resource}
-        if self.authorization_servers:
-            found["authorization_servers"] = list(self.authorization_servers)
-        if self.scopes_supported is not None:
-            found["scopes_supported"] = list(self.scopes_supported)
-        if self.resource_name:
-            found["resource_name"] = self.resource_name
-        if self.documentation:
-            found["resource_documentation"] = self.documentation
-        found["bearer_methods_supported"] = ["header"]
-        return found
-
-    def challenge(self, refusal: Unauthorized) -> str:
-        """Build a Bearer challenge with a metadata URL."""
-        parts = [
-            f'error="{refusal.error}"',
-            f'error_description="{refusal.description}"',
-            f'resource_metadata="{self.metadata_url}"',
-        ]
-        return "Bearer " + ", ".join(parts)
-
-    @property
-    def metadata_url(self) -> str:
-        split = urlsplit(self.resource)
-        return f"{split.scheme}://{split.netloc}{self.metadata_path}"
-
-    async def principal(self, authorization: str | None) -> Principal:
-        """Verify an Authorization header and return its principal."""
-        if not authorization or not authorization.lower().startswith("bearer "):
-            raise Unauthorized("invalid_request", "authorization required")
-        found = await self.verifier.verify(authorization[len("bearer ") :].strip())
-        if found is None or found.expired:
-            raise Unauthorized("invalid_token", "the token is not valid for this resource")
-        missing = found.holds(self.required_scopes)
-        if missing:
-            raise Unauthorized(
-                "insufficient_scope",
-                f"missing scope: {', '.join(sorted(missing))}",
-                status=403,
-            )
-        return found
-
-
-__all__ = [
-    "WELL_KNOWN",
-    "Authorization",
-    "Principal",
-    "TokenVerifier",
-    "Unauthorized",
-]