class Middleware[P = Never, R = Never, LE = Never]
Composable MCP middleware.
P is what it provides the handlers inside it, R what it needs:
per request (from middleware outside it, or the transport) and to be
built, in one parameter, as a union of two defaulted parameters widens to
Unknown. LE is what building it may fail with. layer claims
P for the registrations it is provided to: Python has no request-level
marker types, so a request-level service is the service itself.
Attributes#
| Attribute | Type | Description |
|---|---|---|
layer | Layer[P, LE, R] = cast('Any', stacked) | Runs the middleware around the registrations it is provided to. |
layer_global | Layer[P, LE, R | McpServer] = cast('Any', effect_discard(install).pipe(provide(stacked))) | Runs the middleware around every request of the server, once even when it is also provided locally (at its outermost place). |
Functions#
__init__#
__init__(fn_layer, dependencies=None) -> None| Parameter | Type | Description |
|---|---|---|
fn_layer | Layer[Any, Any, Any] | |
dependencies | Layer[Any, Any, Any] | None = None |
def __init__(
self, fn_layer: Layer[Any, Any, Any], dependencies: Layer[Any, Any, Any] | None = None
) -> None:
self._fn_layer = fn_layer
self._dependencies = dependencies
stack_tag = new_stack_tag()
def build(context: Context[Any]) -> Effect[Context[Any], Any, Any]:
stack: tuple[AnyMiddlewareFn, ...] = (context.get_unsafe(_FnTag),)
if dependencies is None:
return succeed(Context({stack_tag: stack}))
found, memo = context.lookup(CurrentMemoMap)
built = dependencies.build_with_memo_map(
memo if found else fork_or_create(context), context.get_unsafe(Scope)
)
return built.map(lambda deps: Context({stack_tag: (*stack, *middleware_of(deps))}))
stacked: Layer[Any, Any, Any] = effect_context(fx_context().flat_map(build)).pipe(
provide(fn_layer)
)
@gen
def install():
server = yield from McpServer()
built: Context[Any] = yield from fx_context()
stack = built.get_unsafe(stack_tag)
def add() -> Effect[None]:
return _sync(lambda: server.global_middleware.extend(stack))
def remove(_: object, __: object) -> Effect[None]:
def drop() -> None:
for fn in stack:
if fn in server.global_middleware:
server.global_middleware.remove(fn)
return _sync(drop)
yield from acquire_release(add(), remove)
self.layer = cast("Any", stacked)
self.layer_global = cast("Any", effect_discard(install).pipe(provide(stacked)))combine#
combine[P2, R2, LE2](other: Middleware[P2, R2, LE2]) -> Middleware[P | P2, R2, LE | LE2]
combine[P2, R2, LE2](other: Middleware[P2, R2, LE2]) -> Middleware[P | P2, R2, LE | LE2]
combine[P2, R2, LE2](other: Middleware[P2, R2, LE2]) -> Middleware[P | P2, R | R2, LE | LE2]This middleware running inside other, which can provide what
it reads.
| Parameter | Type | Description |
|---|---|---|
other |
@overload
def combine[P2, R2, LE2](
self: Middleware[P, Never, LE], other: Middleware[P2, R2, LE2]
) -> Middleware[P | P2, R2, LE | LE2]: ...
@overload
def combine[P2, R2, LE2](
self: Middleware[P, P2, LE], other: Middleware[P2, R2, LE2]
) -> Middleware[P | P2, R2, LE | LE2]: ...
@overload
def combine[P2, R2, LE2](
self, other: Middleware[P2, R2, LE2]
) -> Middleware[P | P2, R | R2, LE | LE2]: ...
def combine(self, other: Middleware[Any, Any, Any]) -> Middleware[Any, Any, Any]:
"""This middleware running inside ``other``, which can provide what
it reads."""
dependencies = (
other.layer
if self._dependencies is None
else self._dependencies.pipe(provide_merge(other.layer))
)
return Middleware(self._fn_layer, dependencies)