GitHub

Middleware

API reference for Middleware.

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

AttributeTypeDescription
layerLayer[P, LE, R] = cast('Any', stacked)

Runs the middleware around the registrations it is provided to.

layer_globalLayer[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
ParameterTypeDescription
fn_layerLayer[Any, Any, Any]
dependenciesLayer[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.

ParameterTypeDescription
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)