Compare commits

...
Author SHA1 Message Date
bsodfather 986cd78b96 Merge pull request 'MCP: execute negotiation and ping through SDK handlers' (#140) from delivery/rmcp107-negotiation-handlers into main
CI / UI Checks (push) Successful in 10s
CI / Rust Checks (push) Successful in 1h1m4s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 2s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 1h29m23s
2026-11-13 21:19:48 +00:00
bsodfather bcdf57074b MCP: execute negotiation and ping through SDK handlers
CI / UI Checks (pull_request) Successful in 12s
CI / Rust Checks (pull_request) Successful in 49m59s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 2s
CI / Deploy (pull_request) Skipped
2026-11-13 20:27:41 +00:00
13 changed files with 692 additions and 153 deletions

No files matched your search

+1
View File
@@ -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;
+52 -29
View File
@@ -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),
@@ -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;
@@ -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,
@@ -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<RoleServer>,
) -> Result<InitializeResult, ErrorData> {
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<RoleServer>,
) -> Result<DiscoverResult, ErrorData> {
let revision = context
.extensions
.get::<ProtocolVersion>()
.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<RoleServer>) -> 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<RequestContext<RoleServer>, 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::<RoleServer>::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<Value, ErrorData> {
initialize_with(&NegotiationHandler, revision).await
}
async fn initialize_with(handler: &impl ServerHandler, revision: &str) -> Result<Value, ErrorData> {
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<Value, ErrorData> {
discover_with(&NegotiationHandler, revision).await
}
async fn discover_with(handler: &impl ServerHandler, revision: &str) -> Result<Value, ErrorData> {
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;
@@ -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<InitializeRequestParams, serde_json::Error> {
@@ -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::*;
@@ -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,
@@ -395,7 +395,7 @@ async fn rmcp_initialize_input_observer_positive_control() {
super::sdk_initialize_input_consumed(&params);
assert_eq!(c.sdk_initialize_input(), 1);
assert_eq!(
c.sdk_initialize_result(),
c.sdk_initialize_handler_consumed(),
0,
"input and output are independent"
);
@@ -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");
}
@@ -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<Value> = 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"
);
}
@@ -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<RoleServer>) -> 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<RoleServer>,
) -> Result<InitializeResult, ErrorData> {
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<RoleServer>,
) -> Result<DiscoverResult, ErrorData> {
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<RoleServer>) -> 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::<Vec<_>>(),
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);
}
}
@@ -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"
);
+2
View File
@@ -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<Value>`/`JsonRpcNotification<Value>`. 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 не запускаются.