feat(http): enforce required per-request _meta on the 2026 stateless path (P1)

The audit (+ codex review) flagged a conformance gap: the schema makes
RequestParams._meta REQUIRED (RequestMetaObject with protocolVersion/clientInfo/
clientCapabilities) and the Base Protocol MUSTs -32602/HTTP-400 on missing required
fields and on header/body protocol-version disagreement, but the 2026 server parsed
_meta loosely and never rejected. Now the 2026 transport path validates every
JsonRpcMessage::Request before dispatch: missing params._meta, a missing required
RequestMetaObject key, or an _meta.protocolVersion that disagrees with the
MCP-Protocol-Version header all return JSON-RPC -32602 at HTTP 400. Enforcement is
2026-only; 2025-11-25 is unaffected. Our bilingual client already attaches complete
_meta on every 2026 request (incl. the server/discover probe), so negotiation is
unchanged.

Tests: discover_stateless_2026 gains 3 negative-path wire cases (missing _meta;
missing clientCapabilities; header/body version mismatch) → all assert HTTP 400 +
-32602. Revert-and-fail recorded: stashing the enforcement makes missing_meta fail
(request gets 200). The enforcement surfaced two lambda lifecycle tests sending
un-_meta'd tools/list under 2026 — gated 2025-only (they exercise the removed
initialize/initialized handshake) along with their now-2025-only fixtures.

Default suite: 0 failures, 0 warnings (build + test). Lambda 2025: 105 pass.

Author: hortovanyi

crates/turul-http-mcp-server/src/streamable_http.rs

@@ -1437,11 +1437,62 @@ impl StreamableHttpHandler {
             }
         };
 
-        // DRAFT-2026-v1 stateless core: there is no Mcp-Session-Id handshake, so a
-        // request is never rejected for lacking a session. Use a client-pinned
-        // session if one was supplied, otherwise mint an ephemeral session so the
-        // dispatch pipeline (which carries a SessionContext) proceeds unchanged; the
-        // client neither sends nor needs a session id.
+        // 2026-07-28: every request MUST carry a per-request `_meta` (RequestMetaObject)
+        // with protocolVersion/clientInfo/clientCapabilities (schema: RequestParams._meta
+        // is required), and its protocolVersion MUST match the MCP-Protocol-Version header.
+        // Reject -32602 (HTTP 400) on a missing/incomplete `_meta` or a header/body mismatch.
+        #[cfg(feature = "protocol-2026-07-28")]
+        if let JsonRpcMessage::Request(req) = &message {
+            let v = serde_json::to_value(req).unwrap_or(serde_json::Value::Null);
+            let header_version = context.protocol_version.as_str();
+            let reason = match v.get("params").and_then(|p| p.get("_meta")) {
+                Some(meta) if meta.is_object() => {
+                    let pv = meta
+                        .get("io.modelcontextprotocol/protocolVersion")
+                        .and_then(|x| x.as_str());
+                    if pv.is_none() {
+                        Some("missing required _meta.io.modelcontextprotocol/protocolVersion".to_string())
+                    } else if meta.get("io.modelcontextprotocol/clientInfo").is_none() {
+                        Some("missing required _meta.io.modelcontextprotocol/clientInfo".to_string())
+                    } else if meta.get("io.modelcontextprotocol/clientCapabilities").is_none() {
+                        Some("missing required _meta.io.modelcontextprotocol/clientCapabilities".to_string())
+                    } else if pv != Some(header_version) {
+                        Some(format!(
+                            "_meta protocolVersion '{}' disagrees with MCP-Protocol-Version header '{}'",
+                            pv.unwrap_or(""),
+                            header_version
+                        ))
+                    } else {
+                        None
+                    }
+                }
+                _ => Some("missing required params._meta (RequestMetaObject)".to_string()),
+            };
+            if let Some(reason) = reason {
+                warn!("Rejecting 2026 request (method={}): {}", req.method, reason);
+                let err = turul_mcp_json_rpc_server::JsonRpcError::new(
+                    Some(req.id.clone()),
+                    turul_mcp_json_rpc_server::error::JsonRpcErrorObject::invalid_params(&reason),
+                );
+                let body = serde_json::to_string(&err).unwrap_or_else(|_| "{}".to_string());
+                return Response::builder()
+                    .status(StatusCode::BAD_REQUEST)
+                    .header(CONTENT_TYPE, "application/json")
+                    .header("MCP-Protocol-Version", header_version)
+                    .body(
+                        Full::new(Bytes::from(body))
+                            .map_err(|never| match never {})
+                            .boxed_unsync(),
+                    )
+                    .unwrap();
+            }
+        }
+
+        // The stateless core has no Mcp-Session-Id handshake, so a request is never
+        // rejected for lacking a session. Use a client-pinned session if one was
+        // supplied, otherwise mint an ephemeral session so the dispatch pipeline (which
+        // carries a SessionContext) proceeds unchanged; the client neither sends nor
+        // needs a session id.
         #[cfg(feature = "protocol-2026-07-28")]
         let session_id = match &context.session_id {
             Some(existing_id) => existing_id.clone(),

crates/turul-mcp-aws-lambda/src/handler.rs

@@ -915,6 +915,7 @@ mod tests {
     // ── Strict lifecycle tests over handle_streaming() ────────────────
 
     /// Helper: build a Lambda handler with strict lifecycle and a test tool via the builder.
+    #[cfg(feature = "protocol-2025-11-25")]
     async fn build_strict_streaming_handler() -> LambdaMcpHandler {
         use crate::LambdaMcpServerBuilder;
         use turul_mcp_session_storage::InMemorySessionStorage;
@@ -934,45 +935,55 @@ mod tests {
     }
 
     // Test tool for lifecycle tests — satisfies all required traits
+    #[cfg(feature = "protocol-2025-11-25")]
     #[derive(Clone, Default)]
     struct LifecycleTestTool;
 
+    #[cfg(feature = "protocol-2025-11-25")]
     impl turul_mcp_builders::traits::HasBaseMetadata for LifecycleTestTool {
         fn name(&self) -> &str {
             "ping_tool"
         }
     }
+    #[cfg(feature = "protocol-2025-11-25")]
     impl turul_mcp_builders::traits::HasDescription for LifecycleTestTool {
         fn description(&self) -> Option<&str> {
             Some("test tool")
         }
     }
+    #[cfg(feature = "protocol-2025-11-25")]
     impl turul_mcp_builders::traits::HasInputSchema for LifecycleTestTool {
         fn input_schema(&self) -> &turul_mcp_protocol::ToolSchema {
             static SCHEMA: std::sync::OnceLock<turul_mcp_protocol::ToolSchema> =
                 std::sync::OnceLock::new();
             SCHEMA.get_or_init(turul_mcp_protocol::ToolSchema::object)
         }
     }
+    #[cfg(feature = "protocol-2025-11-25")]
     impl turul_mcp_builders::traits::HasOutputSchema for LifecycleTestTool {
         fn output_schema(&self) -> Option<&turul_mcp_protocol::ToolSchema> {
             None
         }
     }
+    #[cfg(feature = "protocol-2025-11-25")]
     impl turul_mcp_builders::traits::HasAnnotations for LifecycleTestTool {
         fn annotations(&self) -> Option<&turul_mcp_protocol::tools::ToolAnnotations> {
             None
         }
     }
+    #[cfg(feature = "protocol-2025-11-25")]
     impl turul_mcp_builders::traits::HasToolMeta for LifecycleTestTool {
         fn tool_meta(&self) -> Option<&std::collections::HashMap<String, serde_json::Value>> {
             None
         }
     }
+    #[cfg(feature = "protocol-2025-11-25")]
     impl turul_mcp_builders::traits::HasIcons for LifecycleTestTool {}
+    #[cfg(feature = "protocol-2025-11-25")]
     impl turul_mcp_builders::traits::HasExecution for LifecycleTestTool {}
 
     #[async_trait::async_trait]
+    #[cfg(feature = "protocol-2025-11-25")]
     impl turul_mcp_server::McpTool for LifecycleTestTool {
         async fn call(
             &self,
@@ -986,6 +997,7 @@ mod tests {
     }
 
     /// Helper: create a Lambda POST request for handle_streaming()
+    #[cfg(feature = "protocol-2025-11-25")]
     fn streaming_mcp_request(body: &str, session_id: Option<&str>) -> LambdaRequest {
         let mut builder = Request::builder()
             .method("POST")
@@ -1002,6 +1014,7 @@ mod tests {
     }
 
     /// Helper: collect streaming response body into a string
+    #[cfg(feature = "protocol-2025-11-25")]
     async fn collect_streaming_body(
         response: lambda_http::Response<
             http_body_util::combinators::UnsyncBoxBody<bytes::Bytes, hyper::Error>,
@@ -1026,6 +1039,7 @@ mod tests {
     }
 
     /// Helper: extract session ID from a streaming response
+    #[cfg(feature = "protocol-2025-11-25")]
     fn extract_session_id(
         response: &lambda_http::Response<
             http_body_util::combinators::UnsyncBoxBody<bytes::Bytes, hyper::Error>,
@@ -1039,6 +1053,7 @@ mod tests {
     }
 
     /// Helper: parse JSON from a response body (handles SSE "data: " prefix)
+    #[cfg(feature = "protocol-2025-11-25")]
     fn parse_response_json(body: &str) -> serde_json::Value {
         // Strip SSE framing if present
         let json_str = body
@@ -1222,6 +1237,9 @@ mod tests {
     }
 
     /// P0: tools/list succeeds immediately after notifications/initialized (race fix proof)
+    // The initialize/initialized handshake is 2025-11-25 only; the 2026-07-28 stateless
+    // core has no handshake and requires a per-request _meta on tools/list.
+    #[cfg(feature = "protocol-2025-11-25")]
     #[tokio::test]
     async fn test_lambda_streaming_initialized_is_effective_immediately() {
         let handler = build_strict_streaming_handler().await;
@@ -1279,6 +1297,7 @@ mod tests {
     }
 
     /// P1: Lenient mode allows operations without notifications/initialized
+    #[cfg(feature = "protocol-2025-11-25")]
     #[tokio::test]
     async fn test_lambda_streaming_lenient_mode_allows_without_initialized() {
         use crate::LambdaMcpServerBuilder;

crates/turul-mcp-server/tests/discover_stateless_2026.rs

@@ -194,3 +194,67 @@ async fn prompts_list_dispatches_statelessly_with_cacheable_result() {
     assert!(body["result"]["cacheScope"].is_string(), "missing cacheScope: {body}");
     assert!(body["result"]["prompts"].is_array(), "missing prompts array: {body}");
 }
+
+/// POST `body`, asserting the 2026 server rejects it with HTTP 400 + JSON-RPC -32602.
+async fn assert_rejected_invalid_params(url: &str, header_version: Option<&str>, body: serde_json::Value) {
+    let client = reqwest::Client::new();
+    let mut req = client.post(url).header("Accept", "application/json");
+    if let Some(v) = header_version {
+        req = req.header("MCP-Protocol-Version", v);
+    }
+    let resp = req.json(&body).send().await.expect("POST");
+    assert_eq!(resp.status(), 400, "must be rejected with HTTP 400: {body}");
+    let out: serde_json::Value = resp.json().await.expect("json body");
+    assert_eq!(out["error"]["code"], -32602, "must be JSON-RPC -32602: {out}");
+}
+
+#[tokio::test]
+async fn missing_meta_is_rejected_with_invalid_params() {
+    let url = start_server().await;
+    // 2026 requires params._meta on every request — a tools/call without it is invalid.
+    assert_rejected_invalid_params(
+        &url,
+        None,
+        serde_json::json!({
+            "jsonrpc": "2.0", "id": 1, "method": "tools/call",
+            "params": { "name": "echo", "arguments": { "message": "hi" } }
+        }),
+    )
+    .await;
+}
+
+#[tokio::test]
+async fn incomplete_meta_missing_client_capabilities_is_rejected() {
+    let url = start_server().await;
+    assert_rejected_invalid_params(
+        &url,
+        None,
+        serde_json::json!({
+            "jsonrpc": "2.0", "id": 1, "method": "tools/call",
+            "params": {
+                "_meta": {
+                    "io.modelcontextprotocol/protocolVersion": "2026-07-28",
+                    "io.modelcontextprotocol/clientInfo": { "name": "t", "version": "1.0.0" }
+                    // missing io.modelcontextprotocol/clientCapabilities
+                },
+                "name": "echo", "arguments": { "message": "hi" }
+            }
+        }),
+    )
+    .await;
+}
+
+#[tokio::test]
+async fn header_body_protocol_version_mismatch_is_rejected() {
+    let url = start_server().await;
+    // _meta says 2026-07-28 (via meta()); the MCP-Protocol-Version header says 2025-11-25.
+    assert_rejected_invalid_params(
+        &url,
+        Some("2025-11-25"),
+        serde_json::json!({
+            "jsonrpc": "2.0", "id": 1, "method": "tools/call",
+            "params": { "_meta": meta(), "name": "echo", "arguments": { "message": "hi" } }
+        }),
+    )
+    .await;
+}