MCP: classify inbound responses through SDK with fresh authorization
CI / UI Checks (pull_request) Successful in 10s
CI / Rust Checks (pull_request) Successful in 37m3s
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 1s
CI / Deploy (pull_request) Skipped
CI / UI Checks (pull_request) Successful in 10s
CI / Rust Checks (pull_request) Successful in 37m3s
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 1s
CI / Deploy (pull_request) Skipped
This commit is contained in:
1 parent
66bb135398
commit
65144fd8c6
7 files changed
+628
-47
No files matched your search
@@ -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);
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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"}}),
|
||||
|
||||
@@ -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<String, Value>) -> Option<EnvelopeKind> {
|
||||
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<EnvelopeKind,
|
||||
}
|
||||
}
|
||||
Some(_) => 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())),
|
||||
},
|
||||
|
||||
@@ -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<Value>),
|
||||
Error(JsonRpcError),
|
||||
}
|
||||
|
||||
/// Only the no-method branch of the envelope guard calls this helper.
|
||||
pub(super) fn classify_response(message: &Value) -> Option<EnvelopeKind> {
|
||||
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<ResponseEnvelope> {
|
||||
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::<JsonRpcResponse<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::<JsonRpcError>(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<Value> 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));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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));
|
||||
}
|
||||
@@ -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<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 не запускаются.
|
||||
|
||||
Inbound-response-срез #107 на базе rc.31/rmcp3.9.0 подключает no-method ветку общего envelope guard к `protocol/response_sdk.rs`: реальные `JsonRpcResponse<Value>`/`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.
|
||||
|
||||
Reference in new issue
Block a user