Compare commits

...
Author SHA1 Message Date
bsodfather 163b519979 Merge pull request 'MCP: SDK inbound responses with authorization before ACK' (#135) from delivery/rmcp107-responses into main
CI / UI Checks (push) Successful in 8s
CI / Rust Checks (push) Successful in 36m24s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 57m11s
2026-11-13 01:22:04 +00:00
bsodfather 65144fd8c6 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
2026-11-13 00:41:28 +00:00
bsodfather 66bb135398 Merge pull request 'MCP: dispatch requests and notifications through SDK envelopes' (#134) from delivery/rmcp107-dispatch into main
CI / UI Checks (push) Successful in 9s
CI / Rust Checks (push) Successful in 46m33s
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 1h6m32s
2026-11-12 22:34:08 +00:00
bsodfather 0de1e94df4 MCP: dispatch incoming requests and notifications through SDK envelopes
CI / UI Checks (pull_request) Successful in 14s
CI / Rust Checks (pull_request) Successful in 35m55s
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
2026-11-12 21:53:24 +00:00
bsodfather 7a1fc0d761 Merge pull request 'MCP: consume SDK initialized notification in legacy handshake' (#133) from delivery/rmcp107-initialized into main
CI / UI Checks (push) Successful in 12s
CI / Rust Checks (push) Successful in 43m14s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 1h2m47s
2026-11-12 19:42:10 +00:00
bsodfather a4cf5ed8cf Merge pull request 'MCP: route runtime ping through rmcp while preserving wire compatibility' (#132) from delivery/rmcp107-ping into main
CI / UI Checks (push) Successful in 11s
CI / Rust Checks (push) Successful in 38m9s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 1h0m14s
2026-11-12 17:00:53 +00:00
bsodfather c32e24b268 Merge pull request 'MCP: SDK legacy initialize input with preserved session contract' (#131) from delivery/rmcp107-initialize-input into main
CI / UI Checks (push) Successful in 11s
CI / Rust Checks (push) Successful in 31m54s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 50m50s
2026-11-12 14:15:26 +00:00
bsodfather ca126004af Merge pull request 'MCP: SDK initialize/discover results with preserved wire contract' (#130) from delivery/rmcp107-negotiation into main
CI / UI Checks (push) Successful in 11s
CI / Rust Checks (push) Successful in 31m2s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 51m44s
2026-11-12 11:20:52 +00:00
11 changed files with 1288 additions and 78 deletions

No files matched your search

+18 -9
View File
@@ -12,10 +12,7 @@ use super::rmcp_dispatch::{
};
use crate::{
auth::VerifiedMachineCredential,
jsonrpc::{
is_notification, jsonrpc_error, jsonrpc_result, method_name, negotiated_protocol_version,
params, request_id,
},
jsonrpc::{jsonrpc_error, jsonrpc_result, negotiated_protocol_version, params, request_id},
protocol::{
CompletionCommand, CompletionOutcome, ContinuationSupport, DispatchDecision, MethodHandler,
PromptGetCommand, PromptsCommand, PromptsListCommand, PromptsOutcome, RequestIdentity,
@@ -81,7 +78,20 @@ pub(super) async fn handle_modern_request(
// matrix row 18). The envelope, identity and mixed-carrier checks — and authentication — have
// already run at this point, so this early return cannot admit a malformed identity or a session
// conflict, and the notification is never dispatched.
if is_notification(message) {
let envelope = match crate::protocol::decode_dispatch_envelope(message) {
Ok(Some(envelope)) => envelope,
_ => {
return internal_jsonrpc_error(
message,
"admitted dispatch envelope could not be decoded",
);
}
};
let method = envelope.method();
let notification = envelope.is_notification();
#[cfg(test)]
super::dispatch_observer::sdk_dispatch_envelope_consumed();
if notification {
return crate::protocol::modern_notification_response();
}
@@ -89,15 +99,14 @@ pub(super) async fn handle_modern_request(
Ok(declared_method) => declared_method,
Err(response) => return *response,
};
if declared_method != method_name(message) {
if declared_method != method {
return crate::protocol::modern_header_mismatch_response(message);
}
// R5/F5: the same registration-backed dispatch as the legacy adapter. The handler is decided by
// the owning registration (not by a literal method list inside this adapter), and a method whose
// capability is not eligible in this revision is never served here.
let dispatch =
crate::protocol::dispatch_decision(method_name(message).unwrap_or_default(), version);
let dispatch = crate::protocol::dispatch_decision(method.unwrap_or_default(), version);
match dispatch {
DispatchDecision::Allowed {
handler: MethodHandler::Discover,
@@ -121,7 +130,7 @@ pub(super) async fn handle_modern_request(
request_id(message),
crate::protocol::project_modern_result(
version,
crate::protocol::ping_result(message, version),
crate::protocol::ping_result(&json!({"method": "ping"}), version),
),
),
response_mode,
@@ -75,6 +75,12 @@ 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,
sdk_initialized_consumed: AtomicUsize,
sdk_initialize_input: AtomicUsize,
@@ -83,6 +89,24 @@ 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)
}
pub(crate) fn sdk_dispatch_consumed(&self) -> usize {
self.sdk_dispatch_consumed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_initialized_decoded(&self) -> usize {
self.sdk_initialized_decoded.load(Ordering::SeqCst)
}
@@ -456,6 +480,39 @@ pub(crate) fn sdk_initialized_notification_consumed(
#[path = "../rmcp_initialized_runtime_tests.rs"]
mod rmcp_initialized_runtime_tests;
/// Mark after successful SDK envelope decode, independently of routing consumption.
pub(crate) fn sdk_dispatch_envelope_decoded() {
increment(|counters| &counters.sdk_dispatch_decoded);
}
/// Mark only when decoded method/kind selects the existing registry-backed route.
pub(crate) fn sdk_dispatch_envelope_consumed() {
increment(|counters| &counters.sdk_dispatch_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) {
@@ -30,10 +30,7 @@ use super::rmcp_dispatch::{
use super::{AgentRoutePath, AppState};
use crate::{
auth::VerifiedMachineCredential,
jsonrpc::{
LEGACY_PROTOCOL_VERSION, is_notification, is_request, jsonrpc_error, jsonrpc_result,
method_name, params, request_id,
},
jsonrpc::{LEGACY_PROTOCOL_VERSION, jsonrpc_error, jsonrpc_result, params, request_id},
protocol::{
CompletionCommand, CompletionOutcome, ContinuationSupport, DispatchDecision,
EVENT_LEVEL_APPLIED, INVALID_LEVEL, Kind, LoggingOutcome, MethodHandler, PromptGetCommand,
@@ -65,10 +62,20 @@ pub(super) async fn handle_legacy_request(
// `protocol::registry` and is read through `dispatch_decision`, so a newly registered method
// really reaches its handler and removing a descriptor removes the dispatch.
let registration_revision = protocol_version.unwrap_or(LEGACY_PROTOCOL_VERSION);
let dispatch = crate::protocol::dispatch_decision(
method_name(message).unwrap_or_default(),
registration_revision,
);
let envelope = match crate::protocol::decode_dispatch_envelope(message) {
Ok(Some(envelope)) => envelope,
_ => {
return internal_jsonrpc_error(
message,
"admitted dispatch envelope could not be decoded",
);
}
};
let method = envelope.method();
let dispatch =
crate::protocol::dispatch_decision(method.unwrap_or_default(), registration_revision);
#[cfg(test)]
super::dispatch_observer::sdk_dispatch_envelope_consumed();
match dispatch {
// G2: the *registered kind* of the matched method, not the envelope shape, decides which
// legacy lifecycle action runs. `initialize` is a request and `notifications/initialized` is a
@@ -78,11 +85,11 @@ pub(super) async fn handle_legacy_request(
DispatchDecision::Allowed {
handler: MethodHandler::Lifecycle,
kind: Kind::Method,
} if is_request(message) => handle_initialize(state, path, message, response_mode).await,
} if envelope.is_request() => handle_initialize(state, path, message, response_mode).await,
DispatchDecision::Allowed {
handler: MethodHandler::Lifecycle,
kind: Kind::Notification,
} if is_notification(message) => {
} if envelope.is_notification() => {
handle_initialized_notification(
state,
path,
@@ -94,7 +101,7 @@ pub(super) async fn handle_legacy_request(
DispatchDecision::Allowed {
handler: MethodHandler::Ping,
..
} if is_request(message) => {
} if envelope.is_request() => {
let session = match require_initialized_session(&state, path, headers, message).await {
Ok(session) => session,
Err(response) => return response,
@@ -104,7 +111,10 @@ pub(super) async fn handle_legacy_request(
StatusCode::OK,
jsonrpc_result(
request_id(message),
crate::protocol::ping_result(message, &session.protocol_version),
crate::protocol::ping_result(
&json!({"method": "ping"}),
&session.protocol_version,
),
),
response_mode,
None,
@@ -114,7 +124,7 @@ pub(super) async fn handle_legacy_request(
DispatchDecision::Allowed {
handler: MethodHandler::ToolList,
..
} if is_request(message) => {
} if envelope.is_request() => {
let session = match require_initialized_session(&state, path, headers, message).await {
Ok(session) => session,
Err(response) => return response,
@@ -183,7 +193,7 @@ pub(super) async fn handle_legacy_request(
DispatchDecision::Allowed {
handler: MethodHandler::ToolCall,
..
} if is_request(message) => {
} if envelope.is_request() => {
let session = match require_initialized_session(&state, path, headers, message).await {
Ok(session) => session,
Err(response) => return response,
@@ -241,13 +251,13 @@ pub(super) async fn handle_legacy_request(
DispatchDecision::Allowed {
handler: MethodHandler::Cancelled,
kind: Kind::Notification,
} if is_notification(message) => {
} if envelope.is_notification() => {
handle_cancelled_notification(&state, path, headers, message, credential).await
}
DispatchDecision::Allowed {
handler: MethodHandler::ResourceList,
..
} if is_request(message) => {
} if envelope.is_request() => {
let session = match require_initialized_session(&state, path, headers, message).await {
Ok(session) => session,
Err(response) => return response,
@@ -316,7 +326,7 @@ pub(super) async fn handle_legacy_request(
DispatchDecision::Allowed {
handler: MethodHandler::ResourceRead,
..
} if is_request(message) => {
} if envelope.is_request() => {
let session = match require_initialized_session(&state, path, headers, message).await {
Ok(session) => session,
Err(response) => return response,
@@ -397,7 +407,7 @@ pub(super) async fn handle_legacy_request(
DispatchDecision::Allowed {
handler: MethodHandler::ResourceTemplateList,
..
} if is_request(message) => {
} if envelope.is_request() => {
let session = match require_initialized_session(&state, path, headers, message).await {
Ok(session) => session,
Err(response) => return response,
@@ -469,7 +479,7 @@ pub(super) async fn handle_legacy_request(
DispatchDecision::Allowed {
handler: MethodHandler::PromptList,
..
} if is_request(message) => {
} if envelope.is_request() => {
let session = match require_initialized_session(&state, path, headers, message).await {
Ok(session) => session,
Err(response) => return response,
@@ -534,7 +544,7 @@ pub(super) async fn handle_legacy_request(
DispatchDecision::Allowed {
handler: MethodHandler::PromptGet,
..
} if is_request(message) => {
} if envelope.is_request() => {
let session = match require_initialized_session(&state, path, headers, message).await {
Ok(session) => session,
Err(response) => return response,
@@ -632,7 +642,7 @@ pub(super) async fn handle_legacy_request(
DispatchDecision::Allowed {
handler: MethodHandler::Completion,
..
} if is_request(message) => {
} if envelope.is_request() => {
let session = match require_initialized_session(&state, path, headers, message).await {
Ok(session) => session,
Err(response) => return response,
@@ -711,7 +721,7 @@ pub(super) async fn handle_legacy_request(
DispatchDecision::Allowed {
handler: MethodHandler::LoggingSetLevel,
..
} if is_request(message) => {
} if envelope.is_request() => {
let session = match require_initialized_session(&state, path, headers, message).await {
Ok(session) => session,
Err(response) => return response,
@@ -757,10 +767,10 @@ pub(super) async fn handle_legacy_request(
}
// A notification whose method the registration does not map to this adapter's handlers is
// acknowledged without being dispatched, exactly as before.
_ if is_notification(message) => StatusCode::ACCEPTED.into_response(),
_ if envelope.is_notification() => StatusCode::ACCEPTED.into_response(),
// Every remaining decision (unregistered, wrong era, or a handler this adapter does not
// serve) is a method-level rejection: no handler, no service entry, no outbound call.
_ => match method_name(message) {
_ => match method {
Some(method) => transport_response(
StatusCode::OK,
jsonrpc_error(
@@ -0,0 +1,151 @@
//! Generic SDK envelopes for routing after the authoritative Crank admission guard.
use rmcp::model::{JsonRpcNotification, JsonRpcRequest};
use serde_json::{Value, json};
#[derive(Debug)]
pub(crate) enum DispatchEnvelope {
Request(JsonRpcRequest<Value>),
Notification(JsonRpcNotification<Value>),
}
impl DispatchEnvelope {
pub(crate) fn method(&self) -> Option<&str> {
let payload = match self {
Self::Request(envelope) => &envelope.request,
Self::Notification(envelope) => &envelope.notification,
};
payload.get("method").and_then(Value::as_str)
}
pub(crate) fn is_request(&self) -> bool {
matches!(self, Self::Request(_))
}
pub(crate) fn is_notification(&self) -> bool {
matches!(self, Self::Notification(_))
}
}
/// 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,
) -> Result<Option<DispatchEnvelope>, serde_json::Error> {
let Some(method) = message.get("method") else {
return Ok(None);
};
let mut projection = json!({"jsonrpc": message.get("jsonrpc"), "method": method});
let envelope = if let Some(id) = message.get("id") {
// SDK ids are string/i64; the surrogate must never leave this routing-only envelope.
projection["id"] = if id.is_number() && id.as_i64().is_none() {
json!(0)
} else {
id.clone()
};
DispatchEnvelope::Request(serde_json::from_value(projection)?)
} else {
DispatchEnvelope::Notification(serde_json::from_value(projection)?)
};
#[cfg(test)]
crate::app::dispatch_observer::sdk_dispatch_envelope_decoded();
Ok(Some(envelope))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn arbitrary_method_ignores_params_and_mixed_extra_fields() {
for params in [
None,
Some(json!({})),
Some(json!({
"_meta": {"clientInfo": false}, "extension": [null, 3]
})),
] {
let mut message = json!({
"jsonrpc": "2.0", "id": "request", "method": "private/arbitrary",
"result": false, "error": [1], "extension": {"anything": true}
});
if let Some(params) = params {
message["params"] = params;
}
let original = message.clone();
let envelope = decode_dispatch_envelope(&message)
.expect("admitted request decodes")
.expect("request envelope");
assert_eq!(envelope.method(), Some("private/arbitrary"));
assert!(envelope.is_request());
assert!(!envelope.is_notification());
let DispatchEnvelope::Request(request) = envelope else {
panic!("request must retain its SDK variant");
};
assert_eq!(request.request, json!({"method": "private/arbitrary"}));
assert_eq!(message, original);
}
}
#[test]
fn request_ids_preserve_raw_value_and_only_surrogate_sdk_incompatible_numbers() {
for (id, sdk_id) in [
(json!("string-id"), json!("string-id")),
(json!(i64::MIN), json!(i64::MIN)),
(json!(i64::MAX), json!(i64::MAX)),
(json!(u64::MAX), json!(0)),
(json!(1.25), json!(0)),
(json!(1.0), json!(0)),
] {
let message = json!({"jsonrpc": "2.0", "id": id, "method": "arbitrary"});
let original = message.clone();
let DispatchEnvelope::Request(request) = decode_dispatch_envelope(&message)
.expect("admitted id decodes")
.expect("request envelope")
else {
panic!("id-bearing method must be a request");
};
assert_eq!(serde_json::to_value(request.id).expect("SDK id"), sdk_id);
assert_eq!(message, original);
assert_eq!(message.to_string(), original.to_string());
}
}
#[test]
fn notification_kind_is_independent_of_method_and_ignored_fields() {
let message = json!({
"jsonrpc": "2.0", "method": "private/arbitrary", "params": {},
"result": {}, "error": {}, "extension": 42
});
let original = message.clone();
let envelope = decode_dispatch_envelope(&message)
.expect("notification decodes")
.expect("notification envelope");
assert_eq!(envelope.method(), Some("private/arbitrary"));
assert!(!envelope.is_request());
assert!(envelope.is_notification());
let DispatchEnvelope::Notification(notification) = envelope else {
panic!("notification must retain its SDK variant");
};
assert_eq!(
notification.notification,
json!({"method": "private/arbitrary"})
);
assert_eq!(message, original);
}
#[test]
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"}}),
json!({"jsonrpc": "2.0", "error": {"code": -1, "message": "error"}}),
] {
assert!(
decode_dispatch_envelope(&message)
.expect("response bypass")
.is_none()
);
}
}
}
+5 -45
View File
@@ -26,13 +26,17 @@ use crate::transport::{json_response, protocol_version_from_headers, singleton_h
mod command;
mod completion;
mod dispatch_sdk;
mod lifecycle_sdk;
mod logging;
mod prompts;
mod registry;
mod resources;
mod response_sdk;
mod signals;
pub(crate) use dispatch_sdk::decode_dispatch_envelope;
pub(crate) use command::{
ContinuationSupport, ServiceContext, ToolCallCommand, ToolCallOutcome, ToolsCommand,
ToolsListCommand, ToolsOutcome, handle_tools_command,
@@ -88,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
@@ -257,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,330 @@
//! #107 generic dispatch: existing wire GREEN precedes independent SDK RED assertions.
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};
#[path = "rmcp_dispatch_test_support.rs"]
mod fixtures;
use fixtures::*;
async fn success_control() -> Vec<[usize; 2]> {
let h = endpoint().await;
let mut deltas = vec![];
for revision in [LEGACY_REVISION, MODERN_REVISION] {
let session = prepared(&h, revision).await;
for accept in ["application/json", "text/event-stream, application/json"] {
for id in [
json!("dispatch/Ю"),
json!(18446744073709551615u64),
json!(3.25),
] {
for method in ["tools/list", "ping"] {
let mut message = payload(revision, method, id.clone());
// Legacy params remain absent; modern identity metadata remains mandatory.
message["extension"] = json!({"future":[null,true]});
message["result"] = json!({"ignored":true});
message["error"] = json!({"ignored":"not an error envelope"});
let before = sdk(&h.counters);
let ops = h.sessions.snapshot();
let entries = h.counters.snapshot();
let response = request(&h, revision, session.as_deref(), accept, message)
.send()
.await
.unwrap();
assert_eq!(response.status(), 200);
assert_eq!(response.headers()["MCP-Protocol-Version"], revision);
assert!(response.headers().get("MCP-Session-Id").is_none());
let wire = body(response, accept.starts_with("text/event-stream")).await;
assert_eq!(wire["jsonrpc"], "2.0");
assert_eq!(wire["id"], id, "lossless response correlation");
assert!(wire.get("error").is_none(), "{wire}");
if method == "tools/list" {
assert_eq!(wire["result"]["tools"][0]["name"], TOOL_NAME);
assert_eq!(wire["result"]["tools"].as_array().unwrap().len(), 1);
} else {
let result = if revision == MODERN_REVISION {
json!({"protocolVersion":revision,"resultType":"complete"})
} else {
json!({"protocolVersion":revision})
};
assert_eq!(wire, json!({"jsonrpc":"2.0","id":id,"result":result}));
}
if revision == MODERN_REVISION {
assert_eq!(wire["result"]["resultType"], "complete");
assert_eq!(h.sessions.snapshot(), ops, "no modern session access");
}
assert_deltas(
method,
entries,
h.counters.snapshot(),
Snapshot::new(
1,
usize::from(revision == MODERN_REVISION),
usize::from(revision == LEGACY_REVISION),
usize::from(method == "tools/list"),
),
);
assert_eq!(h.started.load(Ordering::SeqCst), 0);
let after = sdk(&h.counters);
deltas.push([after[0] - before[0], after[1] - before[1]]);
}
}
}
}
eprintln!(
"existing GREEN 24 HTTP requests after legacy handshake / modern discovery; SDK deltas={deltas:?}"
);
deltas
}
#[tokio::test]
async fn wire_positive_control_json_sse_ids_tolerance_and_routes() {
success_control().await;
}
#[tokio::test]
async fn sdk_envelope_decoded_on_successful_http() {
let deltas = success_control().await;
assert_eq!(
deltas.iter().map(|d| d[0]).collect::<Vec<_>>(),
vec![1; 24],
"successful HTTP must decode a real SDK request envelope"
);
}
#[tokio::test]
async fn sdk_envelope_consumed_for_registry_routing_on_successful_http() {
let deltas = success_control().await;
assert_eq!(
deltas.iter().map(|d| d[1]).collect::<Vec<_>>(),
vec![1; 24],
"decoded SDK method/kind must drive registry routing, not decode-and-discard"
);
}
async fn notification_control() -> Vec<[usize; 2]> {
let h = endpoint().await;
let response = request(
&h,
LEGACY_REVISION,
None,
"application/json",
legacy_initialize(1),
)
.send()
.await
.unwrap();
assert_eq!(response.status(), 200);
let session = response.headers()["MCP-Session-Id"]
.to_str()
.unwrap()
.to_owned();
let _ = body(response, false).await;
for method in ["notifications/initialized", "unknown/notification"] {
let mut wrong_kind = json!({"jsonrpc":"2.0","id":"wrong-kind","method":method});
let ops = h.sessions.snapshot();
let response = request(
&h,
LEGACY_REVISION,
Some(&session),
"application/json",
wrong_kind.clone(),
)
.send()
.await
.unwrap();
assert_eq!(response.status(), 200);
assert_eq!(body(response, false).await["error"]["code"], -32601);
assert_eq!(h.sessions.snapshot().mark_initialized, ops.mark_initialized);
assert!(!h.sessions.retained(&session).await.unwrap().initialized);
wrong_kind.as_object_mut().unwrap().remove("id");
if method.starts_with("unknown") {
ack(request(
&h,
LEGACY_REVISION,
Some(&session),
"application/json",
wrong_kind,
)
.send()
.await
.unwrap())
.await;
assert!(!h.sessions.retained(&session).await.unwrap().initialized);
}
}
let before = sdk(&h.counters);
ack(request(
&h,
LEGACY_REVISION,
Some(&session),
"application/json",
initialized_notification(),
)
.send()
.await
.unwrap())
.await;
assert!(h.sessions.retained(&session).await.unwrap().initialized);
let after = sdk(&h.counters);
let mut deltas = vec![[after[0] - before[0], after[1] - before[1]]];
let ops = h.sessions.snapshot();
let entries = h.counters.snapshot();
for method in [
"notifications/initialized",
"unknown/notification",
"tools/call",
] {
let mut message = payload(MODERN_REVISION, method, json!(1));
message.as_object_mut().unwrap().remove("id");
let mut req = request(&h, MODERN_REVISION, None, "application/json", message)
.build()
.unwrap();
req.headers_mut().remove("Mcp-Method");
req.headers_mut().remove("Mcp-Name");
let before = sdk(&h.counters);
ack(reqwest::Client::new().execute(req).await.unwrap()).await;
let after = sdk(&h.counters);
deltas.push([after[0] - before[0], after[1] - before[1]]);
}
assert_eq!(h.sessions.snapshot(), ops);
assert_eq!(h.counters.snapshot().tools_service, entries.tools_service);
assert_eq!(h.started.load(Ordering::SeqCst), 0);
eprintln!("existing GREEN notification kind/state/early ACK; SDK deltas={deltas:?}");
deltas
}
#[tokio::test]
async fn notification_order_and_legacy_registered_kind_wire_control() {
notification_control().await;
}
#[tokio::test]
async fn sdk_notification_kind_consumed_on_successful_http() {
assert_eq!(
notification_control().await,
vec![[1, 1]; 4],
"SDK notification variant must drive legacy handshake / modern early ACK"
);
}
#[tokio::test]
async fn rejection_controls_never_enter_service_or_outbound() {
let h = endpoint().await;
for revision in [LEGACY_REVISION, MODERN_REVISION] {
let session = prepared(&h, revision).await;
let base = payload(revision, "tools/list", json!("reject"));
let mut malformed = base.clone();
malformed["jsonrpc"] = json!("1.0");
let mut bad_params = base.clone();
bad_params["params"] = json!([]);
let mut bad_meta = base.clone();
bad_meta["params"] = json!({"_meta":false});
let unknown = payload(revision, "unknown/request", json!("reject"));
let wrong_era = payload(
revision,
if revision == MODERN_REVISION {
"initialize"
} else {
"server/discover"
},
json!("reject"),
);
for (message, status, code) in [
(malformed, 400, -32600),
(bad_params, 400, -32600),
(bad_meta, 400, -32020),
(
unknown,
if revision == MODERN_REVISION {
404
} else {
200
},
-32601,
),
(
wrong_era,
if revision == MODERN_REVISION {
404
} else {
200
},
-32601,
),
] {
let entries = h.counters.snapshot();
let ops = h.sessions.snapshot();
let response = request(
&h,
revision,
session.as_deref(),
"application/json",
message.clone(),
)
.send()
.await
.unwrap();
assert_eq!(response.status().as_u16(), status, "{revision} {message}");
let wire = body(response, false).await;
assert_eq!(wire["error"]["code"], code, "{revision} {message}: {wire}");
assert!(wire.get("result").is_none());
assert_eq!(h.counters.snapshot().tools_service, entries.tools_service);
assert_eq!(h.started.load(Ordering::SeqCst), 0);
if revision == MODERN_REVISION {
assert_eq!(h.sessions.snapshot(), ops);
}
}
}
for (header, value) in [("Mcp-Method", "ping"), ("Mcp-Name", "wrong-tool")] {
let ops = h.sessions.snapshot();
let entries = h.counters.snapshot();
let message = json!({"jsonrpc":"2.0","id":"headers","method":"tools/call","params":{"name":TOOL_NAME,"arguments":{"email":"dispatch@example.com"},"_meta":modern_meta()}});
let response = request(&h, MODERN_REVISION, None, "application/json", message)
.header(header, value)
.send()
.await
.unwrap();
assert_eq!(response.status(), 400);
assert!(body(response, false).await.get("error").is_some());
assert_eq!(h.sessions.snapshot(), ops);
assert_eq!(h.counters.snapshot().tools_service, entries.tools_service);
assert_eq!(h.started.load(Ordering::SeqCst), 0);
}
let ops = h.sessions.snapshot();
let response = request(
&h,
"2099-01-01",
None,
"application/json",
payload(LEGACY_REVISION, "tools/list", json!(1)),
)
.send()
.await
.unwrap();
assert_eq!(response.status(), 400);
assert!(body(response, false).await.get("error").is_some());
assert_eq!(h.sessions.snapshot(), ops);
assert_eq!(h.started.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn observer_independent_positive_control() {
let a = Arc::new(CounterSet::default());
let b = Arc::new(CounterSet::default());
super::sdk_dispatch_envelope_decoded();
super::sdk_dispatch_envelope_consumed();
assert_eq!(sdk(&a), [0, 0]);
tokio::join!(
observe(a.clone(), async {
super::sdk_dispatch_envelope_decoded();
}),
observe(b.clone(), async {
super::sdk_dispatch_envelope_consumed();
})
);
assert_eq!(sdk(&a), [1, 0]);
assert_eq!(sdk(&b), [0, 1]);
assert_eq!(a.snapshot(), Snapshot::new(0, 0, 0, 0));
assert_eq!(b.snapshot(), Snapshot::new(0, 0, 0, 0));
}
@@ -0,0 +1,103 @@
//! Narrow HTTP helpers; all app/auth/catalog/upstream fixtures remain shared.
use super::*;
pub(super) async fn endpoint() -> Endpoint {
crank_test_support::postgres_schema_url_for_task("dispatch_owner", "t_e862066c").await;
Endpoint::started().await
}
pub(super) fn sdk(c: &CounterSet) -> [usize; 2] {
[c.sdk_dispatch_decoded(), c.sdk_dispatch_consumed()]
}
pub(super) fn payload(revision: &str, method: &str, id: Value) -> Value {
let mut message = json!({"jsonrpc":"2.0","id":id,"method":method});
if revision == MODERN_REVISION {
message["params"] = json!({"_meta":modern_meta()});
}
message
}
pub(super) fn request(
h: &Endpoint,
revision: &str,
session: Option<&str>,
accept: &str,
message: Value,
) -> reqwest::RequestBuilder {
h.request(revision, session, &h.key, accept, message)
.header("x-request-id", "dispatch-atdd")
.header(
"traceparent",
"00-11111111111111111111111111111111-2222222222222222-01",
)
}
pub(super) async fn body(response: reqwest::Response, sse: bool) -> Value {
assert_eq!(response.headers()["x-request-id"], "dispatch-atdd");
assert_eq!(
response.headers()["x-trace-id"],
"11111111111111111111111111111111"
);
assert!(
response.headers()["content-type"]
.to_str()
.unwrap()
.starts_with(if sse {
"text/event-stream"
} else {
"application/json"
})
);
let raw = tokio::time::timeout(std::time::Duration::from_secs(6), response.text())
.await
.unwrap()
.unwrap();
if sse {
let frames: Vec<Value> = raw
.lines()
.filter_map(|l| l.strip_prefix("data:"))
.map(|l| serde_json::from_str(l.trim()).unwrap())
.collect();
assert_eq!(frames.len(), 1, "one terminal SSE frame: {raw}");
frames.into_iter().next().unwrap()
} else {
serde_json::from_str(&raw).unwrap()
}
}
pub(super) 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());
}
pub(super) async fn prepared(h: &Endpoint, revision: &str) -> Option<String> {
if revision == LEGACY_REVISION {
return h.session(revision).await;
}
let ops = h.sessions.snapshot();
let response = request(
h,
revision,
None,
"application/json",
payload(revision, "server/discover", json!(1)),
)
.send()
.await
.unwrap();
assert_eq!(response.status(), 200);
assert_eq!(response.headers()["MCP-Protocol-Version"], revision);
assert!(response.headers().get("MCP-Session-Id").is_none());
let wire = body(response, false).await;
assert_eq!(
wire["result"]["supportedVersions"],
json!([MODERN_REVISION, LEGACY_REVISION])
);
assert_eq!(wire["result"]["resultType"], "complete");
assert!(wire.get("error").is_none(), "{wire}");
assert_eq!(h.sessions.snapshot(), ops);
None
}
@@ -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));
}
+4
View File
@@ -53,6 +53,10 @@ Ping-срез #107 на базе rc.28/rmcp3.9.0 подключает обе ш
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 не запускаются.
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.