Add Middleware handlers to StreamableHttpTransport

Author: sveneld

src/Server/Transport/Http/MiddlewareRequestHandler.php

@@ -0,0 +1,46 @@
+<?php
+
+/*
+ * This file is part of the official PHP MCP SDK.
+ *
+ * A collaboration between Symfony and the PHP Foundation.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Mcp\Server\Transport\Http;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+/**
+ * A request handler that processes a middleware pipeline before dispatching
+ * the request to the core transport handler.
+ *
+ * @author Volodymyr Panivko <sveneld300@gmail.com>
+ * @internal
+ */
+class MiddlewareRequestHandler implements RequestHandlerInterface
+{
+    /**
+     * @param list<MiddlewareInterface> $middleware
+     */
+    public function __construct(
+        private array $middleware,
+        private \Closure $application,
+    ) {
+    }
+
+    public function handle(ServerRequestInterface $request): ResponseInterface
+    {
+        $middleware = array_shift($this->middleware);
+        if (null === $middleware) {
+            return ($this->application)($request);
+        }
+
+        return $middleware->process($request, $this);
+    }
+}

src/Server/Transport/StreamableHttpTransport.php

@@ -12,7 +12,9 @@
 namespace Mcp\Server\Transport;
 
 use Http\Discovery\Psr17FactoryDiscovery;
+use Mcp\Exception\InvalidArgumentException;
 use Mcp\Schema\JsonRpc\Error;
+use Mcp\Server\Transport\Http\MiddlewareRequestHandler;
 use Psr\Http\Message\ResponseFactoryInterface;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
@@ -39,19 +41,19 @@ class StreamableHttpTransport extends BaseTransport
     private array $corsHeaders;
 
     /** @var list<MiddlewareInterface> */
-    private array $middlewares = [];
+    private array $middleware = [];
 
     /**
-     * @param array<string, string> $corsHeaders
-     * @param iterable<MiddlewareInterface> $middlewares
+     * @param array<string, string>         $corsHeaders
+     * @param iterable<MiddlewareInterface> $middleware
      */
     public function __construct(
         private ServerRequestInterface $request,
         ?ResponseFactoryInterface $responseFactory = null,
         ?StreamFactoryInterface $streamFactory = null,
         array $corsHeaders = [],
         ?LoggerInterface $logger = null,
-        iterable $middlewares = [],
+        iterable $middleware = [],
     ) {
         parent::__construct($logger);
 
@@ -65,11 +67,11 @@ public function __construct(
             'Access-Control-Expose-Headers' => 'Mcp-Session-Id',
         ], $corsHeaders);
 
-        foreach ($middlewares as $middleware) {
-            if (!$middleware instanceof MiddlewareInterface) {
-                throw new \InvalidArgumentException('Streamable HTTP middleware must implement Psr\\Http\\Server\\MiddlewareInterface.');
+        foreach ($middleware as $m) {
+            if (!$m instanceof MiddlewareInterface) {
+                throw new InvalidArgumentException('Streamable HTTP middleware must implement Psr\\Http\\Server\\MiddlewareInterface.');
             }
-            $this->middlewares[] = $middleware;
+            $this->middleware[] = $m;
         }
     }
 
@@ -289,32 +291,9 @@ private function createRequestHandler(): RequestHandlerInterface
         /**
          * @see self::handleRequest
          */
-        $handler = new class(\Closure::fromCallable([$this, 'handleRequest'])) implements RequestHandlerInterface {
-            public function __construct(private \Closure $handler)
-            {
-            }
-
-            public function handle(ServerRequestInterface $request): ResponseInterface
-            {
-                return ($this->handler)($request);
-            }
-        };
-
-        foreach (array_reverse($this->middlewares) as $middleware) {
-            $handler = new class($middleware, $handler) implements RequestHandlerInterface {
-                public function __construct(
-                    private MiddlewareInterface $middleware,
-                    private RequestHandlerInterface $handler,
-                ) {
-                }
-
-                public function handle(ServerRequestInterface $request): ResponseInterface
-                {
-                    return $this->middleware->process($request, $this->handler);
-                }
-            };
-        }
-
-        return $handler;
+        return new MiddlewareRequestHandler(
+            $this->middleware,
+            \Closure::fromCallable([$this, 'handleRequest']),
+        );
     }
 }