aiohttp-tiny-mcp 0.2.6__tar.gz → 0.3.0__tar.gz

{aiohttp_tiny_mcp-0.2.6 → aiohttp_tiny_mcp-0.3.0}/PKG-INFO

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

{aiohttp_tiny_mcp-0.2.6 → aiohttp_tiny_mcp-0.3.0}/pyproject.toml

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

{aiohttp_tiny_mcp-0.2.6 → aiohttp_tiny_mcp-0.3.0}/pyproject.toml.orig

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

{aiohttp_tiny_mcp-0.2.6 → aiohttp_tiny_mcp-0.3.0}/src/aiohttp_tiny_mcp/client.py

@@ -52,6 +52,8 @@ class Client(BaseClient):
         self.base_url = base_url
         self.session = session
         self.owns_session = session is None
+        #: The id of the last event read from the notification stream.
+        self.last_event_id: str | None = None
         self.session_id: str | None = None
 
     async def __aenter__(self) -> Client:
@@ -93,15 +95,22 @@ class Client(BaseClient):
         async with self.session.post(self.base_url, json=envelope, headers=headers) as resp:
             await resp.read()
 
-    async def stream_notifications(self) -> AsyncIterator[dict[str, Any]]:
-        """Open the legacy notification stream with GET; keep it open until cancelled."""
+    async def stream_notifications(
+        self, *, last_event_id: str | None = None
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Read the legacy GET stream until cancelled. `last_event_id` asks for a replay."""
         assert self.session is not None, "use 'async with Client(...) as client:'"
         headers = self.headers(NOTIFICATIONS_METHOD)
         headers["Accept"] = "text/event-stream"
+        if last_event_id is not None:
+            headers["Last-Event-ID"] = last_event_id
         async with self.session.get(self.base_url, headers=headers) as resp:
             resp.raise_for_status()
-            async for frame in frames(resp):
-                yield frame
+            async for event in read_sse(resp):
+                if event.id is not None:
+                    self.last_event_id = event.id
+                if event.data:
+                    yield json.loads(event.data)
 
     async def reply(self, envelope: dict[str, Any]) -> None:
         """Send a bare JSON-RPC response. The hub routes it to the node waiting for the answer."""

{aiohttp_tiny_mcp-0.2.6 → aiohttp_tiny_mcp-0.3.0}/src/aiohttp_tiny_mcp/client_base.py

@@ -104,7 +104,9 @@ class BaseClient(ABC):
     async def reply(self, envelope: dict[str, Any]) -> None:
         """Answer a request the server made. Carries no reply of its own."""
 
-    def stream_notifications(self) -> AsyncIterator[dict[str, Any]]:
+    def stream_notifications(
+        self, *, last_event_id: str | None = None
+    ) -> AsyncIterator[dict[str, Any]]:
         """Open a separate legacy notification channel, if the transport supports one."""
         raise NotImplementedError(
             f"{type(self).__name__} has no separate stream to read notifications on"
@@ -183,9 +185,20 @@ class BaseClient(ABC):
             await self.request(Operation.SET_LOG_LEVEL, SetLevelParams(level=level))
         self.log_level = level
 
+    async def pages(self, operation: Operation) -> AsyncIterator[dict[str, Any]]:
+        """Every page of a listing, following `nextCursor` to the end."""
+        cursor: str | None = None
+        while True:
+            result = await self.request(operation, ListParams(cursor=cursor))
+            yield result
+            cursor = result.get("nextCursor")
+            if not cursor:
+                return
+
     async def list_tools(self) -> list[ToolDef]:
-        result = await self.request(Operation.LIST_TOOLS, ListParams())
-        tools = ListToolsResult.model_validate(result).tools
+        tools: list[ToolDef] = []
+        async for result in self.pages(Operation.LIST_TOOLS):
+            tools += ListToolsResult.model_validate(result).tools
         self.tool_definitions = {tool.name: tool for tool in tools}
         return tools
 
@@ -272,16 +285,20 @@ class BaseClient(ABC):
                 yield frame
 
     async def list_resources(self) -> list[ResourceDef]:
-        result = await self.request(Operation.LIST_RESOURCES, ListParams())
-        return ListResourcesResult.model_validate(result).resources
+        found: list[ResourceDef] = []
+        async for result in self.pages(Operation.LIST_RESOURCES):
+            found += ListResourcesResult.model_validate(result).resources
+        return found
 
     async def read_resource(self, uri: str) -> ReadResourceResult:
         result = await self.request(Operation.READ_RESOURCE, ReadResourceParams(uri=uri), name=uri)
         return ReadResourceResult.model_validate(result)
 
     async def list_prompts(self) -> list[PromptDef]:
-        result = await self.request(Operation.LIST_PROMPTS, ListParams())
-        return ListPromptsResult.model_validate(result).prompts
+        found: list[PromptDef] = []
+        async for result in self.pages(Operation.LIST_PROMPTS):
+            found += ListPromptsResult.model_validate(result).prompts
+        return found
 
     async def get_prompt(self, name: str, arguments: dict[str, str]) -> GetPromptResult:
         result = await self.request(

{aiohttp_tiny_mcp-0.2.6 → aiohttp_tiny_mcp-0.3.0}/src/aiohttp_tiny_mcp/dispatcher.py

@@ -4,7 +4,8 @@ about HTTP, headers or protocol versions.
 
 from __future__ import annotations
 
-from typing import Any
+from collections.abc import Callable
+from typing import Any, TypeVar
 
 from pydantic import ValidationError
 
@@ -26,6 +27,7 @@ from .models import (
     Completion,
     EmptyResult,
     GetPromptResult,
+    ListParams,
     ListPromptsResult,
     ListResourcesResult,
     ListResourceTemplatesResult,
@@ -78,6 +80,8 @@ def refusal(spec: ToolSpec, principal: Principal | None) -> str | None:
 
 PUSH_ASK_ROUNDS = 8
 
+Entry = TypeVar("Entry")
+
 
 class Dispatcher:
     def __init__(self, registry: Registry) -> None:
@@ -222,6 +226,25 @@ class Dispatcher:
     async def ping(self, ex: Exchange) -> Outcome:
         return Value(result=EmptyResult())
 
+    def paged(
+        self, ex: Exchange, entries: list[Entry], key: Callable[[Entry], str]
+    ) -> tuple[list[Entry], str | None] | Failure:
+        """One page of `entries`, sorted by `key`, and the cursor for the next.
+
+        The cursor is the key of the last entry shown. One that names no entry is
+        -32602: a silent first page would send a paging client round in a circle.
+        """
+        cursor = ex.call.params.cursor if isinstance(ex.call.params, ListParams) else None
+        if cursor is not None:
+            if all(key(entry) != cursor for entry in entries):
+                return Failure(FailureKind.INVALID_PARAMS, f"unknown cursor: {cursor}")
+            entries = [entry for entry in entries if key(entry) > cursor]
+        size = self.registry.page_size
+        if size is None or len(entries) <= size:
+            return entries, None
+        shown = entries[:size]
+        return shown, key(shown[-1])
+
     async def list_tools(self, ex: Exchange) -> Outcome:
         tools: list[ToolDef] = [
             d
@@ -229,7 +252,11 @@ class Dispatcher:
             if (d := ex.adapter.describe_tool(spec)) is not None
         ]
         tools.sort(key=lambda item: item.name)
-        return Value(result=ListToolsResult(tools=tools))
+        found = self.paged(ex, tools, lambda item: item.name)
+        if isinstance(found, Failure):
+            return found
+        shown, next_cursor = found
+        return Value(result=ListToolsResult(tools=shown, next_cursor=next_cursor))
 
     async def call_tool(self, ex: Exchange) -> Outcome:
         spec = self.registry.tools.get(ex.call.target or "")
@@ -254,7 +281,11 @@ class Dispatcher:
             if isinstance(d := ex.adapter.describe_resource(spec), ResourceDef)
         ]
         defs.sort(key=lambda item: item.uri)
-        return Value(result=ListResourcesResult(resources=defs))
+        found = self.paged(ex, defs, lambda item: item.uri)
+        if isinstance(found, Failure):
+            return found
+        shown, next_cursor = found
+        return Value(result=ListResourcesResult(resources=shown, next_cursor=next_cursor))
 
     async def list_resource_templates(self, ex: Exchange) -> Outcome:
         defs: list[ResourceTemplateDef] = [
@@ -263,7 +294,13 @@ class Dispatcher:
             if isinstance(d := ex.adapter.describe_resource(spec), ResourceTemplateDef)
         ]
         defs.sort(key=lambda item: item.uri_template)
-        return Value(result=ListResourceTemplatesResult(resource_templates=defs))
+        found = self.paged(ex, defs, lambda item: item.uri_template)
+        if isinstance(found, Failure):
+            return found
+        shown, next_cursor = found
+        return Value(
+            result=ListResourceTemplatesResult(resource_templates=shown, next_cursor=next_cursor)
+        )
 
     async def read_resource(self, ex: Exchange) -> Outcome:
         uri = ex.call.target or ""
@@ -286,7 +323,11 @@ class Dispatcher:
             if (d := ex.adapter.describe_prompt(spec)) is not None
         ]
         prompts.sort(key=lambda item: item.name)
-        return Value(result=ListPromptsResult(prompts=prompts))
+        found = self.paged(ex, prompts, lambda item: item.name)
+        if isinstance(found, Failure):
+            return found
+        shown, next_cursor = found
+        return Value(result=ListPromptsResult(prompts=shown, next_cursor=next_cursor))
 
     async def get_prompt(self, ex: Exchange) -> Outcome:
         spec = self.registry.prompts.get(ex.call.target or "")

{aiohttp_tiny_mcp-0.2.6 → aiohttp_tiny_mcp-0.3.0}/src/aiohttp_tiny_mcp/endpoint.py

@@ -28,7 +28,7 @@ from .core import (
 )
 from .dispatcher import Dispatcher
 from .exchange import Exchange, is_reply, relay_reply
-from .hub import NOTIFICATIONS, topic
+from .hub import NOTIFICATIONS, Subscription, topic
 from .namespaces import current, namespace, scoped
 from .protocol.selection import AdapterSet
 from .registry import Registry
@@ -405,23 +405,33 @@ class Endpoint:
     async def relay_notifications(
         self, request: web.Request, response: SSEResponse, adapter: Adapter
     ) -> None:
-        """Relay changes, re-reading subscriptions each pass so updates reach an open stream."""
+        """Relay changes with their hub ids, re-reading subscriptions each pass."""
         capabilities = adapter.capabilities(self.registry)
-        hub = self.registry.hub
-        where = topic(NOTIFICATIONS)
-        cursor = await hub.position(where)
+        events = await self.resumed(request, topic(NOTIFICATIONS))
         while True:
-            messages, cursor = await hub.poll(where, cursor, timeout=self.registry.hub_poll_seconds)
-            if not messages:
+            found = await events.poll()
+            if not found:
                 continue
             accepted = wanted(
                 capabilities, self.open_values(request, await self.load_session(request))
             )
-            for payload in messages:
-                if relays(payload, accepted):
-                    text = json.dumps(payload, ensure_ascii=False)
-                    log.debug("-> [%s] %s", adapter.version, text)
-                    await response.send(text)
+            for event in found:
+                if relays(event.message, accepted):
+                    text = json.dumps(event.message, ensure_ascii=False)
+                    log.debug("-> [%s] %s %s", adapter.version, event.id, text)
+                    await response.send(text, id=event.id)
+
+    async def resumed(self, request: web.Request, where: str) -> Subscription:
+        """Subscribe from `Last-Event-ID`, or from now when it is absent or unknown."""
+        hub = self.registry.hub
+        wait = self.registry.hub_poll_seconds
+        last = request.headers.get("Last-Event-ID")
+        if last:
+            try:
+                return await hub.subscribe(where, after=last, wait=wait)
+            except ValueError:
+                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:
         """Whether this caller may use this session.

{aiohttp_tiny_mcp-0.2.6 → aiohttp_tiny_mcp-0.3.0}/src/aiohttp_tiny_mcp/exchange.py

@@ -78,7 +78,7 @@ class Exchange:
         self.principal: Principal | None = None
         self.keep_log_level: Callable[[str], None] | None = None
         self.sse: SSEResponse | None = None
-        self.send: Callable[[Mapping[str, Any]], Awaitable[None]] | None = None
+        self.send: Callable[[Mapping[str, Any]], Awaitable[Any]] | None = None
         self.stack = AsyncExitStack()
         self.resolved: dict[type, Any] = {}
         self.cancelled = asyncio.Event()
@@ -182,13 +182,13 @@ class Exchange:
     async def push_ask(self, key: str, request: InputRequest) -> Answer:
         """Send a question on the active stream and wait through the hub.
 
-        The reply may reach another node. Capture the cursor before sending so fast replies are
-        not missed.
+        The reply may reach another node. Subscribe before sending so fast replies are not
+        missed.
         """
         hub = self.registry.hub
         wire_id = new_id()
         where = topic(ASK, wire_id)
-        cursor = await hub.position(where)
+        replies = await hub.subscribe(where, wait=self.registry.hub_poll_seconds)
         await self.emit({"jsonrpc": "2.0", "id": wire_id, **request})
         loop = asyncio.get_running_loop()
         deadline = loop.time() + self.registry.ask_timeout_seconds
@@ -197,11 +197,8 @@ class Exchange:
                 left = deadline - loop.time()
                 if left <= 0:
                     return Answer(action=AnswerAction.CANCEL)
-                messages, cursor = await hub.poll(
-                    where, cursor, timeout=min(left, self.registry.hub_poll_seconds)
-                )
-                for message in messages:
-                    reply = message.get("reply")
+                for event in await replies.poll(timeout=min(left, replies.wait)):
+                    reply = event.message.get("reply")
                     if isinstance(reply, Mapping):
                         return answer_of(reply)
             return Answer(action=AnswerAction.CANCEL)

{aiohttp_tiny_mcp-0.2.6 → aiohttp_tiny_mcp-0.3.0}/src/aiohttp_tiny_mcp/http_sse.py

@@ -24,7 +24,7 @@ from .core import (
 from .dispatcher import Dispatcher
 from .endpoint import Endpoint
 from .exchange import Exchange
-from .hub import topic
+from .hub import Subscription, topic
 from .namespaces import scoped
 from .protocol.selection import AdapterSet
 from .registry import Registry
@@ -103,7 +103,7 @@ class SseEndpoint:
         session_id = await self.open_session()
         where = topic(STREAM, session_id)
         hub = self.registry.hub
-        cursor = await hub.position(where)
+        events = await hub.subscribe(where, wait=self.registry.hub_poll_seconds)
 
         response = SSEResponse(compress=self.compress)
         await response.prepare(request)
@@ -111,7 +111,7 @@ class SseEndpoint:
         await self.write(response, "endpoint", f"{posting}?session_id={session_id}")
 
         try:
-            await self.relay_until_disconnect(request, response, where, cursor)
+            await self.relay_until_disconnect(request, response, events)
         finally:
             await hub.delete(where)
             await self.registry.session_store.delete(scoped(session_id))
@@ -128,10 +128,10 @@ class SseEndpoint:
         return session_id
 
     async def relay_until_disconnect(
-        self, request: web.Request, response: SSEResponse, where: str, cursor: str
+        self, request: web.Request, response: SSEResponse, events: Subscription
     ) -> None:
         """Run a relay until its client disconnects, then always join it."""
-        relay = asyncio.create_task(self.relay(response, where, cursor))
+        relay = asyncio.create_task(self.relay(response, events))
         try:
             while not relay.done():
                 await asyncio.wait({relay}, timeout=0.05)
@@ -143,13 +143,10 @@ class SseEndpoint:
             with suppress(asyncio.CancelledError, ConnectionError):
                 await relay
 
-    async def relay(self, response: SSEResponse, where: str, cursor: str) -> None:
+    async def relay(self, response: SSEResponse, events: Subscription) -> None:
         """Write everything published for this connection, until cancelled."""
-        hub = self.registry.hub
-        while True:
-            messages, cursor = await hub.poll(where, cursor, timeout=self.registry.hub_poll_seconds)
-            for payload in messages:
-                await self.write(response, "message", json.dumps(payload, ensure_ascii=False))
+        async for event in events:
+            await self.write(response, "message", json.dumps(event.message, ensure_ascii=False))
 
     async def write(self, response: SSEResponse, event: str, data: str) -> None:
         log.debug("-> [%s] %s %s", VERSION, event, data)

aiohttp_tiny_mcp-0.3.0/src/aiohttp_tiny_mcp/hub.py

@@ -0,0 +1,169 @@
+"""Cursor-based event storage shared by reply and notification streams.
+
+Applications supply the backend; MemoryHub serves one process. Shared storage lets one node
+publish replies that another is awaiting.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from abc import abstractmethod
+from collections.abc import AsyncIterator, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any, Protocol, runtime_checkable
+
+from .namespaces import scoped
+
+Cursor = str
+
+START: Cursor = ""
+
+NOTIFICATIONS = "notifications"
+
+ASK = "ask"
+
+MEMORY_KEEP = 1000
+
+
+@dataclass(frozen=True, slots=True)
+class Event:
+    """One published message and its id. The id is the cursor after it."""
+
+    id: Cursor
+    message: Mapping[str, Any]
+
+
+class Subscription:
+    """A reader of one topic that keeps its own place. Made by `Hub.subscribe`."""
+
+    def __init__(
+        self, hub: Hub, topic: str, cursor: Cursor, *, wait: float, pending: Sequence[Event] = ()
+    ) -> None:
+        self.hub = hub
+        self.topic = topic
+        self.cursor = cursor
+        self.wait = wait
+        self.pending = pending
+
+    async def poll(self, *, timeout: float | None = None) -> Sequence[Event]:
+        """Events since the last call. Wait up to `timeout`, or `wait` when None."""
+        events = self.pending
+        self.pending = ()
+        if not events:
+            wait = self.wait if timeout is None else timeout
+            events = await self.hub.poll(self.topic, self.cursor, timeout=wait)
+        if events:
+            self.cursor = events[-1].id
+        return events
+
+    async def __aiter__(self) -> AsyncIterator[Event]:
+        while True:
+            for event in await self.poll():
+                yield event
+
+
+@runtime_checkable
+class Hub(Protocol):
+    """Application-provided event storage.
+
+    Subclass it to have the methods checked and the missing ones refused, or
+    supply any object with these five methods. Readers call `subscribe`; the
+    four abstract methods are the storage it is built on.
+    """
+
+    async def subscribe(
+        self, topic: str, *, after: Cursor | None = None, wait: float = 1.0
+    ) -> Subscription:
+        """Read after `after`, or after now. An unknown `after` raises ValueError."""
+        if after is None:
+            return Subscription(self, topic, await self.position(topic), wait=wait)
+        found = await self.poll(topic, after, timeout=0)
+        return Subscription(self, topic, after, wait=wait, pending=found)
+
+    @abstractmethod
+    async def publish(self, topic: str, message: Mapping[str, Any]) -> Cursor:
+        """Append one message to `topic` and return the id it got."""
+
+    @abstractmethod
+    async def position(self, topic: str) -> Cursor:
+        """Capture the cursor before triggering a publish so replies preceding the first poll are
+        included.
+        """
+
+    @abstractmethod
+    async def poll(self, topic: str, cursor: Cursor, *, timeout: float) -> Sequence[Event]:
+        """Return the events after `cursor`, in order. Wait up to `timeout` for one.
+
+        Raise ValueError for a cursor this hub did not issue.
+        """
+
+    @abstractmethod
+    async def delete(self, topic: str) -> None:
+        """Delete a completed topic."""
+
+
+def topic(kind: str, name: str | None = None) -> str:
+    """Prefix the topic with the current namespace to isolate callers."""
+    return scoped(kind if name is None else f"{kind}/{name}")
+
+
+class MemoryHub(Hub):
+    """Single-process hub. A topic keeps its last `keep` events for replay."""
+
+    def __init__(self, *, keep: int = MEMORY_KEEP) -> None:
+        self.rows: dict[str, list[Event]] = {}
+        self.keep = keep
+        self.last_id = 0
+        self.arrived = asyncio.Condition()
+
+    async def publish(self, topic: str, message: Mapping[str, Any]) -> Cursor:
+        async with self.arrived:
+            self.last_id += 1
+            event = Event(str(self.last_id), dict(message))
+            rows = self.rows.setdefault(topic, [])
+            rows.append(event)
+            del rows[: -self.keep]
+            self.arrived.notify_all()
+        return event.id
+
+    async def position(self, topic: str) -> Cursor:
+        rows = self.rows.get(topic)
+        return rows[-1].id if rows else START
+
+    def after(self, topic: str, cursor: Cursor) -> list[Event]:
+        least = int(cursor) if cursor else 0
+        return [event for event in self.rows.get(topic, []) if int(event.id) > least]
+
+    async def poll(self, topic: str, cursor: Cursor, *, timeout: float) -> Sequence[Event]:
+        loop = asyncio.get_running_loop()
+        deadline = loop.time() + timeout
+        async with self.arrived:
+            while True:
+                found = self.after(topic, cursor)
+                if found:
+                    return found
+                left = deadline - loop.time()
+                if left <= 0:
+                    return []
+                try:
+                    await asyncio.wait_for(self.arrived.wait(), left)
+                except asyncio.TimeoutError:
+                    return []
+
+    async def delete(self, topic: str) -> None:
+        async with self.arrived:
+            self.rows.pop(topic, None)
+
+
+__all__ = [
+    "ASK",
+    "MEMORY_KEEP",
+    "NOTIFICATIONS",
+    "START",
+    "Cursor",
+    "Event",
+    "Hub",
+    "MemoryHub",
+    "Subscription",
+    "topic",
+]

{aiohttp_tiny_mcp-0.2.6 → aiohttp_tiny_mcp-0.3.0}/src/aiohttp_tiny_mcp/postgres.py

@@ -9,7 +9,7 @@ from collections.abc import AsyncIterator, Mapping, Sequence
 from functools import cached_property
 from typing import Any
 
-from .hub import START, Cursor, Hub
+from .hub import START, Cursor, Event, Hub
 from .sessions import SessionRecord, SessionStore
 
 try:
@@ -365,7 +365,7 @@ class PostgresHub(Hub):
             [
                 sql.SQL("INSERT INTO "),
                 self.storage.events_table,
-                sql.SQL(" (topic, message) VALUES (%s, %s)"),
+                sql.SQL(" (topic, message) VALUES (%s, %s) RETURNING id"),
             ]
         )
 
@@ -399,12 +399,17 @@ class PostgresHub(Hub):
             ]
         )
 
-    async def publish(self, topic: str, message: Mapping[str, Any]) -> None:
+    async def publish(self, topic: str, message: Mapping[str, Any]) -> Cursor:
         pool = await self.storage.open()
         async with pool.connection() as connection:
             async with connection.transaction():
                 await connection.execute("SELECT pg_advisory_xact_lock(hashtext(%s))", (topic,))
-                await connection.execute(self._query_publish, (topic, json.dumps(message)))
+                inserted = await connection.execute(
+                    self._query_publish, (topic, json.dumps(message))
+                )
+                row = await inserted.fetchone()
+        assert row is not None
+        return str(row[0])
 
     async def position(self, topic: str) -> Cursor:
         pool = await self.storage.open()
@@ -413,30 +418,26 @@ class PostgresHub(Hub):
             row = await found.fetchone()
         return str(row[0]) if row is not None and row[0] is not None else START
 
-    async def after(self, topic: str, cursor: Cursor) -> tuple[list[Mapping[str, Any]], Cursor]:
-        """Everything published after `cursor`, and where to continue from."""
+    async def after(self, topic: str, cursor: Cursor) -> list[Event]:
+        """Events after `cursor`. The row id is the event id."""
         pool = await self.storage.open()
         async with pool.connection() as connection:
             found = await connection.execute(
                 self._query_after, (topic, int(cursor) if cursor else 0)
             )
             rows = await found.fetchall()
-        if not rows:
-            return [], cursor
-        return [row[1] for row in rows], str(rows[-1][0])
+        return [Event(str(row[0]), row[1]) for row in rows]
 
-    async def poll(
-        self, topic: str, cursor: Cursor, *, timeout: float
-    ) -> tuple[Sequence[Mapping[str, Any]], Cursor]:
+    async def poll(self, topic: str, cursor: Cursor, *, timeout: float) -> Sequence[Event]:
         loop = asyncio.get_running_loop()
         deadline = loop.time() + timeout
         while True:
-            messages, cursor = await self.after(topic, cursor)
-            if messages:
-                return messages, cursor
+            found = await self.after(topic, cursor)
+            if found:
+                return found
             left = deadline - loop.time()
             if left <= 0:
-                return [], cursor
+                return []
             await asyncio.sleep(min(self.look_again, left))
 
     async def delete(self, topic: str) -> None:

{aiohttp_tiny_mcp-0.2.6 → aiohttp_tiny_mcp-0.3.0}/src/aiohttp_tiny_mcp/redis.py

@@ -6,7 +6,7 @@ import json
 from collections.abc import AsyncIterator, Mapping, Sequence
 from typing import Any
 
-from .hub import START, Cursor, Hub
+from .hub import START, Cursor, Event, Hub
 from .sessions import SessionRecord, SessionStore
 
 try:
@@ -156,29 +156,37 @@ class RedisHub(Hub):
     def key(self, topic: str) -> str:
         return f"{self.prefix}:topic:{topic}"
 
-    async def publish(self, topic: str, message: Mapping[str, Any]) -> None:
+    async def publish(self, topic: str, message: Mapping[str, Any]) -> Cursor:
         client = await self.storage.open()
         key = self.key(topic)
-        await client.xadd(key, {"message": json.dumps(message)}, maxlen=self.keep, approximate=True)
+        added: Any = await client.xadd(
+            key, {"message": json.dumps(message)}, maxlen=self.keep, approximate=True
+        )
         await client.expire(key, self.ttl_seconds)
+        return text(added)
 
     async def position(self, topic: str) -> Cursor:
         client = await self.storage.open()
         last: Any = await client.xrevrange(self.key(topic), count=1)
         return text(last[0][0]) if last else START
 
-    async def poll(
-        self, topic: str, cursor: Cursor, *, timeout: float
-    ) -> tuple[Sequence[Mapping[str, Any]], Cursor]:
+    async def poll(self, topic: str, cursor: Cursor, *, timeout: float) -> Sequence[Event]:
+        """The stream id is the event id. Redis refuses a malformed one."""
+        from redis.exceptions import ResponseError
+
         client = await self.storage.open()
-        found: Any = await client.xread(
-            {self.key(topic): cursor or BEGINNING}, block=max(1, int(timeout * 1000))
-        )
+        try:
+            found: Any = await client.xread(
+                {self.key(topic): cursor or BEGINNING}, block=max(1, int(timeout * 1000))
+            )
+        except ResponseError as e:
+            raise ValueError(f"not a stream id: {cursor!r}") from e
         if not found:
-            return [], cursor
-        entries = found[0][1]
-        messages = [json.loads(next(iter(fields.values()))) for _, fields in entries]
-        return messages, text(entries[-1][0])
+            return []
+        return [
+            Event(text(entry_id), json.loads(next(iter(fields.values()))))
+            for entry_id, fields in found[0][1]
+        ]
 
     async def delete(self, topic: str) -> None:
         client = await self.storage.open()

{aiohttp_tiny_mcp-0.2.6 → aiohttp_tiny_mcp-0.3.0}/src/aiohttp_tiny_mcp/registry.py

@@ -41,6 +41,7 @@ class Registry:
         request_state_ttl_seconds: int = STATE_TTL_SECONDS,
         hub_poll_seconds: float = 30.0,
         ask_timeout_seconds: float = 120.0,
+        page_size: int | None = None,
     ) -> None:
         self.info = Implementation(name=name, version=version)
         self.instructions = instructions
@@ -48,6 +49,8 @@ class Registry:
         self.session_store = session_store if session_store is not None else MemorySessionStore()
         self.auth = auth
         self.session_ttl_seconds = session_ttl_seconds
+        #: Most entries per listing page. `None`, the default, answers with all of them.
+        self.page_size = page_size
         self.request_state = RequestStates(self.session_store, request_state_ttl_seconds)
         self.hub_poll_seconds = hub_poll_seconds
         self.ask_timeout_seconds = ask_timeout_seconds

{aiohttp_tiny_mcp-0.2.6 → aiohttp_tiny_mcp-0.3.0}/src/aiohttp_tiny_mcp/sqlite.py

@@ -10,7 +10,7 @@ from contextlib import suppress
 from pathlib import Path
 from typing import Any
 
-from .hub import START, Cursor, Hub
+from .hub import START, Cursor, Event, Hub
 from .sessions import SessionRecord, SessionStore
 
 try:
@@ -181,12 +181,13 @@ class SqliteHub(Hub):
         if look_again is not None:
             self.look_again = look_again
 
-    async def publish(self, topic: str, message: Mapping[str, Any]) -> None:
+    async def publish(self, topic: str, message: Mapping[str, Any]) -> Cursor:
         connection = await self.storage.open()
-        await connection.execute(
+        async with connection.execute(
             f"INSERT INTO mcp_events (topic, message, created_at) VALUES (?, ?, {NOW})",
             (topic, json.dumps(message)),
-        )
+        ) as inserted:
+            return str(inserted.lastrowid)
 
     async def position(self, topic: str) -> Cursor:
         connection = await self.storage.open()
@@ -196,30 +197,26 @@ class SqliteHub(Hub):
             row = await cursor.fetchone()
         return str(row[0]) if row is not None and row[0] is not None else START
 
-    async def after(self, topic: str, cursor: Cursor) -> tuple[list[Mapping[str, Any]], Cursor]:
-        """Everything published after `cursor`, and where to continue from."""
+    async def after(self, topic: str, cursor: Cursor) -> list[Event]:
+        """Events after `cursor`. The row id is the event id."""
         connection = await self.storage.open()
         async with connection.execute(
             "SELECT id, message FROM mcp_events WHERE topic = ? AND id > ? ORDER BY id",
             (topic, int(cursor) if cursor else 0),
         ) as rows:
-            found = list(await rows.fetchall())
-        if not found:
-            return [], cursor
-        return [json.loads(row[1]) for row in found], str(found[-1][0])
-
-    async def poll(
-        self, topic: str, cursor: Cursor, *, timeout: float
-    ) -> tuple[Sequence[Mapping[str, Any]], Cursor]:
+            found = await rows.fetchall()
+        return [Event(str(row[0]), json.loads(row[1])) for row in found]
+
+    async def poll(self, topic: str, cursor: Cursor, *, timeout: float) -> Sequence[Event]:
         loop = asyncio.get_running_loop()
         deadline = loop.time() + timeout
         while True:
-            messages, cursor = await self.after(topic, cursor)
-            if messages:
-                return messages, cursor
+            found = await self.after(topic, cursor)
+            if found:
+                return found
             left = deadline - loop.time()
             if left <= 0:
-                return [], cursor
+                return []
             await asyncio.sleep(min(self.look_again, left))
 
     async def delete(self, topic: str) -> None:

{aiohttp_tiny_mcp-0.2.6 → aiohttp_tiny_mcp-0.3.0}/src/aiohttp_tiny_mcp/subscriptions.py

@@ -69,14 +69,12 @@ async def listen(ex: Exchange) -> EmptyResult:
         await ex.emit(ack)
         return EmptyResult(meta=Meta.model_validate({SUBSCRIPTION_ID: ex.id}))
 
-    topic = hubs.topic(hubs.NOTIFICATIONS)
-    cursor = await hub.position(topic)
+    events = await hub.subscribe(hubs.topic(hubs.NOTIFICATIONS), wait=ex.registry.hub_poll_seconds)
     await ex.emit(ack)
     while not ex.cancelled.is_set():
-        messages, cursor = await hub.poll(topic, cursor, timeout=ex.registry.hub_poll_seconds)
-        for payload in messages:
-            if relays(payload, accepted):
-                await ex.emit(tag(payload, ex.id))
+        for event in await events.poll():
+            if relays(event.message, accepted):
+                await ex.emit(tag(event.message, ex.id))
     return EmptyResult(meta=Meta.model_validate({SUBSCRIPTION_ID: ex.id}))
 
 

aiohttp_tiny_mcp-0.2.6/src/aiohttp_tiny_mcp/hub.py

@@ -1,109 +0,0 @@
-"""Cursor-based event storage shared by reply and notification streams.
-
-Applications supply the backend; MemoryHub serves one process. Shared storage lets one node
-publish replies that another is awaiting.
-"""
-
-from __future__ import annotations
-
-import asyncio
-from abc import abstractmethod
-from collections.abc import Mapping, Sequence
-from typing import Any, Protocol, runtime_checkable
-
-from .namespaces import scoped
-
-Cursor = str
-
-START: Cursor = ""
-
-NOTIFICATIONS = "notifications"
-
-ASK = "ask"
-
-
-@runtime_checkable
-class Hub(Protocol):
-    """Application-provided event storage.
-
-    Subclass it to have the methods checked and the missing ones refused, or
-    supply any object with these four methods: this is a protocol, so a
-    backend that inherits nothing is still a Hub.
-    """
-
-    @abstractmethod
-    async def publish(self, topic: str, message: Mapping[str, Any]) -> None:
-        """Append one message to `topic`."""
-
-    @abstractmethod
-    async def position(self, topic: str) -> Cursor:
-        """Capture the cursor before triggering a publish so replies preceding the first poll are
-        included.
-        """
-
-    @abstractmethod
-    async def poll(
-        self, topic: str, cursor: Cursor, *, timeout: float
-    ) -> tuple[Sequence[Mapping[str, Any]], Cursor]:
-        """Return messages after cursor and the next cursor.
-
-        Wait up to timeout seconds for a message. Backends choose whether to poll or wait for
-        notification; timeout is a deadline, not a polling interval.
-        """
-
-    @abstractmethod
-    async def delete(self, topic: str) -> None:
-        """Delete a completed topic."""
-
-
-def topic(kind: str, name: str | None = None) -> str:
-    """Prefix the topic with the current namespace to isolate callers."""
-    return scoped(kind if name is None else f"{kind}/{name}")
-
-
-class MemoryHub(Hub):
-    """Single-process hub, waiting on a condition rather than sleeping."""
-
-    def __init__(self) -> None:
-        self.rows: dict[str, list[tuple[int, Mapping[str, Any]]]] = {}
-        self.last_id = 0
-        self.arrived = asyncio.Condition()
-
-    async def publish(self, topic: str, message: Mapping[str, Any]) -> None:
-        async with self.arrived:
-            self.last_id += 1
-            self.rows.setdefault(topic, []).append((self.last_id, dict(message)))
-            self.arrived.notify_all()
-
-    async def position(self, topic: str) -> Cursor:
-        rows = self.rows.get(topic)
-        return str(rows[-1][0]) if rows else START
-
-    def after(self, topic: str, cursor: Cursor) -> list[tuple[int, Mapping[str, Any]]]:
-        least = int(cursor) if cursor else 0
-        return [row for row in self.rows.get(topic, []) if row[0] > least]
-
-    async def poll(
-        self, topic: str, cursor: Cursor, *, timeout: float
-    ) -> tuple[Sequence[Mapping[str, Any]], Cursor]:
-        loop = asyncio.get_running_loop()
-        deadline = loop.time() + timeout
-        async with self.arrived:
-            while True:
-                found = self.after(topic, cursor)
-                if found:
-                    return [message for _, message in found], str(found[-1][0])
-                left = deadline - loop.time()
-                if left <= 0:
-                    return [], cursor
-                try:
-                    await asyncio.wait_for(self.arrived.wait(), left)
-                except asyncio.TimeoutError:
-                    return [], cursor
-
-    async def delete(self, topic: str) -> None:
-        async with self.arrived:
-            self.rows.pop(topic, None)
-
-
-__all__ = ["ASK", "NOTIFICATIONS", "START", "Cursor", "Hub", "MemoryHub", "topic"]