From 65144fd8c633d4c92531637cd996c62f6ccd7080 Mon Sep 17 00:00:00 2001 From: bsodfather Date: Fri, 13 Nov 2026 00:41:28 +0000 Subject: [PATCH] MCP: classify inbound responses through SDK with fresh authorization --- .../src/app/dispatch_observer.rs | 36 ++ .../crank-community-mcp/src/app/endpoint.rs | 11 + .../src/protocol/dispatch_sdk.rs | 4 +- .../crank-community-mcp/src/protocol/mod.rs | 47 +-- .../src/protocol/response_sdk.rs | 223 +++++++++++ .../src/rmcp_response_runtime_tests.rs | 352 ++++++++++++++++++ docs/development/rmcp-migration-plan.md | 2 + 7 files changed, 628 insertions(+), 47 deletions(-) create mode 100644 crates/crank-community-mcp/src/protocol/response_sdk.rs create mode 100644 crates/crank-community-mcp/src/rmcp_response_runtime_tests.rs diff --git a/crates/crank-community-mcp/src/app/dispatch_observer.rs b/crates/crank-community-mcp/src/app/dispatch_observer.rs index 8026036..f18926a 100644 --- a/crates/crank-community-mcp/src/app/dispatch_observer.rs +++ b/crates/crank-community-mcp/src/app/dispatch_observer.rs @@ -75,6 +75,10 @@ pub(crate) struct CounterSet { 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, + sdk_inbound_error_consumed: AtomicUsize, sdk_dispatch_decoded: AtomicUsize, sdk_dispatch_consumed: AtomicUsize, sdk_initialized_decoded: AtomicUsize, @@ -85,6 +89,18 @@ pub(crate) struct CounterSet { } impl CounterSet { + pub(crate) fn sdk_inbound_response_decoded(&self) -> usize { + self.sdk_inbound_response_decoded.load(Ordering::SeqCst) + } + pub(crate) fn sdk_inbound_error_decoded(&self) -> usize { + self.sdk_inbound_error_decoded.load(Ordering::SeqCst) + } + pub(crate) fn sdk_inbound_response_consumed(&self) -> usize { + self.sdk_inbound_response_consumed.load(Ordering::SeqCst) + } + pub(crate) fn sdk_inbound_error_consumed(&self) -> usize { + self.sdk_inbound_error_consumed.load(Ordering::SeqCst) + } pub(crate) fn sdk_dispatch_decoded(&self) -> usize { self.sdk_dispatch_decoded.load(Ordering::SeqCst) } @@ -477,6 +493,26 @@ pub(crate) fn sdk_dispatch_envelope_consumed() { #[path = "../rmcp_dispatch_runtime_tests.rs"] mod rmcp_dispatch_runtime_tests; +/// Mark only after a real SDK success-response from_value succeeds. +pub(crate) fn sdk_inbound_response_decoded() { + increment(|c| &c.sdk_inbound_response_decoded); +} +/// Mark only after a real SDK error-response from_value succeeds. +pub(crate) fn sdk_inbound_error_decoded() { + increment(|c| &c.sdk_inbound_error_decoded); +} +/// Mark inside the matched typed SDK success variant that selects ACK. +pub(crate) fn sdk_inbound_response_consumed() { + increment(|c| &c.sdk_inbound_response_consumed); +} +/// Mark inside the matched typed SDK error variant that selects ACK. +pub(crate) fn sdk_inbound_error_consumed() { + increment(|c| &c.sdk_inbound_error_consumed); +} + +#[path = "../rmcp_response_runtime_tests.rs"] +mod rmcp_response_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/endpoint.rs b/crates/crank-community-mcp/src/app/endpoint.rs index 7b35620..d5517bb 100644 --- a/crates/crank-community-mcp/src/app/endpoint.rs +++ b/crates/crank-community-mcp/src/app/endpoint.rs @@ -278,6 +278,17 @@ async fn mcp_post_response( Err(_status) => return ambiguous_session_carrier_response(headers, message), }; + // Responses ACK before era/session resolution, but must not bypass fresh credentials. + // Method-bearing messages retain their existing scoped authorization path below. + if message + .as_object() + .is_some_and(|object| !object.contains_key("method")) + && let Err(error) = + require_traced_machine_access(&state, path, headers, PlatformApiKeyScope::Read).await + { + return error.into_response(); + } + // Single JSON-RPC envelope guard: only a well-formed message reaches era resolution, dispatch, // approval or any outbound request. Syntactically valid JSON is not the same as a valid envelope. let envelope = match crate::protocol::validate_jsonrpc_envelope(message) { diff --git a/crates/crank-community-mcp/src/protocol/dispatch_sdk.rs b/crates/crank-community-mcp/src/protocol/dispatch_sdk.rs index 0dac574..31abf02 100644 --- a/crates/crank-community-mcp/src/protocol/dispatch_sdk.rs +++ b/crates/crank-community-mcp/src/protocol/dispatch_sdk.rs @@ -27,7 +27,7 @@ impl DispatchEnvelope { } } -/// Call only after `validate_jsonrpc_envelope`; responses keep their existing non-SDK path. +/// Call only after `validate_jsonrpc_envelope`; responses use the separate response SDK classifier. /// Params and extensions stay in the raw message, not in this routing-only projection. pub(crate) fn decode_dispatch_envelope( message: &Value, @@ -135,7 +135,7 @@ mod tests { } #[test] - fn incoming_success_and_error_responses_are_not_migrated() { + fn incoming_success_and_error_responses_do_not_enter_method_dispatch() { for message in [ json!({"jsonrpc": "2.0", "id": 1, "result": {}}), json!({"jsonrpc": "2.0", "id": "id", "error": {"code": -1, "message": "error"}}), diff --git a/crates/crank-community-mcp/src/protocol/mod.rs b/crates/crank-community-mcp/src/protocol/mod.rs index 2550c16..9e7a86a 100644 --- a/crates/crank-community-mcp/src/protocol/mod.rs +++ b/crates/crank-community-mcp/src/protocol/mod.rs @@ -32,6 +32,7 @@ mod logging; mod prompts; mod registry; mod resources; +mod response_sdk; mod signals; pub(crate) use dispatch_sdk::decode_dispatch_envelope; @@ -91,50 +92,6 @@ fn is_valid_request_id(id: &Value) -> bool { id.is_string() || id.is_number() } -/// The pinned error object: `Error { code: number; message: string; data?: unknown }`. -fn is_valid_error_object(error: Option<&Value>) -> bool { - let Some(Value::Object(error)) = error else { - return false; - }; - error.get("code").is_some_and(Value::is_number) - && error.get("message").is_some_and(Value::is_string) -} - -/// Classify a wire response (a message without `method`). -/// -/// Pinned shapes are exclusive: a success response carries `result: Result` (an object) and a required -/// `id: RequestId`, an error response carries `error: Error` and may omit the id (a present id must -/// still be a `RequestId`). Both together, neither, a foreign id, a non-object `result` or a malformed -/// error object are all invalid requests rather than an acknowledgement. -/// -/// The `result` value is required to be an object because the pinned `JSONRPCResultResponse` types it as -/// `Result`; the modern `resultType` member is deliberately **not** required here, because an incoming -/// response may come from a client implementing an earlier revision. -fn classify_wire_response(object: &serde_json::Map) -> Option { - match (object.contains_key("result"), object.contains_key("error")) { - (true, false) => { - if !matches!(object.get("result"), Some(Value::Object(_))) { - return None; - } - object - .get("id") - .filter(|id| is_valid_request_id(id)) - .map(|_| EnvelopeKind::Response) - } - (false, true) => { - if !is_valid_error_object(object.get("error")) { - return None; - } - match object.get("id") { - None => Some(EnvelopeKind::Response), - Some(id) if is_valid_request_id(id) => Some(EnvelopeKind::Response), - Some(_) => None, - } - } - _ => None, - } -} - /// Pinned modern wire projection of a success result. /// /// `JSONRPCResultResponse.result` is a `Result`, and this revision requires the `resultType` member @@ -260,7 +217,7 @@ pub(crate) fn validate_jsonrpc_envelope(message: &Value) -> Result Err(rejected(invalid_request_response())), - None => match classify_wire_response(object) { + None => match response_sdk::classify_response(message) { Some(kind) => Ok(kind), None => Err(rejected(invalid_request_response())), }, diff --git a/crates/crank-community-mcp/src/protocol/response_sdk.rs b/crates/crank-community-mcp/src/protocol/response_sdk.rs new file mode 100644 index 0000000..3eccd0f --- /dev/null +++ b/crates/crank-community-mcp/src/protocol/response_sdk.rs @@ -0,0 +1,223 @@ +//! SDK classification of inbound responses, without narrowing the admitted wire numbers. + +use rmcp::model::{JsonRpcError, JsonRpcResponse}; +use serde_json::{Value, json}; + +use super::EnvelopeKind; + +enum ResponseEnvelope { + Success(JsonRpcResponse), + Error(JsonRpcError), +} + +/// Only the no-method branch of the envelope guard calls this helper. +pub(super) fn classify_response(message: &Value) -> Option { + match decode_response(message)? { + ResponseEnvelope::Success(JsonRpcResponse { result, .. }) => { + // The generic SDK result must still satisfy the pinned object-only contract. + if !result.is_object() { + return None; + } + #[cfg(test)] + crate::app::dispatch_observer::sdk_inbound_response_consumed(); + Some(EnvelopeKind::Response) + } + ResponseEnvelope::Error(JsonRpcError { .. }) => { + #[cfg(test)] + crate::app::dispatch_observer::sdk_inbound_error_consumed(); + Some(EnvelopeKind::Response) + } + } +} + +fn decode_response(message: &Value) -> Option { + let object = message.as_object()?; + if object.get("jsonrpc")?.as_str()? != "2.0" || object.contains_key("method") { + return None; + } + let id = object.get("id"); + if id.is_some_and(|id| !id.is_string() && !id.is_number()) { + return None; + } + let mut projection = json!({"jsonrpc": "2.0"}); + if let Some(id) = id { + // SDK ids are string/i64; this surrogate stays in the classification-only clone. + projection["id"] = if id.is_number() && id.as_i64().is_none() { + json!(0) + } else { + id.clone() + }; + } + match (object.get("result"), object.get("error")) { + (Some(result), None) if result.is_object() && id.is_some() => { + projection["result"] = result.clone(); + let response = serde_json::from_value::>(projection).ok()?; + #[cfg(test)] + crate::app::dispatch_observer::sdk_inbound_response_decoded(); + Some(ResponseEnvelope::Success(response)) + } + (None, Some(error)) if error.is_object() => { + let code = error.get("code")?; + if !code.is_number() || !error.get("message")?.is_string() { + return None; + } + projection["error"] = error.clone(); + // SDK codes are i32; validate the original number before projecting only that field. + if code + .as_i64() + .and_then(|code| i32::try_from(code).ok()) + .is_none() + { + projection["error"]["code"] = json!(0); + } + let error = serde_json::from_value::(projection).ok()?; + #[cfg(test)] + crate::app::dispatch_observer::sdk_inbound_error_decoded(); + Some(ResponseEnvelope::Error(error)) + } + _ => None, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn accepts_response_shapes_without_constraining_params_or_extensions() { + for message in [ + json!({"jsonrpc": "2.0", "id": "", "result": {}}), + json!({"jsonrpc": "2.0", "id": 1, "result": {"resultType": false}, + "params": false, "extension": [null, 1]}), + json!({"jsonrpc": "2.0", "error": {"code": -1, "message": ""}}), + json!({"jsonrpc": "2.0", "id": "id", "error": { + "code": -1, "message": "error", "data": [null, {"nested": true}] + }, "params": [], "extension": false}), + ] { + let original = message.to_string(); + assert_eq!(classify_response(&message), Some(EnvelopeKind::Response)); + assert_eq!(message.to_string(), original); + } + } + + #[test] + fn rejects_invalid_shapes_before_sdk_projection() { + for message in [ + Value::Null, + json!([]), + json!({"id": 1, "result": {}}), + json!({"jsonrpc": "1.0", "id": 1, "result": {}}), + json!({"jsonrpc": "2.0"}), + json!({"jsonrpc": "2.0", "result": {}}), + json!({"jsonrpc": "2.0", "id": 1, "result": {}, "error": null}), + json!({"jsonrpc": "2.0", "id": 1, "result": null}), + json!({"jsonrpc": "2.0", "id": 1, "result": []}), + json!({"jsonrpc": "2.0", "id": 1, "result": true}), + json!({"jsonrpc": "2.0", "error": null}), + json!({"jsonrpc": "2.0", "error": []}), + json!({"jsonrpc": "2.0", "error": {"message": "error"}}), + json!({"jsonrpc": "2.0", "error": {"code": "-1", "message": "error"}}), + json!({"jsonrpc": "2.0", "error": {"code": null, "message": "error"}}), + json!({"jsonrpc": "2.0", "error": {"code": true, "message": "error"}}), + json!({"jsonrpc": "2.0", "error": {"code": -1}}), + json!({"jsonrpc": "2.0", "error": {"code": -1, "message": false}}), + json!({"jsonrpc": "2.0", "method": null, "id": 1, "result": {}}), + json!({"jsonrpc": "2.0", "method": "request", "id": 1, "result": {}}), + ] { + assert_eq!(classify_response(&message), None, "{message}"); + } + for id in [Value::Null, json!(true), json!([]), json!({})] { + for payload in [ + json!({"result": {}}), + json!({"error": {"code": -1, "message": "e"}}), + ] { + let mut message = payload; + message["jsonrpc"] = json!("2.0"); + message["id"] = id.clone(); + assert_eq!(classify_response(&message), None, "{message}"); + } + } + } + + #[test] + fn numeric_projection_preserves_raw_json_and_executes_typed_variants() { + let numbers = [ + json!(i64::MIN), + json!(i64::MAX), + json!(u64::MAX), + json!(i32::MIN), + json!(i32::MAX), + json!(2147483648_i64), + json!(-2147483649_i64), + json!(1.25), + json!(1.0), + json!(-0.0), + json!(f64::MAX), + ]; + for number in numbers { + let sdk_id = if number.as_i64().is_some() { + number.clone() + } else { + json!(0) + }; + let sdk_code = if number + .as_i64() + .and_then(|n| i32::try_from(n).ok()) + .is_some() + { + number.clone() + } else { + json!(0) + }; + for error in [false, true] { + let mut message = json!({"jsonrpc": "2.0", "id": number}); + if error { + message["error"] = json!({"code": number, "message": "e", "data": number}); + } else { + message["result"] = json!({"nested": [number, null]}); + } + let original = message.to_string(); + match decode_response(&message).expect("numeric wire shape decodes") { + ResponseEnvelope::Success(response) => { + assert!(!error); + assert_eq!(serde_json::to_value(response.id).unwrap(), sdk_id); + assert_eq!(response.result, message["result"]); + } + ResponseEnvelope::Error(response) => { + assert!(error); + assert_eq!(serde_json::to_value(response.id).unwrap(), sdk_id); + assert_eq!(serde_json::to_value(response.error.code).unwrap(), sdk_code); + assert_eq!(response.error.data.as_ref(), Some(&number)); + } + } + assert_eq!(classify_response(&message), Some(EnvelopeKind::Response)); + assert_eq!(message.to_string(), original); + } + } + } + + #[test] + fn typed_error_keeps_optional_id_and_arbitrary_data() { + for data in [ + Value::Null, + json!(true), + json!(1.0), + json!("text"), + json!([]), + json!({}), + ] { + let message = + json!({"jsonrpc": "2.0", "error": {"code": -1, "message": "e", "data": data}}); + let ResponseEnvelope::Error(error) = decode_response(&message).unwrap() else { + panic!("error must retain its SDK variant"); + }; + assert_eq!(error.id, None); + // SDK Option maps explicit null to None; classification never rewrites the wire. + assert_eq!( + error.error.data, + if data.is_null() { None } else { Some(data) } + ); + assert_eq!(classify_response(&message), Some(EnvelopeKind::Response)); + } + } +} diff --git a/crates/crank-community-mcp/src/rmcp_response_runtime_tests.rs b/crates/crank-community-mcp/src/rmcp_response_runtime_tests.rs new file mode 100644 index 0000000..21013b1 --- /dev/null +++ b/crates/crank-community-mcp/src/rmcp_response_runtime_tests.rs @@ -0,0 +1,352 @@ +//! #107 inbound responses: wire compatibility and independent SDK execution oracles. +use super::rmcp_progress_cancel_runtime_tests::fixtures::Endpoint; +use super::{CounterSet, Snapshot, observe, support::*}; +use serde_json::{Value, json}; +use std::sync::{Arc, atomic::Ordering}; + +async fn endpoint() -> Endpoint { + crank_test_support::postgres_schema_url_for_task("response_owner", "t_d427ee76").await; + Endpoint::started().await +} +fn sdk(c: &CounterSet) -> [usize; 4] { + [ + c.sdk_inbound_response_decoded(), + c.sdk_inbound_error_decoded(), + c.sdk_inbound_response_consumed(), + c.sdk_inbound_error_consumed(), + ] +} +fn request( + h: &Endpoint, + revision: &str, + session: Option<&str>, + accept: &str, + raw: &str, +) -> reqwest::RequestBuilder { + // Reuse the HTTP fixture without its request-only modern method/name headers. + let mut req = h + .request(LEGACY_REVISION, session, &h.key, accept, json!({})) + .header("x-request-id", "response-atdd") + .body(raw.to_owned()) + .build() + .unwrap(); + req.headers_mut() + .insert("MCP-Protocol-Version", revision.parse().unwrap()); + reqwest::RequestBuilder::from_parts(reqwest::Client::new(), req) +} +async fn ack(response: reqwest::Response) { + assert_eq!(response.status(), 202); + assert!(response.headers().get("content-type").is_none()); + assert!(response.headers().get("MCP-Session-Id").is_none()); + assert!(response.bytes().await.unwrap().is_empty()); +} +async fn no_effects(h: &Endpoint, ops: SessionOps, entries: Snapshot) { + assert_eq!( + h.sessions.snapshot(), + ops, + "response ACK must not access sessions" + ); + let after = h.counters.snapshot(); + assert_eq!( + (after.era_modern, after.era_legacy, after.tools_service), + ( + entries.era_modern, + entries.era_legacy, + entries.tools_service + ) + ); + assert_eq!(h.started.load(Ordering::SeqCst), 0); + assert!( + h.history("response-atdd").await.is_empty(), + "no domain invocation" + ); +} +async fn success_control(error: bool) -> Vec<[usize; 4]> { + let h = endpoint().await; + let mut deltas = vec![]; + let numbers = [ + "-9223372036854775808", + "9223372036854775807", + "18446744073709551615", + "3.25", + "1.0", + "-0.0", + "1.7976931348623157e308", + "-1.7976931348623157e308", + "5e-324", + ]; + let mut ids = vec!["\"reply/Ю\""]; + ids.extend(numbers); + for revision in [LEGACY_REVISION, MODERN_REVISION] { + for accept in ["application/json", "text/event-stream, application/json"] { + for session in [None, Some("nonexistent-response-session")] { + for (index, id) in ids.iter().enumerate() { + let messages = if error { + let code = numbers[index % numbers.len()]; + let data = [ + "null", + "true", + "3.25", + "\"text\"", + "[]", + "{}", + "[null,true,{\"nested\":1}]", + ][index % 7]; + vec![ + format!( + r#"{{"jsonrpc":"2.0","id":{id},"error":{{"code":{code},"message":"failed","data":{data}}},"params":false,"extension":[]}}"# + ), + format!( + r#"{{"jsonrpc":"2.0","error":{{"code":{code},"message":"failed"}},"params":{{"_meta":false}}}}"# + ), + ] + } else { + vec![format!( + r#"{{"jsonrpc":"2.0","id":{id},"result":{{"arbitrary":[null,true,3]}},"params":false,"extension":[]}}"# + )] + }; + for raw in messages { + let before = sdk(&h.counters); + let ops = h.sessions.snapshot(); + let entries = h.counters.snapshot(); + ack(request(&h, revision, session, accept, &raw) + .send() + .await + .unwrap()) + .await; + no_effects(&h, ops, entries).await; + let after = sdk(&h.counters); + deltas.push(std::array::from_fn(|i| after[i] - before[i])); + } + } + } + } + } + eprintln!("existing wire GREEN error={error}; SDK deltas={deltas:?}"); + deltas +} +#[tokio::test] +async fn wire_success_and_error_ack_without_session_or_modern_metadata() { + success_control(false).await; + success_control(true).await; +} +#[tokio::test] +async fn sdk_success_response_decoded_and_consumed_after_http_ack() { + let deltas = success_control(false).await; + assert!( + deltas.iter().all(|d| *d == [1, 0, 1, 0]), + "real SDK success decode/typed variant consumption required; actual={deltas:?}" + ); +} +#[tokio::test] +async fn sdk_error_response_decoded_and_consumed_after_http_ack() { + let deltas = success_control(true).await; + assert!( + deltas.iter().all(|d| *d == [0, 1, 0, 1]), + "real SDK error decode/typed variant consumption required; actual={deltas:?}" + ); +} +#[tokio::test] +async fn malformed_responses_reject_before_sdk_or_effects() { + let h = endpoint().await; + let mut cases = vec![ + json!({}), + json!({"jsonrpc":"2.0","id":1}), + json!({"jsonrpc":"2.0","id":1,"result":{},"error":{"code":1,"message":"x"}}), + json!({"jsonrpc":"2.0","result":{}}), + json!({"id":1,"result":{}}), + json!({"jsonrpc":2,"id":1,"result":{}}), + json!({"jsonrpc":"2.0","id":1,"result":3}), + json!({"jsonrpc":"2.0","error":{}}), + json!({"jsonrpc":"2.0","error":{"code":1,"message":3}}), + ]; + for value in [Value::Null, json!(true), json!([]), json!({}), json!("bad")] { + for field in ["jsonrpc", "result", "id"] { + if (field == "result" && value.is_object()) || (field == "id" && value.is_string()) { + continue; + } + let mut m = json!({"jsonrpc":"2.0","id":1,"result":{}}); + m[field] = value.clone(); + cases.push(m); + } + for field in ["error", "code", "message", "id"] { + if (field == "error" && value.is_object()) + || (field == "message" && value.is_string()) + || (field == "id" && value.is_string()) + { + continue; + } + let mut m = json!({"jsonrpc":"2.0","id":1,"error":{"code":1,"message":"x"}}); + if ["code", "message"].contains(&field) { + m["error"][field] = value.clone(); + } else { + m[field] = value.clone(); + } + cases.push(m); + } + } + for missing in ["code", "message"] { + let mut m = json!({"jsonrpc":"2.0","error":{"code":1,"message":"x"}}); + m["error"].as_object_mut().unwrap().remove(missing); + cases.push(m); + } + for revision in [LEGACY_REVISION, MODERN_REVISION] { + for m in &cases { + let before = sdk(&h.counters); + let ops = h.sessions.snapshot(); + let entries = h.counters.snapshot(); + let response = request(&h, revision, None, "application/json", &m.to_string()) + .send() + .await + .unwrap(); + assert_eq!(response.status(), 400, "{m}"); + let wire: Value = response.json().await.unwrap(); + assert_eq!(wire["error"]["code"], -32600, "{m}: {wire}"); + assert_eq!(wire["id"], Value::Null); + assert!(wire.get("result").is_none()); + assert_eq!(sdk(&h.counters), before); + no_effects(&h, ops, entries).await; + } + } +} +#[tokio::test] +async fn admission_guards_precede_response_ack_and_sdk() { + let h = endpoint().await; + for revision in [LEGACY_REVISION, MODERN_REVISION] { + for raw in [ + r#"{"jsonrpc":"2.0","id":1,"result":{}}"#, + r#"{"jsonrpc":"2.0","error":{"code":1,"message":"x"}}"#, + ] { + for guard in ["origin", "accept", "ambiguous"] { + let ops = h.sessions.snapshot(); + let entries = h.counters.snapshot(); + let before = sdk(&h.counters); + let mut req = request(&h, revision, None, "application/json", raw) + .build() + .unwrap(); + let expected = match guard { + "origin" => { + req.headers_mut() + .insert("origin", "https://evil.example".parse().unwrap()); + 403 + } + "accept" => { + req.headers_mut() + .insert("accept", "text/plain".parse().unwrap()); + 406 + } + _ => { + req.headers_mut() + .append("MCP-Session-Id", "one".parse().unwrap()); + req.headers_mut() + .append("MCP-Session-Id", "two".parse().unwrap()); + 400 + } + }; + let response = reqwest::Client::new().execute(req).await.unwrap(); + assert_eq!(response.status().as_u16(), expected, "{guard}"); + let _ = response.bytes().await.unwrap(); + assert_eq!(sdk(&h.counters), before); + no_effects(&h, ops, entries).await; + } + } + } +} +#[tokio::test] +async fn authentication_and_revocation_precede_response_ack() { + let h = endpoint().await; + let mut statuses = vec![]; + for revoked in [false, true] { + if revoked { + h.registry + .revoke_platform_api_key( + &workspace_id(), + &crank_core::PlatformApiKeyId::new("pk_dispatch_observer"), + &time::OffsetDateTime::now_utc(), + ) + .await + .unwrap(); + } + for revision in [LEGACY_REVISION, MODERN_REVISION] { + for raw in [ + r#"{"jsonrpc":"2.0","id":1,"result":{}}"#, + r#"{"jsonrpc":"2.0","error":{"code":1,"message":"x"}}"#, + ] { + let before = sdk(&h.counters); + let ops = h.sessions.snapshot(); + let entries = h.counters.snapshot(); + let mut req = request(&h, revision, None, "application/json", raw) + .build() + .unwrap(); + if !revoked { + req.headers_mut().remove("authorization"); + } + let response = reqwest::Client::new().execute(req).await.unwrap(); + statuses.push(response.status().as_u16()); + let _ = response.bytes().await.unwrap(); + assert_eq!(sdk(&h.counters), before); + no_effects(&h, ops, entries).await; + } + } + } + assert_eq!( + statuses, + vec![401; 8], + "missing/revoked credentials must reject before ACK and SDK" + ); +} +#[tokio::test] +async fn method_bearing_messages_keep_priority_over_response_fields() { + let h = endpoint().await; + for revision in [LEGACY_REVISION, MODERN_REVISION] { + let session = h.session(revision).await; + for notification in [false, true] { + let mut m = json!({"jsonrpc":"2.0","method":"ping","id":7,"result":false,"error":[],"extension":null}); + if notification { + m.as_object_mut().unwrap().remove("id"); + } + if revision == MODERN_REVISION { + m["params"] = json!({"_meta":modern_meta()}); + } + let before = sdk(&h.counters); + let response = h + .request(revision, session.as_deref(), &h.key, "application/json", m) + .send() + .await + .unwrap(); + if notification { + ack(response).await; + } else { + assert_eq!(response.status(), 200); + let wire: Value = response.json().await.unwrap(); + assert_eq!(wire["id"], 7); + assert!(wire["result"].is_object()); + assert!(wire.get("error").is_none()); + } + assert_eq!(sdk(&h.counters), before, "not an inbound response"); + } + } +} +#[tokio::test] +async fn observer_positive_control_is_task_scoped_and_independent() { + let a = Arc::new(CounterSet::default()); + let b = Arc::new(CounterSet::default()); + super::sdk_inbound_response_decoded(); + super::sdk_inbound_error_decoded(); + super::sdk_inbound_response_consumed(); + super::sdk_inbound_error_consumed(); + assert_eq!(sdk(&a), [0; 4]); + tokio::join!( + observe(a.clone(), async { + super::sdk_inbound_response_decoded(); + super::sdk_inbound_error_consumed(); + }), + observe(b.clone(), async { + super::sdk_inbound_error_decoded(); + super::sdk_inbound_response_consumed(); + }) + ); + assert_eq!(sdk(&a), [1, 0, 0, 1]); + assert_eq!(sdk(&b), [0, 1, 1, 0]); + assert_eq!(a.snapshot(), Snapshot::new(0, 0, 0, 0)); +} diff --git a/docs/development/rmcp-migration-plan.md b/docs/development/rmcp-migration-plan.md index 499df1c..182b2bd 100644 --- a/docs/development/rmcp-migration-plan.md +++ b/docs/development/rmcp-migration-plan.md @@ -55,6 +55,8 @@ Initialized-срез #107 на базе rc.29/rmcp3.9.0 подключает ш 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 не запускаются. +Inbound-response-срез #107 на базе rc.31/rmcp3.9.0 подключает no-method ветку общего envelope guard к `protocol/response_sdk.rs`: реальные `JsonRpcResponse`/`JsonRpcError` определяют response classification и ранний HTTP202 ACK штатного `build_app` POST обеих revisions. Сохранены object-only result без обязательного resultType, exclusivity result/error, optional error id, произвольные data/params/extensions и любые JSON number id/code; только SDK-несовместимые числа получают внутренние surrogates после проверки исходного wire-предиката, raw message не меняется. Заменён handwritten response classifier/error-object parser. Обнаруженный ATDD обход credentials ранним ACK устранён свежей read-авторизацией no-method сообщений до SDK decode; порядок method-bearing запросов не меняется. Origin/Accept/ambiguous carrier checks предшествуют decode/ACK, ACK остаётся до era/session resolution без session/domain вызовов. HTTP wire и SDK decoded/consumed oracles проверяются отдельно. Domain/generic handler execution, session storage/TTL/reconnect, transport и feature qualification остаются вне среза; полный #107 остаётся open, #108/4.7/production не запускаются. + Проверяемый результат: - Через SDK проходят действующие Tools, Resources, Prompts, completion, уведомления и подписки в применимых revisions, а также progress/cancel и существующая logging policy. -- 2.54.0