From 326f209bc5104e18c287d2dbde5da6a3a8f7438e Mon Sep 17 00:00:00 2001 From: bsodfather Date: Thu, 12 Nov 2026 16:30:34 +0000 Subject: [PATCH] refactor(mcp): route runtime ping through rmcp request and result --- .../crank-community-mcp/src/app/dispatch.rs | 2 +- .../src/app/dispatch_observer.rs | 21 ++ .../src/app/legacy_dispatch.rs | 2 +- .../src/protocol/lifecycle_sdk.rs | 22 +- .../crank-community-mcp/src/protocol/mod.rs | 4 +- .../src/rmcp_ping_runtime_tests.rs | 211 ++++++++++++++++++ docs/development/rmcp-migration-plan.md | 2 + 7 files changed, 260 insertions(+), 4 deletions(-) create mode 100644 crates/crank-community-mcp/src/rmcp_ping_runtime_tests.rs diff --git a/crates/crank-community-mcp/src/app/dispatch.rs b/crates/crank-community-mcp/src/app/dispatch.rs index 57ad2a6..9d92f45 100644 --- a/crates/crank-community-mcp/src/app/dispatch.rs +++ b/crates/crank-community-mcp/src/app/dispatch.rs @@ -121,7 +121,7 @@ pub(super) async fn handle_modern_request( request_id(message), crate::protocol::project_modern_result( version, - json!({ "protocolVersion": version }), + crate::protocol::ping_result(message, version), ), ), response_mode, diff --git a/crates/crank-community-mcp/src/app/dispatch_observer.rs b/crates/crank-community-mcp/src/app/dispatch_observer.rs index 86ba6b5..ca010b6 100644 --- a/crates/crank-community-mcp/src/app/dispatch_observer.rs +++ b/crates/crank-community-mcp/src/app/dispatch_observer.rs @@ -73,12 +73,20 @@ pub(crate) struct CounterSet { sdk_signal_notification: AtomicUsize, sdk_jsonrpc_response: AtomicUsize, sdk_jsonrpc_error: AtomicUsize, + sdk_ping_request: AtomicUsize, + sdk_ping_result: AtomicUsize, sdk_initialize_input: AtomicUsize, sdk_initialize_result: AtomicUsize, sdk_discover_result: AtomicUsize, } impl CounterSet { + pub(crate) fn sdk_ping_request(&self) -> usize { + self.sdk_ping_request.load(Ordering::SeqCst) + } + pub(crate) fn sdk_ping_result(&self) -> usize { + self.sdk_ping_result.load(Ordering::SeqCst) + } pub(crate) fn sdk_initialize_input(&self) -> usize { self.sdk_initialize_input.load(Ordering::SeqCst) } @@ -410,6 +418,19 @@ pub(crate) fn sdk_initialize_input_consumed(_params: &rmcp::model::InitializeReq #[path = "../rmcp_initialize_input_runtime_tests.rs"] mod rmcp_initialize_input_runtime_tests; +/// Mark only where a real SDK PingRequest is consumed by the shared runtime ping seam. +pub(crate) fn sdk_ping_request_consumed(_request: &rmcp::model::PingRequest) { + increment(|counters| &counters.sdk_ping_request); +} + +/// Mark only after successfully serializing the real SDK ping result. +pub(crate) fn sdk_ping_result_serialized() { + increment(|counters| &counters.sdk_ping_result); +} + +#[path = "../rmcp_ping_runtime_tests.rs"] +mod rmcp_ping_runtime_tests; + fn increment(counter: impl Fn(&CounterSet) -> &AtomicUsize) { let _ = OBSERVER.try_with(|counters| { counter(counters).fetch_add(1, Ordering::SeqCst); diff --git a/crates/crank-community-mcp/src/app/legacy_dispatch.rs b/crates/crank-community-mcp/src/app/legacy_dispatch.rs index 8249beb..91f05fc 100644 --- a/crates/crank-community-mcp/src/app/legacy_dispatch.rs +++ b/crates/crank-community-mcp/src/app/legacy_dispatch.rs @@ -98,7 +98,7 @@ pub(super) async fn handle_legacy_request( StatusCode::OK, jsonrpc_result( request_id(message), - json!({ "protocolVersion": session.protocol_version }), + crate::protocol::ping_result(message, &session.protocol_version), ), response_mode, None, diff --git a/crates/crank-community-mcp/src/protocol/lifecycle_sdk.rs b/crates/crank-community-mcp/src/protocol/lifecycle_sdk.rs index 7b7c660..58487fb 100644 --- a/crates/crank-community-mcp/src/protocol/lifecycle_sdk.rs +++ b/crates/crank-community-mcp/src/protocol/lifecycle_sdk.rs @@ -2,7 +2,7 @@ use rmcp::model::{ CacheScope, DiscoverResult, Implementation, InitializeRequestParams, InitializeResult, - ProtocolVersion, ServerCapabilities, + PingRequest, ProtocolVersion, ServerCapabilities, ServerResult, }; use serde_json::Value; @@ -45,6 +45,26 @@ fn restore_registry_extensions(result: &mut Value, advertised: Value) { } } +pub(crate) fn ping_result(message: &Value, revision: &str) -> Value { + // Ping params were ignored after admission; do not add SDK constraints to extensions. + let request: PingRequest = serde_json::from_value(serde_json::json!({ + "method": message["method"] + })) + .expect("registry dispatched a validated ping request"); + #[cfg(test)] + crate::app::dispatch_observer::sdk_ping_request_consumed(&request); + let result = match rmcp::model::ClientRequest::from(request) { + rmcp::model::ClientRequest::PingRequest(_) => ServerResult::empty(()), + _ => unreachable!("typed ping can only dispatch ping"), + }; + let mut result = serde_json::to_value(result).expect("SDK ping result is serializable"); + #[cfg(test)] + crate::app::dispatch_observer::sdk_ping_result_serialized(); + // Crank keeps the admitted/session revision in addition to the SDK's empty ping result. + result["protocolVersion"] = Value::String(revision.to_owned()); + result +} + pub(crate) fn initialize_result(revision: &str, name: &str, version: &str) -> Value { let advertised = advertised_server_capabilities(revision); let result = InitializeResult::new(capabilities(&advertised)) diff --git a/crates/crank-community-mcp/src/protocol/mod.rs b/crates/crank-community-mcp/src/protocol/mod.rs index c8d8eff..1ad6e63 100644 --- a/crates/crank-community-mcp/src/protocol/mod.rs +++ b/crates/crank-community-mcp/src/protocol/mod.rs @@ -41,7 +41,9 @@ pub(crate) use completion::{ CompletionArgument, CompletionCommand, CompletionOutcome, CompletionReference, handle_completion_command, }; -pub(crate) use lifecycle_sdk::{discover_result, initialize_params, initialize_result}; +pub(crate) use lifecycle_sdk::{ + discover_result, initialize_params, initialize_result, ping_result, +}; pub(crate) use logging::{ CarriedScope, EVENT_FAILED, EVENT_LEVEL_APPLIED, EVENT_REJECTED, EVENT_SERVED, INVALID_LEVEL, LogLevel, LogLevelStore, LoggingOutcome, SetLevelCommand, carry_scope, handle_logging_command, diff --git a/crates/crank-community-mcp/src/rmcp_ping_runtime_tests.rs b/crates/crank-community-mcp/src/rmcp_ping_runtime_tests.rs new file mode 100644 index 0000000..db13ad3 --- /dev/null +++ b/crates/crank-community-mcp/src/rmcp_ping_runtime_tests.rs @@ -0,0 +1,211 @@ +//! #107 ping: existing wire GREEN is independent from the SDK execution oracle. +use super::rmcp_progress_cancel_runtime_tests::fixtures::Endpoint; +use super::{CounterSet, Snapshot, observe, support::*}; +use serde_json::{Value, json}; +use std::{sync::Arc, time::Duration}; + +async fn endpoint() -> Endpoint { + crank_test_support::postgres_schema_url_for_task("ping_owner", "t_83746dc7").await; + Endpoint::started().await +} + +fn ping(revision: &str, extended: bool) -> Value { + let mut payload = json!({"jsonrpc":"2.0","id":"ping/Ю","method":"ping"}); + if revision == MODERN_REVISION || extended { + payload["params"] = json!({"_meta":if revision == MODERN_REVISION { + modern_meta() + } else { json!({}) }}); + } + if extended { + payload["params"]["ignored"] = json!([null, {"future":true}]); + payload["params"]["_meta"]["future"] = json!(42); + payload["extension"] = json!({"nested":[false]}); + } + payload +} + +async fn wire_body(response: reqwest::Response, sse: bool) -> Value { + assert_eq!(response.headers()["x-request-id"], "ping-atdd"); + assert_eq!( + response.headers()["x-trace-id"], + "11111111111111111111111111111111" + ); + assert!( + response.headers()["content-type"] + .to_str() + .unwrap() + .starts_with(if sse { + "text/event-stream" + } else { + "application/json" + }) + ); + let raw = tokio::time::timeout(Duration::from_secs(6), response.text()) + .await + .unwrap() + .unwrap(); + if sse { + let frames: Vec = raw + .lines() + .filter_map(|line| line.strip_prefix("data:")) + .map(|line| serde_json::from_str(line.trim()).unwrap()) + .collect(); + assert_eq!(frames.len(), 1, "one terminal frame: {raw}"); + frames.into_iter().next().unwrap() + } else { + serde_json::from_str(&raw).unwrap() + } +} + +fn correlated(request: reqwest::RequestBuilder) -> reqwest::RequestBuilder { + request.header("x-request-id", "ping-atdd").header( + "traceparent", + "00-11111111111111111111111111111111-2222222222222222-01", + ) +} + +async fn success_control(revision: &str) -> Vec<(usize, usize)> { + let h = endpoint().await; + // The existing fixture performs real initialize -> initialized for legacy only. + let session = h.session(revision).await; + let mut sdk = vec![]; + for (accept, extended) in [ + ("application/json", false), + ("text/event-stream, application/json", true), + ] { + let counters = h.counters.snapshot(); + let ops = h.sessions.snapshot(); + let before = (h.counters.sdk_ping_request(), h.counters.sdk_ping_result()); + let response = correlated(h.request( + revision, + session.as_deref(), + &h.key, + accept, + ping(revision, extended), + )) + .send() + .await + .unwrap(); + assert_eq!(response.status(), 200); + assert_eq!(response.headers()["MCP-Protocol-Version"], revision); + assert!(response.headers().get("MCP-Session-Id").is_none()); + let wire = wire_body(response, accept.starts_with("text/event-stream")).await; + let result = if revision == MODERN_REVISION { + json!({"protocolVersion":revision,"resultType":"complete"}) + } else { + json!({"protocolVersion":revision}) + }; + assert_eq!(wire, json!({"jsonrpc":"2.0","id":"ping/Ю","result":result})); + assert_deltas( + "ping", + counters, + h.counters.snapshot(), + Snapshot::new( + 1, + usize::from(revision == MODERN_REVISION), + usize::from(revision == LEGACY_REVISION), + 0, + ), + ); + assert_session_ops( + "ping", + ops, + h.sessions.snapshot(), + SessionOps { + get: 2 * usize::from(revision == LEGACY_REVISION), + create: 0, + mark_initialized: 0, + }, + ); + sdk.push(( + h.counters.sdk_ping_request() - before.0, + h.counters.sdk_ping_result() - before.1, + )); + eprintln!( + "existing GREEN ping revision={revision} accept={accept} extended={extended}; SDK delta={:?}", + sdk.last().unwrap() + ); + } + sdk +} + +#[tokio::test] +async fn ping_wire_json_sse_tolerance_and_session_contract() { + success_control(LEGACY_REVISION).await; + success_control(MODERN_REVISION).await; +} + +#[tokio::test] +async fn ping_sdk_legacy_request_and_result() { + assert_eq!( + success_control(LEGACY_REVISION).await, + vec![(1, 1); 2], + "successful legacy HTTP ping must consume SDK request and serialize SDK result" + ); +} + +#[tokio::test] +async fn ping_sdk_modern_request_and_result() { + assert_eq!( + success_control(MODERN_REVISION).await, + vec![(1, 1); 2], + "successful stateless HTTP ping must consume SDK request and serialize SDK result" + ); +} + +#[tokio::test] +async fn ping_guards_never_enter_sdk() { + let h = endpoint().await; + for revision in [LEGACY_REVISION, MODERN_REVISION] { + let mut payload = ping(revision, true); + if revision == MODERN_REVISION { + payload["params"]["_meta"] = Value::Null; + } + let response = correlated(h.request(revision, None, &h.key, "application/json", payload)) + .send() + .await + .unwrap(); + assert_eq!(response.status(), 400); + if revision == LEGACY_REVISION { + assert!(response.headers().get("content-type").is_none()); + assert!(response.bytes().await.unwrap().is_empty()); + } else { + let wire = wire_body(response, false).await; + assert_eq!(wire["id"], "ping/Ю"); + assert_eq!(wire["error"]["code"], -32020); + assert!(wire.get("result").is_none()); + } + assert_eq!( + (h.counters.sdk_ping_request(), h.counters.sdk_ping_result()), + (0, 0) + ); + eprintln!("existing GREEN pre-seam guard revision={revision}; SDK=(0,0)"); + } +} + +#[tokio::test] +async fn ping_observer_positive_control() { + let c = Arc::new(CounterSet::default()); + let request: rmcp::model::PingRequest = + serde_json::from_value(json!({"method":"ping"})).unwrap(); + observe(c.clone(), async { + super::sdk_ping_request_consumed(&request); + assert_eq!((c.sdk_ping_request(), c.sdk_ping_result()), (1, 0)); + super::sdk_ping_result_serialized(); + assert_eq!((c.sdk_ping_request(), c.sdk_ping_result()), (1, 1)); + }) + .await; + super::sdk_ping_request_consumed(&request); + super::sdk_ping_result_serialized(); + observe(Arc::new(CounterSet::default()), async { + super::sdk_ping_request_consumed(&request); + super::sdk_ping_result_serialized(); + }) + .await; + assert_eq!( + (c.sdk_ping_request(), c.sdk_ping_result()), + (1, 1), + "scope isolation and out-of-scope no-op" + ); + assert_eq!(c.snapshot(), Snapshot::new(0, 0, 0, 0)); +} diff --git a/docs/development/rmcp-migration-plan.md b/docs/development/rmcp-migration-plan.md index 2822ac8..9477243 100644 --- a/docs/development/rmcp-migration-plan.md +++ b/docs/development/rmcp-migration-plan.md @@ -49,6 +49,8 @@ Envelopes-срез #107 на базе rc.25/rmcp3.9.0 заменяет handwritt Negotiation-results-срез #107 на базе rc.26/rmcp3.9.0 заменяет handwritten ответы legacy `initialize` и modern `server/discover` на настоящие `InitializeResult`/`DiscoverResult` в `protocol/lifecycle_sdk.rs`. Уже подключённый потребитель — штатный `build_app` HTTP JSON/SSE. Версии и их порядок заданы прежним allowlist, capabilities поступают только из registry; server identity, omissions и discovery ttlMs=0/cacheScope=private сохранены. SDK `ServerCapabilities` не представляет дополнительные top-level имена registry: после typed serialization восстанавливаются только отсутствующие ключи, без замены SDK-known полей. HTTP ATDD отдельно проверяет прежний wire и SDK execution, legacy initialize→initialized→защищённый вызов и отсутствие session operations у modern discovery; affected regression сохраняет frozen advertisement, unsupported revision rejection, auth/revocation/Agent scope и legacy transport lifecycle. Следующий initialize-input-срез на базе rc.27 заменяет `app/request.rs::InitializeParams` декодированием настоящего `InitializeRequestParams` в `protocol/lifecycle_sdk.rs`: штатный `handle_initialize` использует SDK `protocol_version` в прежнем allowlist. Локальная projection передаёт только protocolVersion с инертными обязательными SDK capabilities/clientInfo; исходные ignored clientInfo/extensions не валидируются, а raw capabilities сохраняют прежний object-предикат elicitation. HTTP admission (включая запрет sequence params и malformed _meta) остаётся до SDK. Отдельный typed runtime oracle и JSON/SSE tolerance/session ATDD подтверждают использование результата SDK, отсутствие новых отказов и прежний initialize→initialized→защищённый вызов. Generic dispatch/ping, session storage/TTL/reconnect, admission/auth и transport не переносились. Существующий SSE error.data omission не исправляется; полный #107, feature qualification и production deployment не завершены. +Ping-срез #107 на базе rc.28/rmcp3.9.0 подключает обе штатные HTTP ветки к общему `protocol/lifecycle_sdk.rs::ping_result`: проекция уже допущенного метода декодируется в `PingRequest`, его SDK request variant выбирает `ServerResult::empty(())`, а сериализованный SDK результат поступает в прежний JSON/SSE terminal. Удалены два handwritten ping result builder; Crank добавляет прежний `protocolVersion` из legacy session либо modern identity, а modern result projection сохраняется. Игнорируемые params/extensions не получают новых SDK ограничений. Legacy initialized-session guard остаётся перед helper; modern ping не обращается к sessions. Runtime ATDD отдельно подтверждает SDK request/result execution и прежние wire/status/headers/id/correlation обеих revisions; affected regressions проверяют session/admission/method/revocation guards. Generic dispatch, session storage/TTL/reconnect, admission/auth и transport остаются прежними; полный #107, feature qualification и production deployment не завершены. + Проверяемый результат: - Через SDK проходят действующие Tools, Resources, Prompts, completion, уведомления и подписки в применимых revisions, а также progress/cancel и существующая logging policy.