Implement SSE server transport with per-factory session registry (#215)

MCP's SSE transport splits each JSON-RPC request/response across two
TCP connections on the server: a long-lived GET {sse_path} stream, and
short POST /callback/{session_id} connections that carry the request
body. The server returns 202 Accepted on the POST and routes the real
JSON-RPC response back through the SSE stream registered under the
matching session ID. This commit lands the server side of that dance
inside HttpSseJsonRpcProtocolFilter.

Design notes:

- SseSessionRegistry is owned by HttpSseFilterChainFactory, not a
  process-wide singleton. The upstream draft used a global singleton
  with a std::mutex; that conflicts with the project rule to prefer
  state machines and dispatcher-thread invariants over mutex-guarded
  shared state, leaks session IDs across McpServer instances in the
  same process, and encourages cross-thread connection.write() calls.
  A per-factory registry keeps lifetime bounded by the server, and
  since all filter callbacks on a given server already fire on one
  dispatcher thread, the map needs no lock — only an assert on each
  public method to keep that invariant honest if someone later splits
  the server across workers.

- The filter, not the registry, holds the session-ID-to-connection
  binding lifecycle: registerSession in onHeaders for GET {sse_path},
  removeSession in the filter destructor when the SSE stream connection
  tears down. The destructor runs on the dispatcher thread per the
  filter/connection contract, so a POST /callback arriving between
  "SSE connection closed" and "filter destructed" is handled by an
  already-empty registry lookup returning false — no use-after-free
  window.

- onHeaders sends the SSE prelude (HTTP 200 + text/event-stream headers
  + the "event: endpoint" line) via connection().write() inline, same
  for the POST's 202 Accepted. A sse_writing_handshake_ pass-through
  flag keeps our own onWrite from re-framing those raw bytes as an SSE
  event when the write chain calls back into us — the alternative
  (posting through the dispatcher) would race the client reading the
  handshake before we could register the session in the registry.

- onWrite intercepts the JSON-RPC response when sse_callback_session_id_
  is set, drains the buffer, hands the JSON to the registry, and
  returns StopIteration so the response doesn't get written back to
  the POST connection (which already got its 202).

- The filter ctor gains four trailing defaulted params (sse_path,
  rpc_path, external_url, SseSessionRegistry*). All four default to
  the values that match pre-existing behavior, so no caller that
  doesn't care about SSE server transport needs to change.

- Factory ctor/destructor are moved out-of-line so the unique_ptr
  member of the forward-declared SseSessionRegistry class compiles
  cleanly from the header.

The existing HttpSse/HttpsSse/SseCodec/HttpCodecSse test suite (10
cases) continues to pass unchanged — the new transport is opt-in via
the GET {sse_path} / POST /callback/{id} URL pattern and back-compat
factories that don't use either path see no behavioral change.
Integration test for the new round-trip lands in the next commit.

Author: gophergogo

include/mcp/filter/http_sse_filter_chain_factory.h

@@ -18,6 +18,7 @@ class McpProtocolCallbacks;
 namespace filter {
 class HttpRoutingFilter;
 class MetricsFilter;
+class SseSessionRegistry;
 }  // namespace filter
 }  // namespace mcp
 
@@ -83,16 +84,11 @@ class HttpSseFilterChainFactory : public network::FilterChainFactory {
                             bool use_sse = true,
                             const std::string& sse_path = "/sse",
                             const std::string& rpc_path = "/mcp",
-                            const std::string& external_url = "")
-      : dispatcher_(dispatcher),
-        message_callbacks_(message_callbacks),
-        is_server_(is_server),
-        http_path_(http_path),
-        http_host_(http_host),
-        use_sse_(use_sse),
-        sse_path_(sse_path),
-        rpc_path_(rpc_path),
-        external_url_(external_url) {}
+                            const std::string& external_url = "");
+
+  // Destructor defined out-of-line so the unique_ptr<SseSessionRegistry>
+  // member can use the incomplete forward-declared type in this header.
+  ~HttpSseFilterChainFactory();
 
   /**
    * Create filter chain for the connection
@@ -189,6 +185,16 @@ class HttpSseFilterChainFactory : public network::FilterChainFactory {
   std::string external_url_;  // External URL for absolute SSE callback URLs
   mutable bool enable_metrics_ = true;  // Enable metrics by default
 
+  // SSE session registry — maps session IDs to the connections that are
+  // streaming SSE to each client, so POST /callback/{id} handlers can
+  // route a JSON-RPC response back through the correct stream. Lazily
+  // constructed on the first server-side filter chain creation; stays
+  // null for client-mode factories. Owned here (not a global singleton)
+  // so each McpServer instance has an isolated registry and lifetime is
+  // bounded by the factory, not process lifetime. Mutable because
+  // createFilterChain is const on the base class.
+  mutable std::unique_ptr<SseSessionRegistry> sse_registry_;
+
   // Store filters for lifetime management
   mutable std::vector<network::FilterSharedPtr> filters_;