diff --git a/crates/crank-community-mcp/src/app.rs b/crates/crank-community-mcp/src/app.rs index b055bd7..cf79d0e 100644 --- a/crates/crank-community-mcp/src/app.rs +++ b/crates/crank-community-mcp/src/app.rs @@ -41,6 +41,7 @@ mod rmcp_http; #[cfg(test)] #[path = "rmcp_http_tests.rs"] mod rmcp_http_tests; +mod rmcp_negotiation; mod rmcp_progress_cancel; mod rmcp_prompts; mod rmcp_prompts_projection; diff --git a/crates/crank-community-mcp/src/app/dispatch.rs b/crates/crank-community-mcp/src/app/dispatch.rs index 0df9bdf..d62eb92 100644 --- a/crates/crank-community-mcp/src/app/dispatch.rs +++ b/crates/crank-community-mcp/src/app/dispatch.rs @@ -18,7 +18,7 @@ use crate::{ PromptGetCommand, PromptsCommand, PromptsListCommand, PromptsOutcome, RequestIdentity, ResourceReadCommand, ResourcesCommand, ResourcesListCommand, ResourcesOutcome, ServiceContext, ToolCallCommand, ToolsCommand, ToolsListCommand, declared_mcp_method, - discover_result, validate_modern_request_name, + validate_modern_request_name, }, session::SessionState, tool_error::execution_locale, @@ -42,8 +42,6 @@ use super::response::{ }; use super::{AgentRoutePath, AppState, TRANSPORT_SESSION_TTL_MS}; use crate::protocol::ResourceTemplatesListError; -const SERVER_NAME: &str = "crank-mcp-server"; -const SERVER_VERSION: &str = env!("CARGO_PKG_VERSION"); /// Serve a request of the modern stateless era. /// No session is created, read or required; identity comes from the per-request `_meta` metadata that @@ -111,32 +109,43 @@ pub(super) async fn handle_modern_request( DispatchDecision::Allowed { handler: MethodHandler::Discover, .. - } => transport_response( - StatusCode::OK, - jsonrpc_result( - request_id(message), - discover_result(version, SERVER_NAME, SERVER_VERSION), - ), - response_mode, - None, - Some(version), - ), + } => { + let result = match super::rmcp_negotiation::discover(version).await { + Ok(result) => result, + Err(error) => return sdk_error_response(message, response_mode, version, error), + }; + transport_response( + StatusCode::OK, + jsonrpc_result( + request_id(message), + crate::protocol::project_modern_cacheable_result(version, result), + ), + response_mode, + None, + Some(version), + ) + } DispatchDecision::Allowed { handler: MethodHandler::Ping, .. - } => transport_response( - StatusCode::OK, - jsonrpc_result( - request_id(message), - crate::protocol::project_modern_result( - version, - crate::protocol::ping_result(&json!({"method": "ping"}), version), + } => { + if let Err(error) = super::rmcp_negotiation::ping().await { + return sdk_error_response(message, response_mode, version, error); + } + transport_response( + StatusCode::OK, + jsonrpc_result( + request_id(message), + crate::protocol::project_modern_result( + version, + json!({"protocolVersion": version}), + ), ), - ), - response_mode, - None, - Some(version), - ), + response_mode, + None, + Some(version), + ) + } DispatchDecision::Allowed { handler: MethodHandler::ToolList, .. @@ -732,6 +741,19 @@ pub(super) async fn handle_modern_request( } } +pub(super) fn sdk_error_response( + message: &Value, + mode: ResponseMode, + revision: &str, + error: rmcp::ErrorData, +) -> Response { + let mut envelope = jsonrpc_error(request_id(message), i64::from(error.code.0), error.message); + if let Some(data) = error.data { + envelope["error"]["data"] = data; + } + transport_response(StatusCode::OK, envelope, mode, None, Some(revision)) +} + /// The verified, era-neutral context of a Resource command: the same workspace/Agent/credential/ /// correlation the Tools service receives. fn resource_service_context<'a>( @@ -791,6 +813,10 @@ pub(super) async fn handle_initialize( None, ); }; + let initialize_result = match super::rmcp_negotiation::initialize(protocol_version).await { + Ok(result) => result, + Err(error) => return sdk_error_response(message, response_mode, protocol_version, error), + }; let now = OffsetDateTime::now_utc(); let expires_at = add_millis(now, TRANSPORT_SESSION_TTL_MS); let supports_elicitation = raw_params @@ -816,10 +842,7 @@ pub(super) async fn handle_initialize( transport_response( StatusCode::OK, - jsonrpc_result( - request_id(message), - crate::protocol::initialize_result(protocol_version, SERVER_NAME, SERVER_VERSION), - ), + jsonrpc_result(request_id(message), initialize_result), response_mode, Some(&session_id), Some(protocol_version), diff --git a/crates/crank-community-mcp/src/app/dispatch_observer.rs b/crates/crank-community-mcp/src/app/dispatch_observer.rs index c15a6d5..e7e1185 100644 --- a/crates/crank-community-mcp/src/app/dispatch_observer.rs +++ b/crates/crank-community-mcp/src/app/dispatch_observer.rs @@ -89,8 +89,7 @@ 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_inbound_response_decoded: AtomicUsize, sdk_inbound_error_decoded: AtomicUsize, sdk_inbound_response_consumed: AtomicUsize, @@ -100,8 +99,13 @@ pub(crate) struct CounterSet { sdk_initialized_decoded: AtomicUsize, sdk_initialized_consumed: AtomicUsize, sdk_initialize_input: AtomicUsize, - sdk_initialize_result: AtomicUsize, - sdk_discover_result: AtomicUsize, + + sdk_initialize_handler_completed: AtomicUsize, + sdk_initialize_handler_consumed: AtomicUsize, + sdk_discover_handler_completed: AtomicUsize, + sdk_discover_handler_consumed: AtomicUsize, + sdk_ping_handler_completed: AtomicUsize, + sdk_ping_handler_consumed: AtomicUsize, } impl CounterSet { @@ -180,20 +184,28 @@ impl CounterSet { pub(crate) fn sdk_initialized_consumed(&self) -> usize { self.sdk_initialized_consumed.load(Ordering::SeqCst) } - 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) } - pub(crate) fn sdk_initialize_result(&self) -> usize { - self.sdk_initialize_result.load(Ordering::SeqCst) + + pub(crate) fn sdk_initialize_handler_completed(&self) -> usize { + self.sdk_initialize_handler_completed.load(Ordering::SeqCst) } - pub(crate) fn sdk_discover_result(&self) -> usize { - self.sdk_discover_result.load(Ordering::SeqCst) + pub(crate) fn sdk_initialize_handler_consumed(&self) -> usize { + self.sdk_initialize_handler_consumed.load(Ordering::SeqCst) + } + pub(crate) fn sdk_discover_handler_completed(&self) -> usize { + self.sdk_discover_handler_completed.load(Ordering::SeqCst) + } + pub(crate) fn sdk_discover_handler_consumed(&self) -> usize { + self.sdk_discover_handler_consumed.load(Ordering::SeqCst) + } + pub(crate) fn sdk_ping_handler_completed(&self) -> usize { + self.sdk_ping_handler_completed.load(Ordering::SeqCst) + } + pub(crate) fn sdk_ping_handler_consumed(&self) -> usize { + self.sdk_ping_handler_consumed.load(Ordering::SeqCst) } pub(crate) fn sdk_jsonrpc_response(&self) -> usize { self.sdk_jsonrpc_response.load(Ordering::SeqCst) @@ -581,19 +593,32 @@ pub(crate) fn sdk_jsonrpc_error_serialized() { #[path = "../rmcp_envelopes_runtime_tests.rs"] mod rmcp_envelopes_runtime_tests; -/// Mark only after successfully serializing a real rmcp InitializeResult. -pub(crate) fn sdk_initialize_result_serialized() { - increment(|counters| &counters.sdk_initialize_result); +pub(crate) fn sdk_initialize_handler_completed() { + increment(|c| &c.sdk_initialize_handler_completed); } - -/// Mark only after successfully serializing a real rmcp DiscoverResult. -pub(crate) fn sdk_discover_result_serialized() { - increment(|counters| &counters.sdk_discover_result); +pub(crate) fn sdk_initialize_handler_consumed() { + increment(|c| &c.sdk_initialize_handler_consumed); +} +pub(crate) fn sdk_discover_handler_completed() { + increment(|c| &c.sdk_discover_handler_completed); +} +pub(crate) fn sdk_discover_handler_consumed() { + increment(|c| &c.sdk_discover_handler_consumed); +} +pub(crate) fn sdk_ping_handler_completed() { + increment(|c| &c.sdk_ping_handler_completed); +} +pub(crate) fn sdk_ping_handler_consumed() { + increment(|c| &c.sdk_ping_handler_consumed); } #[path = "../rmcp_lifecycle_negotiation_runtime_tests.rs"] mod rmcp_lifecycle_negotiation_runtime_tests; +#[cfg(test)] +#[path = "../rmcp_negotiation_handler_runtime_tests.rs"] +mod rmcp_negotiation_handler_runtime_tests; + /// Mark only where SDK protocol_version is consumed by initialize negotiation, not at DTO creation. pub(crate) fn sdk_initialize_input_consumed(_params: &rmcp::model::InitializeRequestParams) { increment(|counters| &counters.sdk_initialize_input); @@ -602,16 +627,6 @@ 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; diff --git a/crates/crank-community-mcp/src/app/legacy_dispatch.rs b/crates/crank-community-mcp/src/app/legacy_dispatch.rs index 119ad2e..2185d2a 100644 --- a/crates/crank-community-mcp/src/app/legacy_dispatch.rs +++ b/crates/crank-community-mcp/src/app/legacy_dispatch.rs @@ -106,14 +106,20 @@ pub(super) async fn handle_legacy_request( Err(response) => return response, }; + if let Err(error) = super::rmcp_negotiation::ping().await { + return super::dispatch::sdk_error_response( + message, + response_mode, + &session.protocol_version, + error, + ); + } + transport_response( StatusCode::OK, jsonrpc_result( request_id(message), - crate::protocol::ping_result( - &json!({"method": "ping"}), - &session.protocol_version, - ), + json!({"protocolVersion": session.protocol_version}), ), response_mode, None, diff --git a/crates/crank-community-mcp/src/app/rmcp_negotiation.rs b/crates/crank-community-mcp/src/app/rmcp_negotiation.rs new file mode 100644 index 0000000..2726e73 --- /dev/null +++ b/crates/crank-community-mcp/src/app/rmcp_negotiation.rs @@ -0,0 +1,176 @@ +//! Request-owned SDK handlers for the existing HTTP negotiation and ping routes. +use std::borrow::Cow; + +use rmcp::{ErrorData, RoleServer, ServerHandler, model::*, service::RequestContext}; +use serde_json::{Value, json}; + +use crate::{jsonrpc::SUPPORTED_PROTOCOL_VERSIONS, protocol::advertised_server_capabilities}; + +const SERVER_NAME: &str = "crank-mcp-server"; +const SERVER_VERSION: &str = env!("CARGO_PKG_VERSION"); + +#[derive(Clone)] +struct NegotiationHandler; + +impl ServerHandler for NegotiationHandler { + fn supported_protocol_versions(&self) -> Cow<'static, [ProtocolVersion]> { + Cow::Owned( + SUPPORTED_PROTOCOL_VERSIONS + .iter() + .map(|v| version(v)) + .collect(), + ) + } + + async fn initialize( + &self, + request: InitializeRequestParams, + _context: RequestContext, + ) -> Result { + let revision = request.protocol_version.as_str(); + if !SUPPORTED_PROTOCOL_VERSIONS.contains(&revision) { + return Err(ErrorData::new( + ErrorCode(-32602), + format!("unsupported protocol version {revision}"), + None, + )); + } + let caps = capabilities(&advertised_server_capabilities(revision)); + #[cfg(test)] + super::dispatch_observer::sdk_initialize_handler_completed(); + Ok(InitializeResult::new(caps) + .with_protocol_version(version(revision)) + .with_server_info(Implementation::new(SERVER_NAME, SERVER_VERSION))) + } + + async fn discover( + &self, + context: RequestContext, + ) -> Result { + let revision = context + .extensions + .get::() + .ok_or_else(|| ErrorData::internal_error("discovery revision unavailable", None))?; + let revision = revision.as_str(); + let result = DiscoverResult::new( + SUPPORTED_PROTOCOL_VERSIONS + .iter() + .map(|v| version(v)) + .collect(), + capabilities(&advertised_server_capabilities(revision)), + ) + .with_server_info(Implementation::new(SERVER_NAME, SERVER_VERSION)) + .with_ttl_ms(0) + .with_cache_scope(CacheScope::Private); + #[cfg(test)] + super::dispatch_observer::sdk_discover_handler_completed(); + Ok(result) + } + + async fn ping(&self, _context: RequestContext) -> Result<(), ErrorData> { + #[cfg(test)] + super::dispatch_observer::sdk_ping_handler_completed(); + Ok(()) + } +} + +fn version(revision: &str) -> ProtocolVersion { + serde_json::from_value(Value::String(revision.to_owned())) + .expect("registered revisions are valid SDK versions") +} + +fn capabilities(value: &Value) -> ServerCapabilities { + // Registry capabilities are the allowlist; the SDK must not supply defaults. + serde_json::from_value(value.clone()).expect("registered capabilities match SDK shapes") +} + +async fn request_context() -> Result, ErrorData> { + let ping: rmcp::model::ClientJsonRpcMessage = + serde_json::from_value(json!({"jsonrpc":"2.0", "id":1, "method":"ping"})) + .map_err(|_| ErrorData::internal_error("negotiation context unavailable", None))?; + let (transport, receiver) = rmcp::transport::OneshotTransport::::new(ping); + let info = InitializeRequestParams::new( + ClientCapabilities::default(), + Implementation::new("crank-negotiation-context", "1"), + ); + // Bootstrap only obtains a closed Peer; it must never run the request handler. + #[derive(Clone)] + struct Bootstrap; + impl ServerHandler for Bootstrap {} + let mut running = rmcp::service::serve_directly(Bootstrap, transport, Some(info)); + let peer = running.peer().clone(); + running + .close() + .await + .map_err(|_| ErrorData::internal_error("negotiation handler unavailable", None))?; + drop(receiver); + Ok(RequestContext::new(RequestId::Number(1), peer)) +} + +pub(super) async fn initialize(revision: &str) -> Result { + initialize_with(&NegotiationHandler, revision).await +} + +async fn initialize_with(handler: &impl ServerHandler, revision: &str) -> Result { + let context = request_context().await?; + let params = + InitializeRequestParams::new(ClientCapabilities::default(), Implementation::new("", "")) + .with_protocol_version(version(revision)); + let result = ServerHandler::initialize(handler, params, context).await?; + let mut value = serde_json::to_value(result) + .map_err(|_| ErrorData::internal_error("initialize result unavailable", None))?; + restore_capabilities(&mut value, revision); + #[cfg(test)] + super::dispatch_observer::sdk_initialize_handler_consumed(); + Ok(value) +} + +pub(super) async fn discover(revision: &str) -> Result { + discover_with(&NegotiationHandler, revision).await +} + +async fn discover_with(handler: &impl ServerHandler, revision: &str) -> Result { + let mut context = request_context().await?; + context.extensions.insert(version(revision)); + let result = ServerHandler::discover(handler, context).await?; + let mut value = serde_json::to_value(result) + .map_err(|_| ErrorData::internal_error("discover result unavailable", None))?; + restore_capabilities(&mut value, revision); + #[cfg(test)] + super::dispatch_observer::sdk_discover_handler_consumed(); + Ok(value) +} + +pub(super) async fn ping() -> Result<(), ErrorData> { + ping_with(&NegotiationHandler).await +} + +async fn ping_with(handler: &impl ServerHandler) -> Result<(), ErrorData> { + let context = request_context().await?; + let result = ServerHandler::ping(handler, context).await; + #[cfg(test)] + super::dispatch_observer::sdk_ping_handler_consumed(); + result +} + +fn restore_capabilities(result: &mut Value, revision: &str) { + let advertised = advertised_server_capabilities(revision); + let represented = + serde_json::to_value(capabilities(&advertised)).expect("SDK capabilities serialize"); + let caps = result["capabilities"] + .as_object_mut() + .expect("SDK capabilities serialize as object"); + for (key, value) in advertised + .as_object() + .expect("registry capabilities are object") + { + // Restore only fields the SDK cannot represent, not removed typed capabilities. + if represented.get(key).is_none() { + caps.entry(key.clone()).or_insert_with(|| value.clone()); + } + } +} + +#[cfg(test)] +#[path = "../rmcp_negotiation_handler_tests.rs"] +mod tests; diff --git a/crates/crank-community-mcp/src/protocol/lifecycle_sdk.rs b/crates/crank-community-mcp/src/protocol/lifecycle_sdk.rs index 5248009..98dd538 100644 --- a/crates/crank-community-mcp/src/protocol/lifecycle_sdk.rs +++ b/crates/crank-community-mcp/src/protocol/lifecycle_sdk.rs @@ -1,14 +1,10 @@ //! Typed negotiation results; admission and session lifecycle remain in the HTTP adapter. -use rmcp::model::{ - CacheScope, DiscoverResult, Implementation, InitializeRequestParams, InitializeResult, - PingRequest, ProtocolVersion, ServerCapabilities, ServerResult, -}; +use rmcp::model::InitializeRequestParams; +#[cfg(test)] +use rmcp::model::{InitializeResult, ServerCapabilities}; use serde_json::Value; -use super::advertised_server_capabilities; -use crate::jsonrpc::SUPPORTED_PROTOCOL_VERSIONS; - pub(crate) fn initialize_params( params: &Value, ) -> Result { @@ -20,16 +16,13 @@ pub(crate) fn initialize_params( })) } -fn protocol_version(revision: &str) -> ProtocolVersion { - serde_json::from_value(Value::String(revision.to_owned())) - .expect("served protocol revisions are strings") -} - +#[cfg(test)] fn capabilities(advertised: &Value) -> ServerCapabilities { serde_json::from_value(advertised.clone()) .expect("registry capability fragments match SDK capability shapes") } +#[cfg(test)] fn restore_registry_extensions(result: &mut Value, advertised: Value) { let capabilities = result["capabilities"] .as_object_mut() @@ -55,59 +48,6 @@ pub(crate) fn initialized_notification(message: &Value) -> rmcp::model::ClientNo notification.into() } -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)) - .with_protocol_version(protocol_version(revision)) - .with_server_info(Implementation::new(name, version)); - let mut result = serde_json::to_value(result) - .expect("SDK initialize result with registry capabilities is serializable"); - #[cfg(test)] - crate::app::dispatch_observer::sdk_initialize_result_serialized(); - restore_registry_extensions(&mut result, advertised); - result -} - -pub(crate) fn discover_result(revision: &str, name: &str, version: &str) -> Value { - let advertised = advertised_server_capabilities(revision); - let result = DiscoverResult::new( - SUPPORTED_PROTOCOL_VERSIONS - .iter() - .map(|revision| protocol_version(revision)) - .collect(), - capabilities(&advertised), - ) - .with_server_info(Implementation::new(name, version)) - .with_ttl_ms(0) - .with_cache_scope(CacheScope::Private); - let mut result = serde_json::to_value(result) - .expect("SDK discovery result with registry capabilities is serializable"); - #[cfg(test)] - crate::app::dispatch_observer::sdk_discover_result_serialized(); - restore_registry_extensions(&mut result, advertised); - result -} - #[cfg(test)] mod tests { use super::*; diff --git a/crates/crank-community-mcp/src/protocol/mod.rs b/crates/crank-community-mcp/src/protocol/mod.rs index 9e7a86a..e109fb2 100644 --- a/crates/crank-community-mcp/src/protocol/mod.rs +++ b/crates/crank-community-mcp/src/protocol/mod.rs @@ -45,9 +45,7 @@ pub(crate) use completion::{ CompletionArgument, CompletionCommand, CompletionOutcome, CompletionReference, handle_completion_command, }; -pub(crate) use lifecycle_sdk::{ - discover_result, initialize_params, initialize_result, initialized_notification, ping_result, -}; +pub(crate) use lifecycle_sdk::{initialize_params, initialized_notification}; 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_initialize_input_runtime_tests.rs b/crates/crank-community-mcp/src/rmcp_initialize_input_runtime_tests.rs index 0224fd6..31b56b7 100644 --- a/crates/crank-community-mcp/src/rmcp_initialize_input_runtime_tests.rs +++ b/crates/crank-community-mcp/src/rmcp_initialize_input_runtime_tests.rs @@ -395,7 +395,7 @@ async fn rmcp_initialize_input_observer_positive_control() { super::sdk_initialize_input_consumed(¶ms); assert_eq!(c.sdk_initialize_input(), 1); assert_eq!( - c.sdk_initialize_result(), + c.sdk_initialize_handler_consumed(), 0, "input and output are independent" ); diff --git a/crates/crank-community-mcp/src/rmcp_lifecycle_negotiation_runtime_tests.rs b/crates/crank-community-mcp/src/rmcp_lifecycle_negotiation_runtime_tests.rs index 403a3c2..7d84012 100644 --- a/crates/crank-community-mcp/src/rmcp_lifecycle_negotiation_runtime_tests.rs +++ b/crates/crank-community-mcp/src/rmcp_lifecycle_negotiation_runtime_tests.rs @@ -7,7 +7,10 @@ use std::{sync::Arc, time::Duration}; use super::rmcp_progress_cancel_runtime_tests::fixtures::Endpoint; fn sdk_counts(c: &CounterSet) -> [usize; 2] { - [c.sdk_initialize_result(), c.sdk_discover_result()] + [ + c.sdk_initialize_handler_consumed(), + c.sdk_discover_handler_consumed(), + ] } fn capabilities() -> Value { @@ -197,19 +200,19 @@ async fn rmcp_lifecycle_negotiation_observer_positive_control() { let c = Arc::new(CounterSet::default()); observe(c.clone(), async { super::admission_enter(); - super::sdk_initialize_result_serialized(); + super::sdk_initialize_handler_consumed(); assert_eq!( sdk_counts(&c), [1, 0], "initialize and discovery are separate markers" ); - super::sdk_discover_result_serialized(); + super::sdk_discover_handler_consumed(); }) .await; assert_eq!(sdk_counts(&c), [1, 1]); assert_eq!(c.snapshot(), super::Snapshot::new(1, 0, 0, 0)); - super::sdk_initialize_result_serialized(); - super::sdk_discover_result_serialized(); + super::sdk_initialize_handler_consumed(); + super::sdk_discover_handler_consumed(); assert_eq!(sdk_counts(&c), [1, 1], "out-of-scope markers are no-ops"); } diff --git a/crates/crank-community-mcp/src/rmcp_negotiation_handler_runtime_tests.rs b/crates/crank-community-mcp/src/rmcp_negotiation_handler_runtime_tests.rs new file mode 100644 index 0000000..4b76bac --- /dev/null +++ b/crates/crank-community-mcp/src/rmcp_negotiation_handler_runtime_tests.rs @@ -0,0 +1,139 @@ +//! Behavioral RED for real negotiation/ping handler execution and result consumption. +use super::rmcp_progress_cancel_runtime_tests::fixtures::Endpoint; +use super::{CounterSet, observe, support::*}; +use serde_json::{Value, json}; +use std::{sync::Arc, time::Duration}; + +async fn request( + h: &Endpoint, + revision: &str, + payload: Value, + accept: &str, + session: Option<&str>, +) -> reqwest::Response { + h.request(revision, session, &h.key, accept, payload) + .header("x-request-id", "negotiation-handler-atdd") + .header( + "traceparent", + "00-11111111111111111111111111111111-2222222222222222-01", + ) + .send() + .await + .unwrap() +} + +async fn terminal(response: reqwest::Response, sse: bool) -> Value { + assert_eq!(response.status(), 200); + 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, "single terminal response frame"); + frames.into_iter().next().unwrap() + } else { + serde_json::from_str(&raw).unwrap() + } +} + +fn handler_counts(c: &CounterSet) -> [usize; 6] { + [ + c.sdk_initialize_handler_completed(), + c.sdk_initialize_handler_consumed(), + c.sdk_discover_handler_completed(), + c.sdk_discover_handler_consumed(), + c.sdk_ping_handler_completed(), + c.sdk_ping_handler_consumed(), + ] +} + +fn delta(after: [usize; 6], before: [usize; 6]) -> [usize; 6] { + std::array::from_fn(|index| after[index] - before[index]) +} + +#[tokio::test] +async fn rmcp_negotiation_handler_http_executes_and_consumes_initialize_discover_and_ping() { + crank_test_support::postgres_schema_url_for_task("negotiation_handler_owner", "t_219756db") + .await; + let h = Endpoint::started().await; + let session = h.session(LEGACY_REVISION).await; + let before_all = handler_counts(&h.counters); + for (revision, method, session) in [ + (LEGACY_REVISION, "initialize", None), + (MODERN_REVISION, "server/discover", None), + ] { + let mut payload = if method == "initialize" { + legacy_initialize(1) + } else { + json!({"jsonrpc":"2.0","id":1,"method":method,"params":{"_meta":modern_meta()}}) + }; + for accept in ["application/json", "text/event-stream, application/json"] { + if method == "initialize" { + payload["id"] = json!(if accept.starts_with("text/event") { + 2 + } else { + 1 + }); + } + let response = request(&h, revision, payload.clone(), accept, session).await; + let body = terminal(response, accept.starts_with("text/event")).await; + assert_eq!(body["jsonrpc"], "2.0"); + } + } + for revision in [LEGACY_REVISION, MODERN_REVISION] { + for accept in ["application/json", "text/event-stream, application/json"] { + let payload = json!({"jsonrpc":"2.0","id":"ping","method":"ping","params":{"_meta":if revision == MODERN_REVISION { modern_meta() } else { json!({"future":true}) }}}); + let response = request( + &h, + revision, + payload, + accept, + if revision == LEGACY_REVISION { + session.as_deref() + } else { + None + }, + ) + .await; + let body = terminal(response, accept.starts_with("text/event")).await; + assert_eq!(body["id"], "ping"); + assert!(body.get("error").is_none()); + if revision == LEGACY_REVISION { + assert_eq!(body["result"]["protocolVersion"], LEGACY_REVISION); + } + } + } + let after = handler_counts(&h.counters); + assert_eq!( + delta(after, before_all), + [2, 2, 2, 2, 4, 4], + "successful initialize/discover/ping HTTP responses must complete in and consume their SDK handler results" + ); +} + +#[tokio::test] +async fn rmcp_negotiation_handler_observer_positive_control() { + let c = Arc::new(CounterSet::default()); + observe(c.clone(), async { + super::sdk_initialize_handler_completed(); + super::sdk_initialize_handler_consumed(); + super::sdk_discover_handler_completed(); + super::sdk_discover_handler_consumed(); + super::sdk_ping_handler_completed(); + super::sdk_ping_handler_consumed(); + assert_eq!(handler_counts(&c), [1; 6]); + }) + .await; + assert_eq!(handler_counts(&c), [1; 6]); + super::sdk_initialize_handler_completed(); + assert_eq!( + handler_counts(&c), + [1; 6], + "markers outside observer scope are inert" + ); +} diff --git a/crates/crank-community-mcp/src/rmcp_negotiation_handler_tests.rs b/crates/crank-community-mcp/src/rmcp_negotiation_handler_tests.rs new file mode 100644 index 0000000..fdff377 --- /dev/null +++ b/crates/crank-community-mcp/src/rmcp_negotiation_handler_tests.rs @@ -0,0 +1,209 @@ +//! The production adapters consume actual trait results and own their pending work. +use super::*; + +#[tokio::test] +async fn rmcp_negotiation_handler_qa_discover_uses_requested_revision_capabilities() { + use crate::protocol::{ + CAPABILITY_DESCRIPTORS, CapabilityId, CapabilityRegistry, METHOD_DESCRIPTORS, + }; + use std::sync::Arc; + + let mut outcomes = Vec::new(); + for revisions in [&["2026-07-28"][..], &["2025-11-25"][..]] { + let mut descriptors = CAPABILITY_DESCRIPTORS.to_vec(); + descriptors + .iter_mut() + .find(|d| d.id == CapabilityId::Tools) + .unwrap() + .revisions = revisions; + let registration = + Arc::new(CapabilityRegistry::new(&descriptors, METHOD_DESCRIPTORS).unwrap()); + crate::app::dispatch_observer::observe_with_registration(registration, async { + let expected = advertised_server_capabilities("2026-07-28"); + let actual = discover("2026-07-28").await.unwrap(); + outcomes.push(( + expected["tools"].clone(), + actual["capabilities"]["tools"].clone(), + )); + }) + .await; + } + assert_eq!( + outcomes, + vec![ + (json!({"listChanged":true}), json!({"listChanged":true})), + (Value::Null, Value::Null) + ], + "modern-only tools must be advertised; legacy-only tools must not leak into modern discovery" + ); +} +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst}; + +#[derive(Default)] +struct Control { + calls: AtomicUsize, + dropped: AtomicBool, + finished: AtomicBool, + fail: bool, + pending: bool, +} +struct Witness<'a>(&'a AtomicBool); +impl Drop for Witness<'_> { + fn drop(&mut self) { + self.0.store(true, SeqCst); + } +} +fn error() -> ErrorData { + ErrorData::new( + ErrorCode(-32042), + "typed negotiation failure", + Some(json!({"proof":42})), + ) +} +impl Control { + async fn enter(&self, context: &RequestContext) -> Result<(), ErrorData> { + assert!( + context.peer.is_transport_closed(), + "bootstrap closes before handler" + ); + self.calls.fetch_add(1, SeqCst); + let _witness = Witness(&self.dropped); + if self.pending { + std::future::pending::<()>().await; + } + self.finished.store(true, SeqCst); + if self.fail { Err(error()) } else { Ok(()) } + } +} +impl ServerHandler for Control { + async fn initialize( + &self, + request: InitializeRequestParams, + context: RequestContext, + ) -> Result { + self.enter(&context).await?; + let mut result = ServerHandler::initialize(&NegotiationHandler, request, context).await?; + result.server_info = Implementation::new("typed-initialize", "42"); + result.capabilities.tools = None; + Ok(result) + } + async fn discover( + &self, + context: RequestContext, + ) -> Result { + self.enter(&context).await?; + let mut result = ServerHandler::discover(&NegotiationHandler, context).await?; + result = result.with_server_info(Implementation::new("typed-discover", "42")); + result.capabilities.tools = None; + Ok(result) + } + async fn ping(&self, context: RequestContext) -> Result<(), ErrorData> { + self.enter(&context).await + } +} + +#[tokio::test] +async fn rmcp_negotiation_handler_mutated_typed_success_is_consumed() { + let h = Control::default(); + let init = initialize_with(&h, "2025-11-25").await.unwrap(); + assert_eq!(init["serverInfo"]["name"], "typed-initialize"); + assert!(init["capabilities"].get("tools").is_none()); + let discover = discover_with(&h, "2026-07-28").await.unwrap(); + assert_eq!( + discover["_meta"]["io.modelcontextprotocol/serverInfo"]["name"], + "typed-discover" + ); + assert!(discover["capabilities"].get("tools").is_none()); + ping_with(&h).await.unwrap(); + assert_eq!(h.calls.load(SeqCst), 3, "no bootstrap invocation"); +} + +#[tokio::test] +async fn rmcp_negotiation_handler_typed_errors_are_not_success() { + let h = Control { + fail: true, + ..Default::default() + }; + for actual in [ + initialize_with(&h, "2025-11-25").await.unwrap_err(), + discover_with(&h, "2026-07-28").await.unwrap_err(), + ping_with(&h).await.unwrap_err(), + ] { + assert_eq!(actual, error()); + for mode in [ + crate::transport::ResponseMode::Json, + crate::transport::ResponseMode::Sse, + ] { + let response = super::super::dispatch::sdk_error_response( + &json!({"id":"typed-error"}), + mode, + "2025-11-25", + actual.clone(), + ); + assert_eq!(response.status(), 200); + assert!(response.headers().get("mcp-session-id").is_none()); + let bytes = axum::body::to_bytes(response.into_body(), usize::MAX) + .await + .unwrap(); + let raw = std::str::from_utf8(&bytes).unwrap(); + let body: Value = match mode { + crate::transport::ResponseMode::Json => serde_json::from_str(raw).unwrap(), + crate::transport::ResponseMode::Sse => serde_json::from_str( + raw.lines() + .find_map(|l| l.strip_prefix("data:")) + .unwrap() + .trim(), + ) + .unwrap(), + }; + assert_eq!( + body, + json!({"jsonrpc":"2.0","id":"typed-error","error":{"code":-32042,"message":"typed negotiation failure","data":{"proof":42}}}) + ); + } + } + assert_eq!(h.calls.load(SeqCst), 3); + assert!(initialize("not-supported").await.is_err()); + assert_eq!( + NegotiationHandler + .supported_protocol_versions() + .iter() + .map(|v| v.as_str()) + .collect::>(), + SUPPORTED_PROTOCOL_VERSIONS + ); +} + +#[tokio::test] +async fn rmcp_negotiation_handler_drop_cancels_request_owned_work() { + for method in 0..3 { + let h = Control { + pending: true, + ..Default::default() + }; + let mut future = Box::pin(async { + match method { + 0 => { + initialize_with(&h, "2025-11-25").await?; + } + 1 => { + discover_with(&h, "2026-07-28").await?; + } + _ => { + ping_with(&h).await?; + } + } + Ok::<_, ErrorData>(()) + }); + tokio::select! { + result = &mut future => panic!("pending handler completed: {result:?}"), + _ = async { while h.calls.load(SeqCst) == 0 { tokio::task::yield_now().await; } } => {} + } + assert!(!h.dropped.load(SeqCst)); + drop(future); + assert!(h.dropped.load(SeqCst)); + tokio::task::yield_now().await; + assert!(!h.finished.load(SeqCst)); + assert_eq!(h.calls.load(SeqCst), 1); + } +} diff --git a/crates/crank-community-mcp/src/rmcp_ping_runtime_tests.rs b/crates/crank-community-mcp/src/rmcp_ping_runtime_tests.rs index db13ad3..018c927 100644 --- a/crates/crank-community-mcp/src/rmcp_ping_runtime_tests.rs +++ b/crates/crank-community-mcp/src/rmcp_ping_runtime_tests.rs @@ -75,7 +75,10 @@ async fn success_control(revision: &str) -> Vec<(usize, usize)> { ] { let counters = h.counters.snapshot(); let ops = h.sessions.snapshot(); - let before = (h.counters.sdk_ping_request(), h.counters.sdk_ping_result()); + let before = ( + h.counters.sdk_ping_handler_completed(), + h.counters.sdk_ping_handler_consumed(), + ); let response = correlated(h.request( revision, session.as_deref(), @@ -118,8 +121,8 @@ async fn success_control(revision: &str) -> Vec<(usize, usize)> { }, ); sdk.push(( - h.counters.sdk_ping_request() - before.0, - h.counters.sdk_ping_result() - before.1, + h.counters.sdk_ping_handler_completed() - before.0, + h.counters.sdk_ping_handler_consumed() - before.1, )); eprintln!( "existing GREEN ping revision={revision} accept={accept} extended={extended}; SDK delta={:?}", @@ -176,9 +179,20 @@ async fn ping_guards_never_enter_sdk() { assert!(wire.get("result").is_none()); } assert_eq!( - (h.counters.sdk_ping_request(), h.counters.sdk_ping_result()), + ( + h.counters.sdk_ping_handler_completed(), + h.counters.sdk_ping_handler_consumed() + ), (0, 0) ); + assert_eq!( + ( + h.counters.sdk_ping_handler_completed(), + h.counters.sdk_ping_handler_consumed() + ), + (0, 0), + "pre-handler guard rejection must not execute or consume the SDK ping handler" + ); eprintln!("existing GREEN pre-seam guard revision={revision}; SDK=(0,0)"); } } @@ -186,24 +200,37 @@ async fn ping_guards_never_enter_sdk() { #[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)); + super::sdk_ping_handler_completed(); + assert_eq!( + ( + c.sdk_ping_handler_completed(), + c.sdk_ping_handler_consumed() + ), + (1, 0) + ); + super::sdk_ping_handler_consumed(); + assert_eq!( + ( + c.sdk_ping_handler_completed(), + c.sdk_ping_handler_consumed() + ), + (1, 1) + ); }) .await; - super::sdk_ping_request_consumed(&request); - super::sdk_ping_result_serialized(); + super::sdk_ping_handler_completed(); + super::sdk_ping_handler_consumed(); observe(Arc::new(CounterSet::default()), async { - super::sdk_ping_request_consumed(&request); - super::sdk_ping_result_serialized(); + super::sdk_ping_handler_completed(); + super::sdk_ping_handler_consumed(); }) .await; assert_eq!( - (c.sdk_ping_request(), c.sdk_ping_result()), + ( + c.sdk_ping_handler_completed(), + c.sdk_ping_handler_consumed() + ), (1, 1), "scope isolation and out-of-scope no-op" ); diff --git a/docs/development/rmcp-migration-plan.md b/docs/development/rmcp-migration-plan.md index 407195f..112db34 100644 --- a/docs/development/rmcp-migration-plan.md +++ b/docs/development/rmcp-migration-plan.md @@ -51,6 +51,8 @@ Negotiation-results-срез #107 на базе rc.26/rmcp3.9.0 заменяет 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 не завершены. +Negotiation-handler-срез #107 поверх rc.36/rmcp3.9.0 заменяет описанные выше DTO-only negotiation/ping helpers на прямые await настоящих `ServerHandler::initialize/discover/ping` в request-owned `app/rmcp_negotiation.rs`. Реальные consumers — legacy initialize/ping и modern discover/ping штатного `build_app` JSON/SSE; typed Result/ErrorData определяет ответ, а legacy session создаётся только после успешного initialize. Bootstrap инертен и закрывается до handler; pending trait future принадлежит запросу и прекращается при drop. Allowlist/порядок revisions, registry capabilities, identity, discovery cache hints, ignored inputs и прежние durable guards сохранены; projection восстанавливает только непредставимые SDK registry extensions и era-specific wire omissions. HTTP completed/consumed oracle обеих revisions дополнен typed-result mutation/error и drop controls; прежние wire/session/admission/revocation проверки сохраняются. DTO-only production builders удалены, initialized notification остаётся прежним typed переходом. Это не перенос SDK HTTP transport/SessionManager, callbacks или полного lifecycle: #107 остаётся open/partial, bootstrap performance и full/load/external-client qualification не завершены; #108/4.7/production не запускаются. + Initialized-срез #107 на базе rc.29/rmcp3.9.0 подключает штатный legacy HTTP handshake к `InitializedNotification` и `ClientNotification`: после registry/admission проекция метода декодируется SDK, а matched initialized variant после прежних session/scope guards разрешает существующий durable `mark_initialized`. Игнорируемые params/extensions, 202 с пустым телом, JSON/SSE и modern no-session поведение сохранены; SDK SessionManager не используется. Runtime-тесты отдельно наблюдают decoding и consumption, проверяют PostgreSQL reconnect и отказ store на чтении/записи. Это только lifecycle-срез, не завершение #107. Envelope-dispatch-срез #107 на базе rc.30/rmcp3.9.0 подключает обе действующие HTTP ветки `app/dispatch.rs` и `app/legacy_dispatch.rs` к общему `protocol/dispatch_sdk.rs`: после прежних admission/auth guards минимальная проекция декодируется в настоящие `JsonRpcRequest`/`JsonRpcNotification`. SDK payload method выбирает прежний `registry::dispatch_decision`, SDK variant определяет request/notification routing вместо повторных raw-JSON predicates. Второй таблицы методов нет; registry остаётся policy gate revisions/capabilities/registered kind. Modern notification ACK по-прежнему предшествует request-only Mcp-Method/Mcp-Name checks и не обращается к sessions/domain. Params и ignored extensions/result/error остаются вне routing projection; SDK-incompatible числовые ID получают только внутренний surrogate, исходные ID/числовая форма остаются в raw message для wire/correlation/cancellation ownership. Для выбранного registry Ping handler typed projection использует canonical ping, сохраняя registered alias semantics. Runtime HTTP ATDD отдельно проверяет SDK decode/consumption и прежний JSON/SSE wire; affected registry/admission, durable initialized/reconnect, progress/cancel и auth guards проверяются без замены storage/transport. Это перенос только generic request/notification envelope routing: domain/generic handler execution, inbound response/error envelopes и их shape validation, session storage/TTL/reconnect, transport и feature qualification остаются вне среза. Полный #107 остаётся open; #108/4.7 и production switch не запускаются.