Compare commits

...
Author SHA1 Message Date
bsodfather 8068fd7910 refactor(mcp): parse legacy initialize protocol version through SDK
CI / UI Checks (pull_request) Successful in 10s
CI / Rust Checks (pull_request) Successful in 31m1s
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 13:43:04 +00:00
bsodfather 2f9c4cb568 refactor(mcp): serialize negotiation results through rmcp SDK
CI / UI Checks (pull_request) Successful in 9s
CI / Rust Checks (pull_request) Successful in 31m21s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 2s
CI / Deploy (pull_request) Skipped
2026-11-12 10:48:24 +00:00
bsodfather 61378224b2 Merge pull request 'MCP: SDK success/error envelopes with preserved wire contract' (#129) from delivery/rmcp107-envelopes into main
CI / UI Checks (push) Successful in 9s
CI / Rust Checks (push) Successful in 30m11s
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 50m47s
2026-11-12 08:23:58 +00:00
bsodfather 1b51d44121 refactor(mcp): serialize success and error envelopes through SDK
CI / UI Checks (pull_request) Successful in 10s
CI / Rust Checks (pull_request) Successful in 30m13s
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 07:52:03 +00:00
bsodfather 077be3b069 Merge pull request 'refactor(mcp): catalog-change signals/listen through rmcp SDK' (#128) from work/rmcp107-signals into main
CI / UI Checks (push) Successful in 8s
CI / Rust Checks (push) Successful in 29m23s
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 49m26s
2026-11-12 05:31:56 +00:00
bsodfather 42e7728b3a refactor(mcp): migrate catalog-change signals and listen to rmcp SDK
CI / UI Checks (pull_request) Successful in 8s
CI / Rust Checks (pull_request) Successful in 29m12s
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 05:02:14 +00:00
bsodfather 541b135baf Merge pull request 'refactor(mcp): progress and legacy cancellation via rmcp SDK (#107 slice)' (#127) from delivery/rmcp107-progress-cancel into main
CI / UI Checks (push) Successful in 10s
CI / Rust Checks (push) Successful in 27m48s
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 47m12s
2026-11-12 02:49:10 +00:00
bsodfather 835947e9fc refactor(mcp): migrate progress and legacy cancel params to rmcp SDK
CI / UI Checks (pull_request) Successful in 8s
CI / Rust Checks (pull_request) Successful in 27m22s
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 02:20:43 +00:00
23 changed files with 3140 additions and 145 deletions

No files matched your search

+1
View File
@@ -40,6 +40,7 @@ mod rmcp_http;
#[cfg(test)]
#[path = "rmcp_http_tests.rs"]
mod rmcp_http_tests;
mod rmcp_progress_cancel;
#[cfg(test)]
mod rmcp_session_tests;
#[cfg(test)]
+11 -14
View File
@@ -5,7 +5,7 @@
//! Moved verbatim out of `app.rs` (Story 3.6, kanban t_987bf309); it is called from
//! `app/endpoint.rs`, so the entry points are `pub(super)`. No behaviour changed.
use super::request::{InitializeParams, ToolCallParams};
use super::request::ToolCallParams;
use super::response::take_confirmation_token;
use super::rmcp_dispatch::{
handle_resources_command, handle_tools_command, list_resource_templates,
@@ -777,7 +777,8 @@ pub(super) async fn handle_initialize(
message: &Value,
response_mode: ResponseMode,
) -> Response {
let initialize_params: InitializeParams = match serde_json::from_value(params(message)) {
let raw_params = params(message);
let initialize_params = match crate::protocol::initialize_params(&raw_params) {
Ok(value) => value,
Err(_error) => {
return transport_response(
@@ -789,7 +790,10 @@ pub(super) async fn handle_initialize(
);
}
};
let Some(protocol_version) = negotiated_protocol_version(&initialize_params.protocol_version)
#[cfg(test)]
super::dispatch_observer::sdk_initialize_input_consumed(&initialize_params);
let Some(protocol_version) =
negotiated_protocol_version(initialize_params.protocol_version.as_str())
else {
// A revision outside the approved window is rejected without minting a session and without
// echoing any withdrawn revision as the served identity.
@@ -810,9 +814,9 @@ pub(super) async fn handle_initialize(
};
let now = OffsetDateTime::now_utc();
let expires_at = add_millis(now, TRANSPORT_SESSION_TTL_MS);
let supports_elicitation = initialize_params
.capabilities
.get("elicitation")
let supports_elicitation = raw_params
.get("capabilities")
.and_then(|capabilities| capabilities.get("elicitation"))
.is_some_and(Value::is_object);
let session_id = match state
.sessions
@@ -835,14 +839,7 @@ pub(super) async fn handle_initialize(
StatusCode::OK,
jsonrpc_result(
request_id(message),
json!( {
"protocolVersion": protocol_version,
"capabilities": crate::protocol::advertised_server_capabilities(protocol_version),
"serverInfo": {
"name": SERVER_NAME,
"version": SERVER_VERSION
}
}),
crate::protocol::initialize_result(protocol_version, SERVER_NAME, SERVER_VERSION),
),
response_mode,
Some(&session_id),
@@ -66,9 +66,51 @@ pub(crate) struct CounterSet {
sdk_logging_dispatch: AtomicUsize,
sdk_logging_level: AtomicUsize,
sdk_logging_notification: AtomicUsize,
sdk_progress_notification: AtomicUsize,
sdk_cancelled_params: AtomicUsize,
sdk_subscriptions_listen: AtomicUsize,
sdk_subscriptions_acknowledged: AtomicUsize,
sdk_signal_notification: AtomicUsize,
sdk_jsonrpc_response: AtomicUsize,
sdk_jsonrpc_error: AtomicUsize,
sdk_initialize_input: AtomicUsize,
sdk_initialize_result: AtomicUsize,
sdk_discover_result: AtomicUsize,
}
impl CounterSet {
pub(crate) fn sdk_initialize_input(&self) -> usize {
self.sdk_initialize_input.load(Ordering::SeqCst)
}
pub(crate) fn sdk_initialize_result(&self) -> usize {
self.sdk_initialize_result.load(Ordering::SeqCst)
}
pub(crate) fn sdk_discover_result(&self) -> usize {
self.sdk_discover_result.load(Ordering::SeqCst)
}
pub(crate) fn sdk_jsonrpc_response(&self) -> usize {
self.sdk_jsonrpc_response.load(Ordering::SeqCst)
}
pub(crate) fn sdk_jsonrpc_error(&self) -> usize {
self.sdk_jsonrpc_error.load(Ordering::SeqCst)
}
pub(crate) fn sdk_subscriptions_listen(&self) -> usize {
self.sdk_subscriptions_listen.load(Ordering::SeqCst)
}
pub(crate) fn sdk_subscriptions_acknowledged(&self) -> usize {
self.sdk_subscriptions_acknowledged.load(Ordering::SeqCst)
}
pub(crate) fn sdk_signal_notification(&self) -> usize {
self.sdk_signal_notification.load(Ordering::SeqCst)
}
pub(crate) fn sdk_progress_notification(&self) -> usize {
self.sdk_progress_notification.load(Ordering::SeqCst)
}
pub(crate) fn sdk_cancelled_params(&self) -> usize {
self.sdk_cancelled_params.load(Ordering::SeqCst)
}
pub(crate) fn sdk_logging_dispatch(&self) -> usize {
self.sdk_logging_dispatch.load(Ordering::SeqCst)
}
@@ -302,6 +344,72 @@ pub(crate) fn sdk_logging_notification_serialized() {
#[path = "../rmcp_logging_runtime_tests.rs"]
mod rmcp_logging_runtime_tests;
/// Mark only after successfully serializing real SDK ProgressNotificationParam params.
pub(crate) fn sdk_progress_notification_serialized() {
increment(|counters| &counters.sdk_progress_notification);
}
/// Mark successful SDK CancelledNotificationParam decoding, not successful cancellation.
pub(crate) fn sdk_cancelled_params_decoded() {
increment(|counters| &counters.sdk_cancelled_params);
}
#[path = "../rmcp_progress_cancel_runtime_tests.rs"]
mod rmcp_progress_cancel_runtime_tests;
pub(crate) fn installed_observer() -> Option<Arc<CounterSet>> {
OBSERVER.try_with(Arc::clone).ok()
}
pub(crate) fn sdk_subscriptions_listen_decoded() {
increment(|counters| &counters.sdk_subscriptions_listen);
}
pub(crate) fn sdk_subscriptions_acknowledged_serialized() {
increment(|counters| &counters.sdk_subscriptions_acknowledged);
}
pub(crate) fn sdk_signal_notification_serialized() {
increment(|counters| &counters.sdk_signal_notification);
}
#[path = "../rmcp_signals_runtime_tests.rs"]
mod rmcp_signals_runtime_tests;
/// Mark only immediately after successfully serializing a real SDK JsonRpcResponse.
pub(crate) fn sdk_jsonrpc_response_serialized() {
increment(|counters| &counters.sdk_jsonrpc_response);
}
/// Mark only immediately after successfully serializing a real SDK JsonRpcError.
pub(crate) fn sdk_jsonrpc_error_serialized() {
increment(|counters| &counters.sdk_jsonrpc_error);
}
#[path = "../rmcp_envelopes_runtime_tests.rs"]
mod rmcp_envelopes_runtime_tests;
/// Mark only after successfully serializing a real rmcp InitializeResult.
pub(crate) fn sdk_initialize_result_serialized() {
increment(|counters| &counters.sdk_initialize_result);
}
/// Mark only after successfully serializing a real rmcp DiscoverResult.
pub(crate) fn sdk_discover_result_serialized() {
increment(|counters| &counters.sdk_discover_result);
}
#[path = "../rmcp_lifecycle_negotiation_runtime_tests.rs"]
mod rmcp_lifecycle_negotiation_runtime_tests;
/// Mark only where SDK protocol_version is consumed by initialize negotiation, not at DTO creation.
pub(crate) fn sdk_initialize_input_consumed(_params: &rmcp::model::InitializeRequestParams) {
increment(|counters| &counters.sdk_initialize_input);
}
#[path = "../rmcp_initialize_input_runtime_tests.rs"]
mod rmcp_initialize_input_runtime_tests;
fn increment(counter: impl Fn(&CounterSet) -> &AtomicUsize) {
let _ = OBSERVER.try_with(|counters| {
counter(counters).fetch_add(1, Ordering::SeqCst);
@@ -799,27 +799,24 @@ async fn handle_cancelled_notification(
message: &Value,
credential: &VerifiedMachineCredential,
) -> Response {
let request_id = params(message).get("requestId").cloned();
let request_id = super::rmcp_progress_cancel::decode_cancelled_request_id(&params(message));
let session_id = session_id_from_headers(headers).ok().flatten();
if let (Some(request_id), Some(session_id)) = (request_id, session_id) {
// Only a string or a number is a pinned `RequestId`; anything else cannot name a call.
if matches!(request_id, Value::String(_) | Value::Number(_)) {
let owned_by_session = match state.sessions.get(&session_id).await {
Ok(Some(session)) => {
session.workspace_slug == path.workspace_slug
&& session.agent_slug == path.agent_slug
}
_ => false,
};
if owned_by_session {
state.in_flight.cancel(
&crate::app::lifecycle::InFlightScope {
session_id,
owner: in_flight_owner(credential),
},
&request_id,
);
let owned_by_session = match state.sessions.get(&session_id).await {
Ok(Some(session)) => {
session.workspace_slug == path.workspace_slug
&& session.agent_slug == path.agent_slug
}
_ => false,
};
if owned_by_session {
state.in_flight.cancel(
&crate::app::lifecycle::InFlightScope {
session_id,
owner: in_flight_owner(credential),
},
&request_id,
);
}
}
StatusCode::ACCEPTED.into_response()
@@ -34,6 +34,7 @@ use axum::{
};
use crank_core::{CorrelationContext, ExecutionLocale, VerifiedMachineCredential};
use futures_util::stream;
use rmcp::model::{NumberOrString, ProgressNotificationParam};
use serde_json::{Number, Value, json};
use tokio::sync::{mpsc, watch};
@@ -82,10 +83,13 @@ impl ProgressToken {
}
}
fn as_value(&self) -> Value {
fn sdk_token(&self) -> NumberOrString {
match self {
Self::Text(text) => Value::String(text.clone()),
Self::Number(number) => Value::Number(number.clone()),
Self::Text(text) => NumberOrString::String(text.clone().into()),
Self::Number(number) => number.as_i64().map_or_else(
|| NumberOrString::String(number.to_string().into()),
NumberOrString::Number,
),
}
}
}
@@ -132,14 +136,24 @@ pub(crate) struct ProgressEvent {
/// The pinned `notifications/progress` frame. Both supported revisions declare the same parameters,
/// so the projection is shared; the token is echoed verbatim and never validated as a credential.
pub(super) fn progress_frame(token: &ProgressToken, event: &ProgressEvent) -> Value {
let sdk_params = ProgressNotificationParam::new(
rmcp::model::ProgressToken(token.sdk_token()),
event.progress as f64,
)
.with_message(event.message);
let mut params = serde_json::to_value(sdk_params)
.expect("finite progress and string/number token are serializable SDK params");
#[cfg(test)]
super::dispatch_observer::sdk_progress_notification_serialized();
// SDK uses i64 tokens and f64 progress; restore the original JSON numbers before wire delivery.
if let ProgressToken::Number(number) = token {
params["progressToken"] = Value::Number(number.clone());
}
params["progress"] = Value::from(event.progress);
json!({
"jsonrpc": "2.0",
"method": "notifications/progress",
"params": {
"progressToken": token.as_value(),
"progress": event.progress,
"message": event.message,
}
"params": params,
})
}
@@ -7,6 +7,44 @@ fn token(value: Value) -> Option<ProgressToken> {
progress_token(&json!({ "_meta": { "progressToken": value } }))
}
#[test]
fn rmcp_progress_cancel_frame_preserves_serialized_numbers_and_omissions() {
for wire_token in [
"\"token\"",
"-7",
"1.5",
"1.0",
"-0.0",
"18446744073709551615",
] {
let value: Value = serde_json::from_str(wire_token).unwrap();
for progress in [2, 9_007_199_254_740_993, u64::MAX] {
let frame = progress_frame(
&token(value.clone()).unwrap(),
&ProgressEvent {
progress,
message: "execution_dispatched",
},
);
assert_eq!(frame["params"]["progressToken"].to_string(), wire_token);
assert_eq!(
frame["params"]["progress"].to_string(),
progress.to_string()
);
assert_eq!(
frame["params"],
json!({
"progressToken": value, "progress": progress, "message": "execution_dispatched"
})
);
assert!(frame["params"].get("total").is_none());
assert!(frame["params"].get("_meta").is_none());
assert_eq!(frame["jsonrpc"], "2.0");
assert_eq!(frame["method"], "notifications/progress");
}
}
}
#[test]
fn a_pinned_progress_token_is_a_bounded_string_or_a_number() {
assert_eq!(
@@ -1,14 +1,6 @@
use serde::{Deserialize, Serialize};
use serde_json::Value;
#[derive(Debug, Serialize, Deserialize)]
pub(super) struct InitializeParams {
#[serde(rename = "protocolVersion")]
pub(super) protocol_version: String,
#[serde(default)]
pub(super) capabilities: Value,
}
#[derive(Debug, Serialize, Deserialize)]
pub(super) struct ToolCallParams {
pub(super) name: String,
@@ -0,0 +1,31 @@
//! Lossless projection of legacy cancellation targets through the pinned SDK.
use rmcp::model::CancelledNotificationParam;
use serde_json::{Map, Value};
pub(super) fn decode_cancelled_request_id(params: &Value) -> Option<Value> {
let mut projection = Map::new();
let original_id = params.get("requestId");
if let Some(id) = original_id {
// SDK IDs use i64; the temporary string never reaches the in-flight lookup.
let projected = match id {
Value::Number(number) if number.as_i64().is_none() => Value::String(number.to_string()),
_ => id.clone(),
};
projection.insert("requestId".to_owned(), projected);
}
// Only requestId names a target; reason, _meta and extensions retain their ignore semantics.
let decoded =
serde_json::from_value::<CancelledNotificationParam>(Value::Object(projection)).ok()?;
#[cfg(test)]
super::dispatch_observer::sdk_cancelled_params_decoded();
let id = decoded.request_id?;
Some(match original_id {
Some(Value::Number(number)) => Value::Number(number.clone()),
_ => id.into_json_value(),
})
}
#[cfg(test)]
#[path = "rmcp_progress_cancel_tests.rs"]
mod tests;
@@ -0,0 +1,52 @@
use super::decode_cancelled_request_id;
use serde_json::{Value, json};
#[test]
fn rmcp_progress_cancel_decoder_preserves_exact_ids_and_ignores_other_fields() {
for wire_id in [
"\"7\"",
"7",
"-7",
"1.5",
"1.0",
"-0.0",
"18446744073709551615",
"\"\"",
"\"line\\nbreak\"",
] {
let id: Value = serde_json::from_str(wire_id).unwrap();
let params = json!({
"requestId": id, "reason": 42, "_meta": [], "unknown": {"nested": [true]}
});
let decoded = decode_cancelled_request_id(&params).unwrap();
assert_eq!(decoded.to_string(), wire_id);
}
let long_id = Value::String("x".repeat(1024));
assert_eq!(
decode_cancelled_request_id(&json!({"requestId": long_id})),
Some(long_id)
);
assert_ne!(
decode_cancelled_request_id(&json!({"requestId": "7"})),
decode_cancelled_request_id(&json!({"requestId": 7}))
);
}
#[test]
fn rmcp_progress_cancel_decoder_has_no_target_for_invalid_or_missing_ids() {
for params in [
json!(null),
json!(true),
json!(7),
json!("requestId"),
json!([]),
json!({}),
json!({"requestId": null}),
json!({"requestId": true}),
json!({"requestId": []}),
json!({"requestId": {}}),
json!({"reason": "ignored", "_meta": []}),
] {
assert_eq!(decode_cancelled_request_id(&params), None, "{params}");
}
}
@@ -122,6 +122,17 @@ pub(super) struct CountedSessionStore {
counters: Arc<SessionCounters>,
}
impl CountedSessionStore {
pub(super) fn snapshot(&self) -> SessionOps {
self.counters.snapshot()
}
/// Inspect retained state without incrementing the HTTP request's session-read oracle.
pub(super) async fn retained(&self, id: &str) -> Option<SessionState> {
self.inner.get(id).await.unwrap()
}
}
#[async_trait::async_trait]
impl TransportSessionStore for CountedSessionStore {
async fn create(
+125 -17
View File
@@ -1,3 +1,6 @@
use rmcp::model::{
ErrorCode, ErrorData, JsonRpcError, JsonRpcResponse, JsonRpcVersion2_0, RequestId,
};
use serde_json::{Value, json};
/// The two approved MCP revisions (`docs/`-approved window of 2026-10-11).
@@ -60,28 +63,50 @@ pub fn is_response(message: &Value) -> bool {
&& (message.get("result").is_some() || message.get("error").is_some())
}
fn projected_sdk_id(id: &Value) -> RequestId {
match id {
Value::String(value) => RequestId::String(value.as_str().into()),
Value::Number(value) => RequestId::Number(value.as_i64().unwrap_or(0)),
_ => RequestId::Number(0),
}
}
pub fn jsonrpc_result(id: Value, result: Value) -> Value {
json!({
"jsonrpc": "2.0",
"id": id,
"result": result
})
let sdk = JsonRpcResponse::<Value> {
jsonrpc: JsonRpcVersion2_0,
id: projected_sdk_id(&id),
result,
};
let mut wire = serde_json::to_value(sdk).expect("SDK response contains only JSON values");
#[cfg(test)]
crate::app::dispatch_observer::sdk_jsonrpc_response_serialized();
// SDK RequestId cannot preserve the full Value domain or floating-point form.
wire["id"] = id;
wire
}
pub fn jsonrpc_error(id: Value, code: i64, message: impl Into<String>) -> Value {
let mut error = json!({
"code": code,
"message": message.into()
});
let (request_id, trace_id) = crank_observability::current_request_correlation();
if request_id.is_some() && trace_id.is_some() {
error["data"] = correlated_error_data(json!({}));
}
json!({
"jsonrpc": "2.0",
"id": id,
"error": error
})
let data = if request_id.is_some() && trace_id.is_some() {
Some(correlated_error_data(json!({})))
} else {
None
};
let sdk = JsonRpcError::new(
Some(projected_sdk_id(&id)),
ErrorData::new(
ErrorCode(i32::try_from(code).unwrap_or(0)),
message.into(),
data,
),
);
let mut wire = serde_json::to_value(sdk).expect("SDK error contains only JSON values");
#[cfg(test)]
crate::app::dispatch_observer::sdk_jsonrpc_error_serialized();
// Restore the helper's wider id/code contract before exposing the SDK envelope.
wire["id"] = id;
wire["error"]["code"] = Value::from(code);
wire
}
pub fn correlated_error_data(mut data: Value) -> Value {
@@ -104,3 +129,86 @@ pub fn negotiated_protocol_version(requested: &str) -> Option<&'static str> {
.copied()
.find(|version| *version == requested)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn jsonrpc_preserves_helper_values_and_numeric_forms() {
let values = [
json!(""),
json!("Юникод"),
json!(i64::MIN),
json!(i64::MAX),
json!(9007199254740993_u64),
json!(u64::MAX),
json!(1.5),
json!(1.0),
json!(-0.0),
Value::Null,
json!(true),
json!([null, u64::MAX]),
json!({"extension": {"nested": null}}),
];
for id in &values {
for result in &values {
let actual = jsonrpc_result(id.clone(), result.clone());
let expected = json!({"jsonrpc": "2.0", "id": id, "result": result});
assert_eq!(actual, expected);
assert_eq!(actual.to_string(), expected.to_string());
}
for code in [
i64::MIN,
i64::from(i32::MIN) - 1,
i64::from(i32::MIN),
-32602,
0,
i64::from(i32::MAX),
i64::from(i32::MAX) + 1,
i64::MAX,
] {
for message in ["", "Ошибка Ю"] {
let actual = jsonrpc_error(id.clone(), code, message);
let expected = json!({"jsonrpc": "2.0", "id": id,
"error": {"code": code, "message": message}});
assert_eq!(actual, expected);
assert_eq!(actual.to_string(), expected.to_string());
}
}
}
}
#[tokio::test]
async fn jsonrpc_error_requires_complete_valid_correlation() {
use crank_observability::{current_request_correlation, with_request_correlation};
let request_id = "request-123";
let trace_id = "1234567890abcdef1234567890abcdef";
for (request, trace) in [("", ""), (request_id, ""), ("", trace_id)] {
with_request_correlation(request.into(), trace.into(), async {
assert_eq!(current_request_correlation(), (None, None));
assert_eq!(
jsonrpc_error(Value::Null, -32602, "error"),
json!({"jsonrpc": "2.0", "id": null,
"error": {"code": -32602, "message": "error"}})
);
})
.await;
}
with_request_correlation(request_id.into(), trace_id.into(), async {
assert_eq!(
jsonrpc_error(Value::Null, i64::MAX, "Ошибка"),
json!({"jsonrpc": "2.0", "id": null, "error": {
"code": i64::MAX, "message": "Ошибка",
"data": {"request_id": request_id, "trace_id": trace_id}}})
);
assert_eq!(
correlated_error_data(json!({"extension": [null, u64::MAX]})),
json!({"extension": [null, u64::MAX],
"request_id": request_id, "trace_id": trace_id})
);
})
.await;
assert_eq!(current_request_correlation(), (None, None));
}
}
@@ -0,0 +1,99 @@
//! Typed negotiation results; admission and session lifecycle remain in the HTTP adapter.
use rmcp::model::{
CacheScope, DiscoverResult, Implementation, InitializeRequestParams, InitializeResult,
ProtocolVersion, ServerCapabilities,
};
use serde_json::Value;
use super::advertised_server_capabilities;
use crate::jsonrpc::SUPPORTED_PROTOCOL_VERSIONS;
pub(crate) fn initialize_params(
params: &Value,
) -> Result<InitializeRequestParams, serde_json::Error> {
// Only protocolVersion was validated here; ignored client fields must not acquire SDK constraints.
serde_json::from_value(serde_json::json!({
"protocolVersion": params.get("protocolVersion"),
"capabilities": {},
"clientInfo": {"name": "", "version": ""}
}))
}
fn protocol_version(revision: &str) -> ProtocolVersion {
serde_json::from_value(Value::String(revision.to_owned()))
.expect("served protocol revisions are strings")
}
fn capabilities(advertised: &Value) -> ServerCapabilities {
serde_json::from_value(advertised.clone())
.expect("registry capability fragments match SDK capability shapes")
}
fn restore_registry_extensions(result: &mut Value, advertised: Value) {
let capabilities = result["capabilities"]
.as_object_mut()
.expect("SDK server capabilities serialize as an object");
// SDK ServerCapabilities has no flattened map for extra registry capability names.
for (name, settings) in advertised
.as_object()
.expect("registry capabilities are an object")
{
capabilities
.entry(name.clone())
.or_insert_with(|| settings.clone());
}
}
pub(crate) fn initialize_result(revision: &str, name: &str, version: &str) -> Value {
let advertised = advertised_server_capabilities(revision);
let result = InitializeResult::new(capabilities(&advertised))
.with_protocol_version(protocol_version(revision))
.with_server_info(Implementation::new(name, version));
let mut result = serde_json::to_value(result)
.expect("SDK initialize result with registry capabilities is serializable");
#[cfg(test)]
crate::app::dispatch_observer::sdk_initialize_result_serialized();
restore_registry_extensions(&mut result, advertised);
result
}
pub(crate) fn discover_result(revision: &str, name: &str, version: &str) -> Value {
let advertised = advertised_server_capabilities(revision);
let result = DiscoverResult::new(
SUPPORTED_PROTOCOL_VERSIONS
.iter()
.map(|revision| protocol_version(revision))
.collect(),
capabilities(&advertised),
)
.with_server_info(Implementation::new(name, version))
.with_ttl_ms(0)
.with_cache_scope(CacheScope::Private);
let mut result = serde_json::to_value(result)
.expect("SDK discovery result with registry capabilities is serializable");
#[cfg(test)]
crate::app::dispatch_observer::sdk_discover_result_serialized();
restore_registry_extensions(&mut result, advertised);
result
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn lifecycle_sdk_retains_extra_registry_capabilities_without_replacing_sdk_fields() {
let advertised =
json!({"tools":{"listChanged":false}, "inert_test_capability":{"enabled":true}});
let mut result = serde_json::to_value(InitializeResult::new(capabilities(&advertised)))
.expect("typed result serializes");
assert_eq!(
result["capabilities"],
json!({"tools":{"listChanged":false}})
);
restore_registry_extensions(&mut result, advertised.clone());
assert_eq!(result["capabilities"], advertised);
}
}
+2 -17
View File
@@ -26,6 +26,7 @@ use crate::transport::{json_response, protocol_version_from_headers, singleton_h
mod command;
mod completion;
mod lifecycle_sdk;
mod logging;
mod prompts;
mod registry;
@@ -40,6 +41,7 @@ pub(crate) use completion::{
CompletionArgument, CompletionCommand, CompletionOutcome, CompletionReference,
handle_completion_command,
};
pub(crate) use lifecycle_sdk::{discover_result, initialize_params, initialize_result};
pub(crate) use logging::{
CarriedScope, EVENT_FAILED, EVENT_LEVEL_APPLIED, EVENT_REJECTED, EVENT_SERVED, INVALID_LEVEL,
LogLevel, LogLevelStore, LoggingOutcome, SetLevelCommand, carry_scope, handle_logging_command,
@@ -844,20 +846,3 @@ pub(crate) fn resolve_request_identity(
}
}
}
/// The pinned `DiscoverResult` for `server/discover` of the revision the caller serves.
pub(crate) fn discover_result(revision: &str, server_name: &str, server_version: &str) -> Value {
json!({
"resultType": "complete",
"supportedVersions": SUPPORTED_PROTOCOL_VERSIONS,
"capabilities": advertised_server_capabilities(revision),
"_meta": {
crate::jsonrpc::META_SERVER_INFO_KEY: {
"name": server_name,
"version": server_version,
}
},
"ttlMs": 0,
"cacheScope": "private"
})
}
@@ -42,8 +42,12 @@ use std::{
use axum::response::sse::Event;
use crank_registry::PublishedAgentCatalog;
use futures_util::stream;
use serde::Deserialize;
use serde_json::{Map, Value, json};
use rmcp::model::{SubscriptionFilter, SubscriptionsListenRequestParams};
use serde::{Deserialize, Deserializer, de::Error};
use serde_json::{Value, json};
#[path = "signals_sdk.rs"]
mod sdk;
use tokio::sync::mpsc;
use tracing::warn;
@@ -60,6 +64,7 @@ pub(crate) const PROMPT_LIST_CHANGED: &str = "notifications/prompts/list_changed
/// `notifications/tools/list_changed` (both approved revisions, Story 3.5).
pub(crate) const TOOL_LIST_CHANGED: &str = "notifications/tools/list_changed";
/// `notifications/subscriptions/acknowledged` (modern revision only).
#[cfg(test)]
pub(crate) const SUBSCRIPTIONS_ACKNOWLEDGED: &str = "notifications/subscriptions/acknowledged";
/// Engineering default of the watcher tick. It is not a measured latency SLO: the story only needs
@@ -113,32 +118,61 @@ impl Signals {
}
}
/// The pinned modern `SubscriptionFilter`, as far as this server reads it.
///
/// Unknown members are ignored and a malformed shape is a deserialization error, so a client cannot
/// reach the watcher with anything but the reviewed field set.
#[derive(Debug, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct ListenFilter {
#[serde(default)]
tools_list_changed: bool,
#[serde(default)]
prompts_list_changed: bool,
#[serde(default)]
resources_list_changed: bool,
#[serde(default)]
resource_subscriptions: Vec<String>,
/// Compatibility bounds around the real SDK filter, not a second protocol field model.
#[derive(Debug, Default)]
pub(crate) struct ListenFilter(SubscriptionFilter);
// SDK optional fields accept null; the existing public filter contract rejects explicit null.
fn validate_filter(value: &Value) -> Result<(), &'static str> {
let object = value.as_object().ok_or(INVALID_LISTEN_FILTER)?;
for key in [
"toolsListChanged",
"promptsListChanged",
"resourcesListChanged",
"resourceSubscriptions",
] {
if object.get(key).is_some_and(Value::is_null) {
return Err(INVALID_LISTEN_FILTER);
}
}
Ok(())
}
/// The pinned `SubscriptionsListenRequestParams`: the notification filter is a required member.
///
/// Only the reviewed member is read; `_meta` and any other member of the request params is not part
/// of this contract.
#[derive(Debug, Deserialize)]
impl<'de> Deserialize<'de> for ListenFilter {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = Value::deserialize(deserializer)?;
validate_filter(&value).map_err(D::Error::custom)?;
serde_json::from_value(value)
.map(Self)
.map_err(D::Error::custom)
}
}
/// Decode only the reviewed notifications projection: HTTP admission already owns `_meta`.
#[derive(Debug)]
pub(crate) struct ListenParams {
pub(crate) notifications: ListenFilter,
}
impl<'de> Deserialize<'de> for ListenParams {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = Value::deserialize(deserializer)?;
let notifications = value
.as_object()
.and_then(|object| object.get("notifications"))
.ok_or_else(|| D::Error::custom(INVALID_LISTEN_FILTER))?;
validate_filter(notifications).map_err(D::Error::custom)?;
let params: SubscriptionsListenRequestParams =
serde_json::from_value(json!({"notifications": notifications}))
.map_err(D::Error::custom)?;
#[cfg(test)]
crate::app::dispatch_observer::sdk_subscriptions_listen_decoded();
Ok(Self {
notifications: ListenFilter(params.notifications),
})
}
}
/// The bounded input contract of a `subscriptions/listen` filter.
pub(crate) enum FilterOutcome {
/// The list-change subset this server honours for the stream.
@@ -154,37 +188,18 @@ impl ListenFilter {
/// acknowledgment reports: it is simply not honoured, and the pinned schema forbids the server
/// from sending a type it did not agree to.
pub(crate) fn accepted(&self) -> FilterOutcome {
if self.resource_subscriptions.len() > MAX_FILTER_URIS
|| self
.resource_subscriptions
.iter()
.any(|uri| uri.len() > MAX_FILTER_URI_BYTES)
{
let uris = self.0.resource_subscriptions.as_deref().unwrap_or_default();
if uris.len() > MAX_FILTER_URIS || uris.iter().any(|uri| uri.len() > MAX_FILTER_URI_BYTES) {
return FilterOutcome::Invalid(INVALID_LISTEN_FILTER);
}
FilterOutcome::Accepted(Signals {
resources: self.resources_list_changed,
prompts: self.prompts_list_changed,
tools: self.tools_list_changed,
resources: self.0.resources_list_changed == Some(true),
prompts: self.0.prompts_list_changed == Some(true),
tools: self.0.tools_list_changed == Some(true),
})
}
}
/// The `notifications` object of the acknowledgment: exactly the subset that will be delivered.
fn acknowledged_filter_wire(accepted: Signals) -> Value {
let mut filter = Map::new();
if accepted.prompts {
filter.insert("promptsListChanged".to_owned(), Value::Bool(true));
}
if accepted.resources {
filter.insert("resourcesListChanged".to_owned(), Value::Bool(true));
}
if accepted.tools {
filter.insert("toolsListChanged".to_owned(), Value::Bool(true));
}
Value::Object(filter)
}
/// The exact bound Resource/Prompt/Tool projection of one published Agent catalog.
///
/// The projection is derived from the same committed catalog read that already feeds
@@ -268,15 +283,11 @@ impl Wire {
if !changed {
continue;
}
let frame = match self {
Wire::Legacy => json!({ "jsonrpc": "2.0", "method": method }),
Wire::Modern(subscription_id) => json!({
"jsonrpc": "2.0",
"method": method,
"params": { "_meta": { SUBSCRIPTION_ID_KEY: subscription_id } }
}),
let subscription_id = match self {
Wire::Legacy => None,
Wire::Modern(subscription_id) => Some(subscription_id),
};
frames.push(frame.to_string());
frames.push(sdk::signal_frame(method, subscription_id));
}
frames
}
@@ -284,15 +295,7 @@ impl Wire {
/// The first modern frame: the accepted subset, before any list-change notification of the stream.
pub(crate) fn acknowledged_frame(subscription_id: &Value, accepted: Signals) -> String {
json!({
"jsonrpc": "2.0",
"method": SUBSCRIPTIONS_ACKNOWLEDGED,
"params": {
"_meta": { SUBSCRIPTION_ID_KEY: subscription_id },
"notifications": acknowledged_filter_wire(accepted),
}
})
.to_string()
sdk::acknowledged_frame(subscription_id, accepted)
}
/// The subscription id of a `subscriptions/listen` request, or `None` when its encoding is not a
@@ -387,7 +390,21 @@ pub(crate) fn spawn(state: Arc<AppState>, watch: Watch) -> mpsc::Receiver<String
Box::pin(async move { read(&state, &scope).await })
});
let (sender, receiver) = mpsc::channel(SIGNAL_QUEUE_CAPACITY);
#[cfg(not(test))]
tokio::spawn(run(watch, sender, reader));
#[cfg(test)]
{
let observer = crate::app::dispatch_observer::installed_observer();
tokio::spawn(async move {
match observer {
Some(observer) => {
crate::app::dispatch_observer::observe(observer, run(watch, sender, reader))
.await
}
None => run(watch, sender, reader).await,
}
});
}
receiver
}
@@ -0,0 +1,178 @@
//! SDK serialization for the stream-local list-change notifications.
use rmcp::model::{
JsonRpcNotification, JsonRpcVersion2_0, NotificationMetaObject, PromptListChangedNotification,
ResourceListChangedNotification, SubscriptionFilter, SubscriptionsAcknowledgedNotification,
SubscriptionsAcknowledgedNotificationParams, ToolListChangedNotification,
};
use serde_json::{Map, Value};
use super::{PROMPT_LIST_CHANGED, RESOURCE_LIST_CHANGED, Signals, TOOL_LIST_CHANGED};
fn subscription_meta(subscription_id: &Value) -> NotificationMetaObject {
let mut meta = Map::new();
// Keep the JSON identity: SDK RequestId narrows numbers to i64.
meta.insert(
super::SUBSCRIPTION_ID_KEY.to_owned(),
subscription_id.clone(),
);
NotificationMetaObject::from(meta)
}
pub(super) fn signal_frame(method: &str, subscription_id: Option<&Value>) -> String {
let meta = subscription_id.map(subscription_meta);
let frame = match method {
RESOURCE_LIST_CHANGED => {
let mut notification = ResourceListChangedNotification::default();
if let Some(meta) = meta {
notification.extensions.insert(meta);
}
serde_json::to_string(&JsonRpcNotification {
jsonrpc: JsonRpcVersion2_0,
notification,
})
}
PROMPT_LIST_CHANGED => {
let mut notification = PromptListChangedNotification::default();
if let Some(meta) = meta {
notification.extensions.insert(meta);
}
serde_json::to_string(&JsonRpcNotification {
jsonrpc: JsonRpcVersion2_0,
notification,
})
}
TOOL_LIST_CHANGED => {
let mut notification = ToolListChangedNotification::default();
if let Some(meta) = meta {
notification.extensions.insert(meta);
}
serde_json::to_string(&JsonRpcNotification {
jsonrpc: JsonRpcVersion2_0,
notification,
})
}
_ => unreachable!("list-change methods are a closed set"),
}
.expect("SDK list-change notification with JSON metadata is serializable");
#[cfg(test)]
crate::app::dispatch_observer::sdk_signal_notification_serialized();
frame
}
pub(super) fn acknowledged_frame(subscription_id: &Value, accepted: Signals) -> String {
let mut notifications = SubscriptionFilter::new();
notifications.resources_list_changed = accepted.resources.then_some(true);
notifications.prompts_list_changed = accepted.prompts.then_some(true);
notifications.tools_list_changed = accepted.tools.then_some(true);
let params = SubscriptionsAcknowledgedNotificationParams::new(notifications)
.with_meta(subscription_meta(subscription_id));
let notification = SubscriptionsAcknowledgedNotification::new(params);
let frame = serde_json::to_string(&JsonRpcNotification {
jsonrpc: JsonRpcVersion2_0,
notification,
})
.expect("SDK subscription acknowledgment with JSON metadata is serializable");
#[cfg(test)]
crate::app::dispatch_observer::sdk_subscriptions_acknowledged_serialized();
frame
}
#[cfg(test)]
mod tests {
use serde_json::json;
use super::*;
const METHODS: [&str; 3] = [
RESOURCE_LIST_CHANGED,
PROMPT_LIST_CHANGED,
TOOL_LIST_CHANGED,
];
#[test]
fn legacy_signals_omit_params() {
for method in METHODS {
let frame: Value = serde_json::from_str(&signal_frame(method, None)).unwrap();
assert_eq!(frame, json!({"jsonrpc": "2.0", "method": method}));
}
}
#[test]
fn modern_signals_and_acknowledgments_preserve_json_identity() {
for encoded in [
r#""subscription-\"quoted""#,
"-7",
"18446744073709551615",
"1.0",
"0.12345678901234567890123456789",
"1.234567890123456789e+25",
] {
let id: Value = serde_json::from_str(encoded).unwrap();
let mut frames = METHODS
.map(|method| (signal_frame(method, Some(&id)), method))
.to_vec();
frames.push((
acknowledged_frame(&id, Signals::default()),
super::super::SUBSCRIPTIONS_ACKNOWLEDGED,
));
for (encoded_frame, method) in frames {
let frame: Value = serde_json::from_str(&encoded_frame).unwrap();
assert_eq!(frame["jsonrpc"], "2.0");
assert_eq!(frame["method"], method);
assert_eq!(
frame["params"]["_meta"][super::super::SUBSCRIPTION_ID_KEY],
id
);
assert_eq!(
frame["params"]["_meta"][super::super::SUBSCRIPTION_ID_KEY].to_string(),
id.to_string(),
);
assert_eq!(frame["params"]["_meta"].as_object().unwrap().len(), 1);
assert!(frame.get("id").is_none());
if method != super::super::SUBSCRIPTIONS_ACKNOWLEDGED {
assert_eq!(frame["params"].as_object().unwrap().len(), 1);
}
}
}
}
#[test]
fn acknowledgment_reports_only_accepted_true_flags_and_never_uris() {
for resources in [false, true] {
for prompts in [false, true] {
for tools in [false, true] {
let accepted = Signals {
resources,
prompts,
tools,
};
let frame: Value =
serde_json::from_str(&acknowledged_frame(&json!("listen"), accepted))
.unwrap();
let mut expected = Map::new();
for (enabled, name) in [
(resources, "resourcesListChanged"),
(prompts, "promptsListChanged"),
(tools, "toolsListChanged"),
] {
if enabled {
expected.insert(name.to_owned(), Value::Bool(true));
}
}
assert_eq!(
frame,
json!({
"jsonrpc": "2.0",
"method": super::super::SUBSCRIPTIONS_ACKNOWLEDGED,
"params": {
"_meta": {super::super::SUBSCRIPTION_ID_KEY: "listen"},
"notifications": expected,
},
}),
);
}
}
}
}
}
@@ -0,0 +1,331 @@
//! #107 envelope migration: independent real HTTP wire and SDK participation controls.
use super::{CounterSet, observe, support::*};
use serde_json::{Value, json};
use std::{sync::Arc, time::Duration};
// Reuse the existing real build_app, published catalog, auth and loopback execution fixture.
use super::rmcp_progress_cancel_runtime_tests::fixtures::Endpoint;
fn counts(c: &CounterSet) -> [usize; 2] {
[c.sdk_jsonrpc_response(), c.sdk_jsonrpc_error()]
}
async fn wire(
response: reqwest::Response,
revision: &str,
id: &Value,
sse: bool,
session: Option<&str>,
) -> Value {
assert_eq!(
response.status(),
200,
"envelope id={id}, SSE={sse}, revision={revision}"
);
assert_eq!(response.headers()["MCP-Protocol-Version"], revision);
assert_eq!(
response
.headers()
.get("MCP-Session-Id")
.map(|v| v.to_str().unwrap()),
if sse { session } else { None }
);
let request_id = response.headers()["x-request-id"]
.to_str()
.unwrap()
.to_owned();
let trace_id = response.headers()["x-trace-id"]
.to_str()
.unwrap()
.to_owned();
let content_type = response.headers()["content-type"].to_str().unwrap();
assert!(content_type.starts_with(if sse {
"text/event-stream"
} else {
"application/json"
}));
let raw = tokio::time::timeout(Duration::from_secs(6), response.text())
.await
.unwrap()
.unwrap();
let body: Value = if sse {
let frames: Vec<Value> = raw
.lines()
.filter_map(|line| line.strip_prefix("data:"))
.map(|data| serde_json::from_str(data.trim()).unwrap())
.collect();
let terminals: Vec<_> = frames.iter().filter(|f| f.get("id").is_some()).collect();
assert_eq!(terminals.len(), 1, "one terminal envelope: {raw}");
assert_eq!(frames.last(), Some(terminals[0]), "terminal must be last");
for frame in &frames[..frames.len() - 1] {
assert_eq!(frame["method"], "notifications/progress");
assert_eq!(frame["params"]["progressToken"], "envelope-stream");
}
terminals[0].clone()
} else {
serde_json::from_str(&raw).unwrap()
};
assert_eq!(body["jsonrpc"], "2.0");
assert_eq!(body["id"], *id);
assert_eq!(
body["id"].to_string(),
id.to_string(),
"preserve numeric form"
);
assert_eq!(
body.as_object().unwrap().len(),
3,
"no envelope extensions: {body}"
);
assert!(body.get("method").is_none());
if let Some(error) = body.get("error") {
assert!(
body.get("result").is_none(),
"protocol error, not tool isError"
);
assert_eq!(error["code"], -32602);
if sse {
// Existing stream polling has no request correlation scope; preserve omission.
assert!(
error.get("data").is_none(),
"existing SSE omission: {error}"
);
assert_eq!(error.as_object().unwrap().len(), 2);
} else {
assert_eq!(
error["data"],
json!({"request_id":request_id,"trace_id":trace_id})
);
assert_eq!(error.as_object().unwrap().len(), 3);
}
} else {
assert!(body.get("result").is_some());
}
body
}
async fn control(revision: &str) -> Vec<[usize; 2]> {
// Own the process-wide disposable DB before the reused fixture's older ownership hint.
crank_test_support::postgres_schema_url_for_task("envelopes_owner", "t_b27f5c9d").await;
let h = Endpoint::started().await;
let session = h.session(revision).await;
let mut deltas = vec![];
for id in [
json!("opaque/Ю"),
json!(""),
json!(i64::MIN),
json!(i64::MAX),
json!(9007199254740993_u64),
json!(u64::MAX),
json!(1.5),
json!(1.0),
json!(-0.0),
] {
for invalid in [false, true] {
let mut params = if invalid {
json!({"cursor":"not-a-cursor"})
} else {
json!({"cursor":"1"})
};
if revision == MODERN_REVISION {
params["_meta"] = modern_meta();
}
let before = counts(&h.counters);
let response = h
.request(
revision,
session.as_deref(),
&h.key,
"application/json",
json!({"jsonrpc":"2.0","id":id,"method":"tools/list","params":params}),
)
.send()
.await
.unwrap();
let body = wire(response, revision, &id, false, session.as_deref()).await;
if invalid {
assert_eq!(body["error"]["message"], "invalid tools/list cursor");
} else {
let mut expected = json!({"tools":[]});
if revision == MODERN_REVISION {
expected["resultType"] = json!("complete");
expected["cacheScope"] = json!("private");
expected["ttlMs"] = json!(0);
}
assert_eq!(
body["result"], expected,
"empty result and omission of nextCursor"
);
}
let after = counts(&h.counters);
deltas.push([after[0] - before[0], after[1] - before[1]]);
}
}
// Both revisions support streamed calls with the combined Accept negotiation.
// Missing tool resolves inside the shared Tools command, after the stream opens.
for sse in [false, true] {
for invalid in [false, true] {
let id = if invalid {
json!(u64::MAX)
} else {
json!(-0.0)
};
let mut params =
json!({"name":TOOL_NAME,"arguments":{"email":"envelopes@example.test"}});
if revision == MODERN_REVISION {
params["_meta"] = modern_meta();
}
if invalid {
params["name"] = json!("missing_tool");
} else {
h.gate.add_permits(1);
}
if sse {
params["_meta"]["progressToken"] = json!("envelope-stream");
}
let before = counts(&h.counters);
let mut request = h
.request(
revision,
session.as_deref(),
&h.key,
if sse {
"text/event-stream, application/json"
} else {
"application/json"
},
json!({"jsonrpc":"2.0","id":id,"method":"tools/call","params":params}),
)
.build()
.unwrap();
if revision == MODERN_REVISION {
request.headers_mut().insert(
"Mcp-Name",
if invalid { "missing_tool" } else { TOOL_NAME }
.parse()
.unwrap(),
);
}
let response = reqwest::Client::new().execute(request).await.unwrap();
let body = wire(response, revision, &id, sse, session.as_deref()).await;
if invalid {
assert_eq!(body["error"]["message"], "tool missing_tool was not found");
} else {
assert_eq!(
body["result"].as_object().unwrap().len(),
if revision == MODERN_REVISION { 4 } else { 3 }
);
assert_eq!(body["result"]["isError"], false);
assert_eq!(
body["result"]["structuredContent"],
json!({"id":"lead_progress"})
);
assert_eq!(
body["result"]["content"],
json!([{"type":"text","text":serde_json::to_string_pretty(&json!({"id":"lead_progress"})).unwrap()}])
);
if revision == MODERN_REVISION {
assert_eq!(body["result"]["resultType"], "complete");
} else {
assert!(body["result"].get("resultType").is_none());
}
}
let after = counts(&h.counters);
deltas.push([after[0] - before[0], after[1] - before[1]]);
}
}
eprintln!(
"existing GREEN envelopes wire {revision}: exact id forms, JSON success/protocol error, terminal SSE success/protocol error; SDK deltas={deltas:?}"
);
deltas
}
#[tokio::test]
async fn rmcp_envelopes_wire_legacy() {
control(LEGACY_REVISION).await;
}
#[tokio::test]
async fn rmcp_envelopes_wire_modern() {
control(MODERN_REVISION).await;
}
#[tokio::test]
async fn rmcp_envelopes_sdk_legacy() {
let actual = control(LEGACY_REVISION).await;
let expected: Vec<_> = (0..actual.len())
.map(|i| if i % 2 == 0 { [1, 0] } else { [0, 1] })
.collect();
assert_eq!(
actual, expected,
"real SDK envelope serialization after complete HTTP body"
);
}
#[tokio::test]
async fn rmcp_envelopes_sdk_modern() {
let actual = control(MODERN_REVISION).await;
let expected: Vec<_> = (0..actual.len())
.map(|i| if i % 2 == 0 { [1, 0] } else { [0, 1] })
.collect();
assert_eq!(
actual, expected,
"real SDK envelope serialization after complete HTTP body"
);
}
#[tokio::test]
async fn rmcp_envelopes_observer_positive_control() {
let c = Arc::new(CounterSet::default());
observe(c.clone(), async {
super::sdk_jsonrpc_response_serialized();
super::sdk_jsonrpc_error_serialized();
})
.await;
assert_eq!(counts(&c), [1, 1]);
super::sdk_jsonrpc_response_serialized();
super::sdk_jsonrpc_error_serialized();
assert_eq!(counts(&c), [1, 1], "out-of-scope markers are no-ops");
}
#[test]
fn rmcp_envelopes_helper_lossless_control() {
use crate::jsonrpc::{jsonrpc_error, jsonrpc_result};
let values = [
json!(null),
json!(""),
json!("Ю"),
json!(i64::MIN),
json!(i64::MAX),
json!(9007199254740993_u64),
json!(u64::MAX),
json!(1.5),
json!(1.0),
json!(-0.0),
json!([null, {"nested":u64::MAX}]),
json!({"x":null}),
];
for id in &values {
for result in &values {
let actual = jsonrpc_result(id.clone(), result.clone());
let expected = json!({"jsonrpc":"2.0","id":id,"result":result});
assert_eq!(actual, expected);
assert_eq!(actual.to_string(), expected.to_string());
}
for code in [
i64::MIN,
i32::MIN as i64 - 1,
i32::MIN as i64,
-32602,
i32::MAX as i64,
i32::MAX as i64 + 1,
i64::MAX,
] {
for message in ["", "Ошибка Ю"] {
let actual = jsonrpc_error(id.clone(), code, message);
let expected =
json!({"jsonrpc":"2.0","id":id,"error":{"code":code,"message":message}});
assert_eq!(actual, expected, "data absent outside correlation scope");
assert_eq!(actual.to_string(), expected.to_string());
}
}
}
}
@@ -0,0 +1,416 @@
//! #107 initialize input: existing wire tolerance GREEN, independent SDK-consumption RED.
use super::rmcp_progress_cancel_runtime_tests::fixtures::Endpoint;
use super::{CounterSet, Snapshot, observe, support::*};
use serde_json::{Value, json};
use std::{sync::Arc, time::Duration};
const ACCEPTS: [&str; 2] = ["application/json", "text/event-stream, application/json"];
const TRACE: &str = "11111111111111111111111111111111";
async fn endpoint() -> Endpoint {
crank_test_support::postgres_schema_url_for_task("initialize_input_owner", "t_ffc30fcd").await;
Endpoint::started().await
}
async fn post(h: &Endpoint, params: Option<Value>, accept: &str) -> reqwest::Response {
let mut payload = json!({"jsonrpc":"2.0","id":"initialize/Ю","method":"initialize"});
if let Some(params) = params {
payload["params"] = params;
}
h.request(LEGACY_REVISION, None, &h.key, accept, payload)
.header("x-request-id", "initialize-input")
.header(
"traceparent",
"00-11111111111111111111111111111111-2222222222222222-01",
)
.send()
.await
.unwrap()
}
async fn body(response: reqwest::Response, sse: bool) -> Value {
assert_eq!(response.headers()["x-request-id"], "initialize-input");
assert_eq!(response.headers()["x-trace-id"], TRACE);
assert!(
response.headers()["content-type"]
.to_str()
.unwrap()
.starts_with(if sse {
"text/event-stream"
} else {
"application/json"
})
);
let raw = tokio::time::timeout(Duration::from_secs(6), response.text())
.await
.unwrap()
.unwrap();
if sse {
let frames: Vec<Value> = raw
.lines()
.filter_map(|line| line.strip_prefix("data:"))
.map(|data| serde_json::from_str(data.trim()).unwrap())
.collect();
assert_eq!(frames.len(), 1, "exactly one terminal SSE frame: {raw}");
frames.into_iter().next().unwrap()
} else {
serde_json::from_str(&raw).unwrap()
}
}
fn valid_shapes() -> Vec<(&'static str, Value, bool)> {
let mut cases = vec![(
"capabilities omitted",
json!({"protocolVersion":LEGACY_REVISION}),
false,
)];
for (name, caps, elicitation) in [
("null capabilities", Value::Null, false),
("boolean capabilities", json!(true), false),
("number capabilities", json!(7), false),
("string capabilities", json!("caps"), false),
("array capabilities", json!([{"elicitation":{}}]), false),
("empty capabilities", json!({}), false),
("null elicitation", json!({"elicitation":null}), false),
("boolean elicitation", json!({"elicitation":true}), false),
("number elicitation", json!({"elicitation":1}), false),
("string elicitation", json!({"elicitation":"yes"}), false),
("array elicitation", json!({"elicitation":[]}), false),
("empty elicitation object", json!({"elicitation":{}}), true),
(
"extended elicitation",
json!({"elicitation":{"form":{},"future":42},"future":[1]}),
true,
),
] {
cases.push((
name,
json!({"protocolVersion":LEGACY_REVISION,"capabilities":caps}),
elicitation,
));
}
for info in [
Value::Null,
json!(42),
json!([]),
json!({"name":false,"version":null}),
json!({"name":"client","version":"1","future":true}),
] {
cases.push((
"ignored clientInfo and extensions",
json!({"protocolVersion":LEGACY_REVISION,
"clientInfo":info,"unknown":{"nested":[null,1]},"_meta":{"future":true}}),
false,
));
}
cases
}
async fn valid_control() -> Vec<usize> {
let h = endpoint().await;
let mut deltas = vec![];
for accept in ACCEPTS {
for (name, params, elicitation) in valid_shapes() {
let ops = h.sessions.snapshot();
let admission = h.counters.snapshot();
let sdk = h.counters.sdk_initialize_input();
let response = post(&h, Some(params), accept).await;
assert_eq!(response.status(), 200, "{name}");
assert_eq!(response.headers()["MCP-Protocol-Version"], LEGACY_REVISION);
let id = response.headers()["MCP-Session-Id"]
.to_str()
.unwrap()
.to_owned();
assert!(!id.is_empty());
let wire = body(response, accept.starts_with("text/event-stream")).await;
assert_eq!(wire["jsonrpc"], "2.0");
assert_eq!(wire["id"], "initialize/Ю");
assert_eq!(wire["result"]["protocolVersion"], LEGACY_REVISION);
assert!(wire.get("error").is_none());
assert_deltas(
name,
admission,
h.counters.snapshot(),
Snapshot::new(1, 0, 1, 0),
);
assert_session_ops(
name,
ops,
h.sessions.snapshot(),
SessionOps {
get: 0,
create: 1,
mark_initialized: 0,
},
);
let state = h
.sessions
.retained(&id)
.await
.expect("retained session, not a discarded DTO");
assert_eq!(state.id, id);
assert_eq!(state.protocol_version, LEGACY_REVISION);
assert_eq!(state.workspace_slug, WORKSPACE_SLUG);
assert_eq!(state.agent_slug, AGENT_SLUG);
assert_eq!(state.supports_elicitation, elicitation, "{name}");
assert!(!state.initialized);
assert_eq!(state.updated_at, state.created_at);
assert_eq!(
(state.expires_at.unwrap() - state.created_at).whole_milliseconds(),
86_400_000
);
deltas.push(h.counters.sdk_initialize_input() - sdk);
let response = h
.request(
LEGACY_REVISION,
Some(&id),
&h.key,
"application/json",
initialized_notification(),
)
.send()
.await
.unwrap();
assert_eq!(response.status(), 202);
assert!(response.bytes().await.unwrap().is_empty());
assert!(h.sessions.retained(&id).await.unwrap().initialized);
let response = h
.request(
LEGACY_REVISION,
Some(&id),
&h.key,
"application/json",
json!({"jsonrpc":"2.0","id":2,"method":"tools/list"}),
)
.send()
.await
.unwrap();
assert_eq!(response.status(), 200);
let result = json_body(response).await;
assert!(
result.get("error").is_none(),
"initialized opens a protected request: {result}"
);
assert_eq!(result["result"]["tools"][0]["name"], TOOL_NAME);
eprintln!("existing GREEN {name}; accept={accept}; elicitation={elicitation}");
}
}
eprintln!("SDK input consumption deltas={deltas:?}");
deltas
}
#[tokio::test]
async fn rmcp_initialize_input_wire_tolerance_and_retained_sessions() {
valid_control().await;
}
#[tokio::test]
async fn rmcp_initialize_input_sdk_consumed_by_negotiation() {
let deltas = valid_control().await;
assert!(!deltas.is_empty());
assert_eq!(
deltas,
vec![1; valid_shapes().len() * ACCEPTS.len()],
"real HTTP initialize must consume SDK InitializeRequestParams.protocol_version in negotiation"
);
}
// Current HTTP envelope admission rejects sequence params before serde's derived struct decoder.
// Pin that observed boundary instead of imposing a new object-only check in the SDK decoder.
#[tokio::test]
async fn rmcp_initialize_input_wire_invalid_shapes_and_admission() {
let h = endpoint().await;
for accept in ACCEPTS {
for params in [
None,
Some(json!({})),
Some(json!({"protocolVersion":null})),
Some(json!({"protocolVersion":true})),
Some(json!({"protocolVersion":42})),
Some(json!({"protocolVersion":[]})),
Some(json!({"protocolVersion":{}})),
] {
rejection(
&h,
params,
accept,
200,
-32602,
"invalid initialize parameters",
false,
)
.await;
}
for params in [
json!(null),
json!(true),
json!(42),
json!("bad"),
json!([]),
json!([LEGACY_REVISION]),
json!([LEGACY_REVISION, {}]),
json!([LEGACY_REVISION, {}, {}]),
] {
rejection(
&h,
Some(params),
accept,
400,
-32600,
"invalid JSON-RPC request",
true,
)
.await;
}
for version in ["2025-03-26", "2025-06-18", "2099-01-01", ""] {
rejection(
&h,
Some(json!({"protocolVersion":version})),
accept,
400,
-32602,
&format!("unsupported protocol version {version}"),
false,
)
.await;
}
for meta in [Value::Null, json!(true), json!(42), json!("bad"), json!([])] {
rejection(
&h,
Some(json!({"protocolVersion":LEGACY_REVISION,"_meta":meta})),
accept,
400,
-32020,
"protocol identity mismatch",
true,
)
.await;
}
}
}
#[allow(clippy::too_many_arguments)]
async fn rejection(
h: &Endpoint,
params: Option<Value>,
accept: &str,
status: u16,
code: i64,
message: &str,
admission_only: bool,
) {
let ops = h.sessions.snapshot();
let admission = h.counters.snapshot();
let sdk = h.counters.sdk_initialize_input();
let response = post(h, params.clone(), accept).await;
assert_eq!(response.status().as_u16(), status, "params={params:?}");
assert!(response.headers().get("MCP-Session-Id").is_none());
// Only HTTP 200 dispatch errors use SSE; HTTP 400 stays JSON regardless of Accept.
let sse = status == 200 && !admission_only && accept.starts_with("text/event-stream");
let wire = body(response, sse).await;
assert_eq!(wire["jsonrpc"], "2.0");
assert_eq!(
wire["id"],
if code == -32600 {
Value::Null
} else {
json!("initialize/Ю")
}
);
assert_eq!(wire["error"]["code"], code, "params={params:?}; {wire}");
assert_eq!(wire["error"]["message"], message);
assert!(wire.get("result").is_none());
// Initialize errors are constructed in the request scope, including terminal SSE errors.
assert_eq!(wire["error"]["data"]["request_id"], "initialize-input");
assert_eq!(wire["error"]["data"]["trace_id"], TRACE);
if code == -32020 {
assert_eq!(
wire["error"]["data"]["details"],
"request _meta must be an object"
);
}
assert_deltas(
"reject",
admission,
h.counters.snapshot(),
Snapshot::new(1, 0, usize::from(!admission_only), 0),
);
assert_session_ops(
"reject",
ops,
h.sessions.snapshot(),
SessionOps {
get: 0,
create: 0,
mark_initialized: 0,
},
);
if !message.starts_with("unsupported protocol version") {
assert_eq!(
h.counters.sdk_initialize_input(),
sdk,
"malformed input never reaches SDK consumption"
);
}
eprintln!(
"existing GREEN reject params={params:?}; accept={accept}; status={status}; code={code}"
);
}
#[tokio::test]
async fn rmcp_initialize_input_sdk_unsupported_revision_uses_same_allowlist() {
let h = endpoint().await;
let mut deltas = vec![];
for accept in ACCEPTS {
for version in ["2025-03-26", "2025-06-18", "2099-01-01", ""] {
let sdk = h.counters.sdk_initialize_input();
rejection(
&h,
Some(json!({"protocolVersion":version})),
accept,
400,
-32602,
&format!("unsupported protocol version {version}"),
false,
)
.await;
deltas.push(h.counters.sdk_initialize_input() - sdk);
}
}
assert_eq!(
deltas,
vec![1; 8],
"unsupported strings must reach the same SDK-backed negotiation, without minting sessions"
);
}
#[tokio::test]
async fn rmcp_initialize_input_observer_positive_control() {
let c = Arc::new(CounterSet::default());
let params: rmcp::model::InitializeRequestParams = serde_json::from_value(json!({
"protocolVersion":LEGACY_REVISION,"capabilities":{},"clientInfo":{"name":"control","version":"1"}
})).unwrap();
observe(c.clone(), async {
super::admission_enter();
super::sdk_initialize_input_consumed(&params);
assert_eq!(c.sdk_initialize_input(), 1);
assert_eq!(
c.sdk_initialize_result(),
0,
"input and output are independent"
);
})
.await;
assert_eq!(c.snapshot(), Snapshot::new(1, 0, 0, 0));
super::sdk_initialize_input_consumed(&params);
assert_eq!(c.sdk_initialize_input(), 1, "out-of-scope call is a no-op");
observe(Arc::new(CounterSet::default()), async {
super::sdk_initialize_input_consumed(&params);
})
.await;
assert_eq!(
c.sdk_initialize_input(),
1,
"another request scope is isolated"
);
}
@@ -0,0 +1,270 @@
//! #107 negotiation results: existing HTTP wire GREEN, independent SDK execution oracle RED.
use super::{CounterSet, observe, support::*};
use serde_json::{Value, json};
use std::{sync::Arc, time::Duration};
use super::rmcp_progress_cancel_runtime_tests::fixtures::Endpoint;
fn sdk_counts(c: &CounterSet) -> [usize; 2] {
[c.sdk_initialize_result(), c.sdk_discover_result()]
}
fn capabilities() -> Value {
// Pin the reviewed advertisement, not a call to the builder under test or SDK defaults.
json!({"completions":{},"logging":{},"prompts":{"listChanged":true},
"resources":{"listChanged":true,"subscribe":false},"tools":{"listChanged":true}})
}
fn expected_result(revision: &str) -> Value {
let server = json!({"name":"crank-mcp-server","version":env!("CARGO_PKG_VERSION")});
if revision == LEGACY_REVISION {
json!({"protocolVersion":LEGACY_REVISION,"capabilities":capabilities(),"serverInfo":server})
} else {
json!({"resultType":"complete","supportedVersions":["2026-07-28","2025-11-25"],
"capabilities":capabilities(),"_meta":{"io.modelcontextprotocol/serverInfo":server},
"ttlMs":0,"cacheScope":"private"})
}
}
async fn wire(response: reqwest::Response, revision: &str, id: &Value, sse: bool) -> Value {
assert_eq!(response.status(), 200);
assert_eq!(response.headers()["MCP-Protocol-Version"], revision);
assert_eq!(response.headers()["x-request-id"], "negotiation-request");
assert_eq!(
response.headers()["x-trace-id"],
"11111111111111111111111111111111"
);
let content_type = response.headers()["content-type"].to_str().unwrap();
assert!(content_type.starts_with(if sse {
"text/event-stream"
} else {
"application/json"
}));
let raw = tokio::time::timeout(Duration::from_secs(6), response.text())
.await
.unwrap()
.unwrap();
let body: Value = if sse {
let frames: Vec<Value> = raw
.lines()
.filter_map(|line| line.strip_prefix("data:"))
.map(|data| serde_json::from_str(data.trim()).unwrap())
.collect();
assert_eq!(
frames.len(),
1,
"one terminal, no unsolicited notifications: {raw}"
);
frames.into_iter().next().unwrap()
} else {
serde_json::from_str(&raw).unwrap()
};
assert_eq!(
body,
json!({"jsonrpc":"2.0","id":id,"result":expected_result(revision)}),
"exact result/envelope fields and omissions (including title/icons/instructions/defaults)"
);
body
}
async fn control(revision: &str) -> Vec<[usize; 2]> {
crank_test_support::postgres_schema_url_for_task("negotiation_owner", "t_99aa603c").await;
let h = Endpoint::started().await;
let mut deltas = vec![];
// Accept order selects JSON or a single terminal SSE frame on the real transport.
for accept in ["application/json", "text/event-stream, application/json"] {
let id = json!("negotiation/Ю");
let payload = if revision == LEGACY_REVISION {
let mut initialize = legacy_initialize(1);
initialize["id"] = id.clone();
initialize
} else {
json!({"jsonrpc":"2.0","id":id,"method":"server/discover","params":{"_meta":modern_meta()}})
};
let before = sdk_counts(&h.counters);
let admission_before = h.counters.snapshot();
let response = h
.request(revision, None, &h.key, accept, payload)
.header("x-request-id", "negotiation-request")
.header(
"traceparent",
"00-11111111111111111111111111111111-2222222222222222-01",
)
.send()
.await
.unwrap();
let session = response
.headers()
.get("MCP-Session-Id")
.map(|v| v.to_str().unwrap().to_owned());
if revision == LEGACY_REVISION {
assert!(
!session
.as_deref()
.expect("initialize creates a session")
.is_empty()
);
} else {
assert_eq!(
session, None,
"stateless discovery never creates a session carrier"
);
}
wire(
response,
revision,
&id,
accept.starts_with("text/event-stream"),
)
.await;
assert_deltas(
"negotiation admission positive control",
admission_before,
h.counters.snapshot(),
if revision == LEGACY_REVISION {
super::Snapshot::new(1, 0, 1, 0)
} else {
super::Snapshot::new(1, 1, 0, 0)
},
);
let after = sdk_counts(&h.counters);
deltas.push([after[0] - before[0], after[1] - before[1]]);
if let Some(session) = session {
let response = h
.request(
revision,
Some(&session),
&h.key,
accept,
initialized_notification(),
)
.send()
.await
.unwrap();
assert_eq!(response.status(), 202);
assert!(response.bytes().await.unwrap().is_empty());
// Prove the minted session can authorize the next protected request.
let response = h
.request(
revision,
Some(&session),
&h.key,
"application/json",
json!({"jsonrpc":"2.0","id":2,"method":"ping"}),
)
.send()
.await
.unwrap();
assert_eq!(response.status(), 200);
assert_eq!(
json_body(response).await,
json!({"jsonrpc":"2.0","id":2,"result":{"protocolVersion":LEGACY_REVISION}})
);
}
}
eprintln!("existing GREEN lifecycle negotiation wire {revision}; SDK deltas={deltas:?}");
deltas
}
#[tokio::test]
async fn rmcp_lifecycle_negotiation_wire_legacy() {
control(LEGACY_REVISION).await;
}
#[tokio::test]
async fn rmcp_lifecycle_negotiation_wire_modern() {
control(MODERN_REVISION).await;
}
#[tokio::test]
async fn rmcp_lifecycle_negotiation_sdk_legacy() {
assert_eq!(
control(LEGACY_REVISION).await,
vec![[1, 0]; 2],
"real HTTP initialize must serialize SDK InitializeResult (not admission/envelope only)"
);
}
#[tokio::test]
async fn rmcp_lifecycle_negotiation_sdk_modern() {
assert_eq!(
control(MODERN_REVISION).await,
vec![[0, 1]; 2],
"real HTTP discovery must serialize SDK DiscoverResult (not admission/envelope only)"
);
}
#[tokio::test]
async fn rmcp_lifecycle_negotiation_observer_positive_control() {
let c = Arc::new(CounterSet::default());
observe(c.clone(), async {
super::admission_enter();
super::sdk_initialize_result_serialized();
assert_eq!(
sdk_counts(&c),
[1, 0],
"initialize and discovery are separate markers"
);
super::sdk_discover_result_serialized();
})
.await;
assert_eq!(sdk_counts(&c), [1, 1]);
assert_eq!(c.snapshot(), super::Snapshot::new(1, 0, 0, 0));
super::sdk_initialize_result_serialized();
super::sdk_discover_result_serialized();
assert_eq!(sdk_counts(&c), [1, 1], "out-of-scope markers are no-ops");
}
#[tokio::test]
async fn rmcp_lifecycle_negotiation_wire_session_operations() {
crank_test_support::postgres_schema_url_for_task("negotiation_sessions_owner", "t_99aa603c")
.await;
let h = Harness::started().await;
// Existing counted-session fixture supplies independent get/create/initialized oracles.
run_valid_legacy_initialize(&h, 10, "legacy create exactly once").await;
let session = h.initialize_legacy_session().await;
run_valid_legacy_call(
&h,
&session,
11,
"negotiation@example.test",
"initialized session works",
)
.await;
for accept in ["application/json", "text/event-stream, application/json"] {
let before = h.session_ops();
let admission_before = h.snapshot();
let response = h
.post(
&[
("MCP-Protocol-Version", MODERN_REVISION),
("Mcp-Method", "server/discover"),
("Accept", accept),
("x-request-id", "negotiation-request"),
(
"traceparent",
"00-11111111111111111111111111111111-2222222222222222-01",
),
],
&json!({"jsonrpc":"2.0","id":"discovery","method":"server/discover",
"params":{"_meta":modern_meta()}}),
)
.await;
assert!(response.headers().get("MCP-Session-Id").is_none());
wire(response, MODERN_REVISION, &json!("discovery"), false).await;
assert_deltas(
"modern discovery",
admission_before,
h.snapshot(),
super::Snapshot::new(1, 1, 0, 0),
);
assert_session_ops(
"stateless discovery",
before,
h.session_ops(),
SessionOps {
get: 0,
create: 0,
mark_initialized: 0,
},
);
}
}
@@ -0,0 +1,293 @@
//! Narrow #107 HTTP fixture; registry/catalog/auth data reuse the dispatch observer support.
use super::*;
use crank_runtime::{
InMemoryCoordinationStateStore, RequestRateLimitConfig, RequestRateLimiter, SecretCrypto,
};
use std::sync::atomic::{AtomicUsize, Ordering};
use tokio::sync::Semaphore;
pub(in crate::app::dispatch_observer) struct Endpoint {
pub registry: crank_registry::PostgresRegistry,
pub counters: Arc<CounterSet>,
pub sessions: Arc<CountedSessionStore>,
pub key: String,
pub other_key: String,
pub gate: Arc<Semaphore>,
pub started: Arc<AtomicUsize>,
url: String,
servers: Vec<tokio::task::JoinHandle<()>>,
}
impl Drop for Endpoint {
fn drop(&mut self) {
for server in &self.servers {
server.abort();
}
}
}
impl Endpoint {
pub async fn started() -> Self {
crank_test_support::postgres_schema_url_for_task("progress_owner", "t_d65dd129").await;
let registry = test_registry().await;
let gate = Arc::new(Semaphore::new(0));
let started = Arc::new(AtomicUsize::new(0));
let (g, s) = (gate.clone(), started.clone());
let upstream = axum::Router::new().route(
"/crm/leads",
axum::routing::post(move || {
let (g, s) = (g.clone(), s.clone());
async move {
s.fetch_add(1, Ordering::SeqCst);
g.acquire().await.unwrap().forget();
axum::Json(json!({"id":"lead_progress"}))
}
}),
);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let base = format!("http://{}", listener.local_addr().unwrap());
let upstream_server = tokio::spawn(async move {
axum::serve(listener, upstream).await.unwrap();
});
let mut operation = test_operation(&base);
operation.execution_config.timeout_ms = 30_000;
registry
.create_operation(&workspace_id(), &operation, Some("alice"))
.await
.unwrap();
registry
.publish_operation(crank_registry::PublishRequest {
workspace_id: &workspace_id(),
operation_id: &operation.id,
version: 1,
published_at: &test_time(),
published_by: Some("alice"),
})
.await
.unwrap();
publish_agent(&registry, &operation).await;
let key = create_api_key(&registry).await;
let other_key = format!("crk_test_{}", uuid::Uuid::now_v7().simple());
let other = crank_core::PlatformApiKey {
id: crank_core::PlatformApiKeyId::new("pk_progress_other"),
workspace_id: workspace_id(),
agent_id: Some(agent_id()),
key_kind: crank_core::PlatformApiKeyKind::McpClient,
name: "progress-other".into(),
prefix: other_key.chars().take(16).collect(),
scopes: vec![
crank_core::PlatformApiKeyScope::Read,
crank_core::PlatformApiKeyScope::Write,
],
status: crank_core::PlatformApiKeyStatus::Active,
created_at: test_time(),
last_used_at: None,
expires_at: None,
allowed_origins: vec![],
};
registry
.create_platform_api_key(crank_registry::CreatePlatformApiKeyRequest {
api_key: &other,
secret_hash: &hash_access_secret(&other_key),
})
.await
.unwrap();
let counters = Arc::new(CounterSet::default());
let sessions = Arc::new(CountedSessionStore::default());
let app = crate::build_app(
registry.clone(),
Duration::ZERO,
Some("https://crank.example.com".into()),
SecretCrypto::new("test-master-key-00000000000000000000000000000000").unwrap(),
crank_runtime::community_with_outbound_policy(
crank_runtime::OutboundHttpPolicy::allowing_hosts(["127.0.0.1"]),
)
.build(),
RequestRateLimiter::new(RequestRateLimitConfig::new(10_000, 10_000).unwrap()),
Arc::new(InMemoryCoordinationStateStore::default()),
sessions.clone(),
Arc::new(crate::auth::CommunityMachineCredentialVerifier),
);
let scope = counters.clone();
let app = app.layer(axum::middleware::from_fn(
move |request: axum::extract::Request, next: axum::middleware::Next| {
let c = scope.clone();
async move {
let response = observe(c.clone(), next.run(request)).await;
observe_body(response, c)
}
},
));
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let url = format!(
"http://{}/v1/{WORKSPACE_SLUG}/{AGENT_SLUG}",
listener.local_addr().unwrap()
);
let server = tokio::spawn(async move {
axum::serve(listener, app).await.unwrap();
});
Self {
registry,
counters,
sessions,
key,
other_key,
gate,
started,
url,
servers: vec![server, upstream_server],
}
}
pub fn request(
&self,
revision: &str,
session: Option<&str>,
key: &str,
accept: &str,
payload: Value,
) -> reqwest::RequestBuilder {
let mut request = reqwest::Client::new()
.post(&self.url)
.bearer_auth(key)
.header("Accept", accept)
.header("MCP-Protocol-Version", revision);
if let Some(session) = session {
request = request.header("MCP-Session-Id", session);
}
if revision == MODERN_REVISION {
request = request
.header("Mcp-Method", payload["method"].as_str().unwrap())
.header("Mcp-Name", TOOL_NAME);
}
request.json(&payload)
}
pub fn call(
&self,
revision: &str,
session: Option<&str>,
id: Value,
token: Option<Value>,
accept: &str,
) -> reqwest::RequestBuilder {
let mut meta = if revision == MODERN_REVISION {
modern_meta()
} else {
json!({})
};
if let Some(token) = token {
meta["progressToken"] = token;
}
self.request(
revision,
session,
&self.key,
accept,
json!({"jsonrpc":"2.0","id":id,"method":"tools/call",
"params":{"name":TOOL_NAME,"arguments":{"email":"progress@example.com"},"_meta":meta}}),
)
}
pub async fn session(&self, revision: &str) -> Option<String> {
if revision == MODERN_REVISION {
return None;
}
let response = self
.request(
revision,
None,
&self.key,
"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();
assert_eq!(
json_body(response).await["result"]["protocolVersion"],
revision
);
let response = self
.request(
revision,
Some(&session),
&self.key,
"application/json",
initialized_notification(),
)
.send()
.await
.unwrap();
assert_eq!(response.status(), 202);
assert!(response.bytes().await.unwrap().is_empty());
Some(session)
}
pub async fn cancel(&self, key: &str, session: &str, params: Value) {
let shape = match params.get("requestId") {
None => "missing",
Some(Value::Null) => "null",
Some(Value::Bool(_)) => "bool",
Some(Value::Array(_)) => "array",
Some(Value::Object(_)) => "object",
Some(Value::Number(_)) => "number",
Some(Value::String(_)) => "string",
};
let response = self
.request(
LEGACY_REVISION,
Some(session),
key,
"application/json",
json!({"jsonrpc":"2.0","method":"notifications/cancelled","params":params}),
)
.send()
.await
.unwrap();
let status = response.status();
let body = response.bytes().await.unwrap();
if status != 202 {
let error: Value = serde_json::from_slice(&body).unwrap_or(Value::Null);
panic!(
"cancel target shape={shape}, HTTP {status}, code={}, message={}, details={}",
error["error"]["code"],
error["error"]["message"],
error["error"]["data"]["details"]
);
}
assert!(body.is_empty(), "ack must disclose nothing");
}
pub async fn wait_started(&self, count: usize) {
tokio::time::timeout(Duration::from_secs(5), async {
while self.started.load(Ordering::SeqCst) < count {
tokio::time::sleep(Duration::from_millis(5)).await;
}
})
.await
.expect("actual outbound dispatch before cancellation");
}
pub async fn history(&self, request: &str) -> Vec<crank_core::InvocationLog> {
self.registry
.list_invocation_logs(crank_registry::ListInvocationLogsQuery {
workspace_id: &workspace_id(),
level: None,
status: None,
outcome_group: None,
search_text: None,
source: Some(crank_core::InvocationSource::AgentToolCall),
operation_id: Some(&crank_core::OperationId::new(format!("op_{TOOL_NAME}"))),
agent_id: None,
created_after: None,
created_before: None,
cursor_created_at: None,
cursor_id: None,
limit: 50,
})
.await
.unwrap()
.into_iter()
.map(|row| row.log)
.filter(|log| log.request_id.as_deref() == Some(request))
.collect()
}
}
@@ -0,0 +1,457 @@
//! #107: real HTTP wire controls first; SDK participation is an independent migration oracle.
use super::{CounterSet, observe, support::*};
use axum::{body::Body, response::Response};
use futures_util::{StreamExt, stream};
use serde_json::{Value, json};
use std::{sync::Arc, time::Duration};
#[path = "rmcp_progress_cancel_http_support.rs"]
pub(super) mod fixtures;
use fixtures::Endpoint;
fn observe_body(response: Response, counters: Arc<CounterSet>) -> Response {
let (parts, body) = response.into_parts();
let body = stream::unfold(
(body.into_data_stream(), counters),
|(mut body, c)| async move {
observe(c.clone(), body.next())
.await
.map(|chunk| (chunk, (body, c)))
},
);
Response::from_parts(parts, Body::from_stream(body))
}
async fn frames(response: reqwest::Response) -> Vec<Value> {
assert_eq!(response.status(), 200);
let sse = response.headers()["content-type"]
.to_str()
.unwrap()
.starts_with("text/event-stream");
let raw = tokio::time::timeout(Duration::from_secs(5), response.text())
.await
.unwrap()
.unwrap();
if sse {
raw.lines()
.filter_map(|line| {
line.strip_prefix("data:")
.map(|data| serde_json::from_str(data.trim()).unwrap())
})
.collect()
} else if raw.is_empty() {
vec![]
} else {
vec![serde_json::from_str(&raw).unwrap()]
}
}
fn terminal(frames: &[Value], revision: &str, id: Value) -> Value {
let last = frames.last().expect("terminal result");
assert_eq!(last["jsonrpc"], "2.0");
assert_eq!(last["id"], id);
assert!(last.get("method").is_none());
assert!(last.get("error").is_none());
assert_eq!(last["result"]["isError"], false);
assert_eq!(
last["result"]["structuredContent"],
json!({"id":"lead_progress"})
);
if revision == MODERN_REVISION {
assert_eq!(last["result"]["resultType"], "complete");
}
last["result"].clone()
}
async fn progress_control(revision: &str) -> usize {
let h = Endpoint::started().await;
let session = h.session(revision).await;
// Establish the unchanged successful execution independently of any notification/marker.
h.gate.add_permits(1);
let plain = frames(
h.call(
revision,
session.as_deref(),
json!(51),
None,
"application/json",
)
.send()
.await
.unwrap(),
)
.await;
assert_eq!(plain.len(), 1);
let expected = terminal(&plain, revision, json!(51));
assert_eq!(h.counters.sdk_progress_notification(), 0);
let mut sdk_positive = usize::MAX;
for token in [
json!("opaque-token"),
json!(-7),
json!(1.5),
json!(1.0),
json!(-0.0),
json!(u64::MAX),
] {
let before = h.counters.sdk_progress_notification();
h.gate.add_permits(1);
let reply = h
.call(
revision,
session.as_deref(),
json!(51),
Some(token.clone()),
"application/json, text/event-stream",
)
.send()
.await
.unwrap();
assert!(
reply.headers()["content-type"]
.to_str()
.unwrap()
.starts_with("text/event-stream")
);
let reply = frames(reply).await;
assert_eq!(reply.len(), 4, "three bounded real steps and one terminal");
for (index, message) in [
"tool_resolved",
"authorization_resolved",
"execution_dispatched",
]
.iter()
.enumerate()
{
let expected_frame = json!({"jsonrpc":"2.0","method":"notifications/progress","params":{
"progressToken":token,"progress":index+1,"message":message}});
// Stringify too: float-form tokens must not silently become integers/strings.
assert_eq!(reply[index].to_string(), expected_frame.to_string());
assert!(reply[index]["params"]["progress"].as_u64().is_some());
}
assert_eq!(terminal(&reply, revision, json!(51)), expected);
sdk_positive = sdk_positive.min(h.counters.sdk_progress_notification() - before);
}
for token in [
None,
Some(json!(null)),
Some(json!(true)),
Some(json!({})),
Some(json!([])),
Some(json!("")),
Some(json!("bad\ntoken")),
Some(json!("x".repeat(129))),
] {
h.gate.add_permits(1);
let before = h.counters.sdk_progress_notification();
let reply = frames(
h.call(
revision,
session.as_deref(),
json!(51),
token,
"text/event-stream",
)
.send()
.await
.unwrap(),
)
.await;
assert_eq!(reply.len(), 1, "invalid/absent token is silent");
assert_eq!(terminal(&reply, revision, json!(51)), expected);
assert_eq!(h.counters.sdk_progress_notification(), before);
}
h.gate.add_permits(1);
let before = h.counters.sdk_progress_notification();
let reply = frames(
h.call(
revision,
session.as_deref(),
json!(51),
Some(json!(u64::MAX)),
"application/json",
)
.send()
.await
.unwrap(),
)
.await;
assert_eq!(reply.len(), 1, "no SSE means no progress");
assert_eq!(terminal(&reply, revision, json!(51)), expected);
assert_eq!(h.counters.sdk_progress_notification(), before);
eprintln!(
"existing GREEN progress HTTP {revision}: exact token forms, bounded integer steps, unchanged result and silent negatives; minimum per-token SDK delta={sdk_positive}"
);
sdk_positive
}
async fn cancel_control(with_meta: bool) -> usize {
let h = Endpoint::started().await;
let session = h.session(LEGACY_REVISION).await.unwrap();
let foreign = h.session(LEGACY_REVISION).await.unwrap();
let request = h
.call(
LEGACY_REVISION,
Some(&session),
json!(u64::MAX),
Some(json!("cancel-token")),
"text/event-stream",
)
.header("x-request-id", "progress-cancel-owner");
let mut call = tokio::spawn(async move { frames(request.send().await.unwrap()).await });
h.wait_started(1).await;
// All no-ops target this active call while its upstream response is held, not a completed call.
for params in [
json!({"requestId":u64::MAX.to_string()}),
json!({"requestId":999}),
json!({}),
json!({"requestId":null}),
json!({"requestId":true}),
json!({"requestId":[]}),
json!({"requestId":{}}),
] {
h.cancel(&h.key, &session, params).await;
}
eprintln!("cancel diagnostic: malformed/unknown/lookalike controls passed");
h.cancel(&h.other_key, &session, json!({"requestId":u64::MAX}))
.await;
h.cancel(&h.key, &foreign, json!({"requestId":u64::MAX}))
.await;
eprintln!("cancel diagnostic: foreign ownership controls passed");
assert!(
tokio::time::timeout(Duration::from_millis(100), &mut call)
.await
.is_err(),
"no-op targets must leave the owned call running"
);
// Now let exactly that call finish: this proves no-op, rather than just delayed cancellation.
h.gate.add_permits(1);
let reply = call.await.unwrap();
terminal(&reply, LEGACY_REVISION, json!(u64::MAX));
let history = h.history("progress-cancel-owner").await;
assert_eq!(history.len(), 1);
assert_eq!(history[0].status, crank_core::InvocationStatus::Ok);
h.cancel(&h.key, &session, json!({"requestId":u64::MAX}))
.await;
assert_eq!(
h.history("progress-cancel-owner").await.len(),
1,
"late cancel adds no outcome"
);
let request = h
.call(
LEGACY_REVISION,
Some(&session),
json!(u64::MAX),
Some(json!("cancel-token")),
"text/event-stream",
)
.header("x-request-id", "progress-cancel-stop");
let call = tokio::spawn(async move { frames(request.send().await.unwrap()).await });
h.wait_started(2).await;
let before = h.counters.sdk_cancelled_params();
let mut params = json!({"requestId":u64::MAX,"reason":42,"unknown":{"nested":true}});
if with_meta {
params["_meta"] = json!({});
}
h.cancel(&h.key, &session, params).await;
let delta = h.counters.sdk_cancelled_params() - before;
let reply = tokio::time::timeout(Duration::from_secs(1), call)
.await
.expect("cancel releases call while upstream is still held")
.unwrap();
assert_eq!(reply.len(), 3);
assert!(
reply
.iter()
.all(|f| f["method"] == "notifications/progress"),
"no false terminal result"
);
assert!(h.history("progress-cancel-stop").await.is_empty());
// Releasing an abandoned upstream cannot turn the cancelled execution into completed history.
h.gate.add_permits(2);
let reply = frames(
h.call(
LEGACY_REVISION,
Some(&session),
json!(u64::MAX),
None,
"application/json",
)
.send()
.await
.unwrap(),
)
.await;
terminal(&reply, LEGACY_REVISION, json!(u64::MAX));
assert!(h.history("progress-cancel-stop").await.is_empty());
assert_eq!(
h.started.load(std::sync::atomic::Ordering::SeqCst),
3,
"no automatic write retry"
);
eprintln!(
"existing GREEN cancel HTTP legacy: active no-ops, numeric owner stop with ignored fields, released/reused id and no false history; SDK delta={delta}"
);
delta
}
#[tokio::test]
async fn rmcp_progress_cancel_wire_legacy() {
progress_control(LEGACY_REVISION).await;
}
#[tokio::test]
async fn rmcp_progress_cancel_wire_modern() {
progress_control(MODERN_REVISION).await;
}
#[tokio::test]
async fn rmcp_progress_cancel_wire_cancellation() {
cancel_control(false).await;
}
#[tokio::test]
async fn rmcp_progress_cancel_sdk_legacy() {
assert!(
progress_control(LEGACY_REVISION).await > 0,
"missing SDK progress serialization after successful HTTP controls"
);
}
#[tokio::test]
async fn rmcp_progress_cancel_sdk_modern() {
assert!(
progress_control(MODERN_REVISION).await > 0,
"missing SDK progress serialization after successful HTTP controls"
);
}
#[tokio::test]
async fn rmcp_progress_cancel_sdk_cancellation() {
assert!(
cancel_control(false).await > 0,
"missing SDK cancelled params decode after successful HTTP stop controls"
);
}
#[tokio::test]
async fn rmcp_progress_cancel_wire_modern_stream_close() {
let h = Endpoint::started().await;
let response = h
.call(
MODERN_REVISION,
None,
json!(52),
Some(json!("disconnect")),
"text/event-stream",
)
.header("x-request-id", "progress-modern-stop")
.send()
.await
.unwrap();
assert_eq!(response.status(), 200);
h.wait_started(1).await;
drop(response);
tokio::time::sleep(Duration::from_millis(250)).await;
// Match the existing lifecycle grace; an un-stopped future would complete after gate release.
h.gate.add_permits(2);
tokio::time::sleep(Duration::from_millis(2500)).await;
assert!(
h.history("progress-modern-stop").await.is_empty(),
"closed stream must not reach completed history"
);
let reply = frames(
h.call(MODERN_REVISION, None, json!(52), None, "application/json")
.send()
.await
.unwrap(),
)
.await;
terminal(&reply, MODERN_REVISION, json!(52));
assert_eq!(
h.started.load(std::sync::atomic::Ordering::SeqCst),
2,
"no retry after disconnect"
);
assert!(h.history("progress-modern-stop").await.is_empty());
}
#[tokio::test]
async fn rmcp_progress_cancel_admitted_meta_cancellation() {
assert!(cancel_control(true).await > 0);
}
#[tokio::test]
async fn rmcp_progress_cancel_malformed_meta_rejected_before_decode() {
let h = Endpoint::started().await;
let session = h.session(LEGACY_REVISION).await.unwrap();
let request = h
.call(
LEGACY_REVISION,
Some(&session),
json!(u64::MAX),
Some(json!("meta-boundary")),
"text/event-stream",
)
.header("x-request-id", "progress-meta-rejected");
let mut call = tokio::spawn(async move { frames(request.send().await.unwrap()).await });
h.wait_started(1).await;
let before = h.counters.sdk_cancelled_params();
let response = h
.request(
LEGACY_REVISION,
Some(&session),
&h.key,
"application/json",
json!({"jsonrpc":"2.0","method":"notifications/cancelled","params":{
"requestId":u64::MAX,"reason":42,"_meta":[],"unknown":{"nested":true}}}),
)
.send()
.await
.unwrap();
assert_eq!(response.status(), 400);
let error = json_body(response).await;
assert_eq!(error["error"]["code"], -32020);
assert_eq!(error["error"]["message"], "protocol identity mismatch");
assert_eq!(
error["error"]["data"]["details"],
"request _meta must be an object"
);
assert_eq!(h.counters.sdk_cancelled_params(), before);
assert!(
tokio::time::timeout(Duration::from_millis(100), &mut call)
.await
.is_err()
);
h.gate.add_permits(1);
let reply = call.await.unwrap();
terminal(&reply, LEGACY_REVISION, json!(u64::MAX));
let history = h.history("progress-meta-rejected").await;
assert_eq!(history.len(), 1);
assert_eq!(history[0].status, crank_core::InvocationStatus::Ok);
assert_eq!(h.started.load(std::sync::atomic::Ordering::SeqCst), 1);
assert_eq!(h.counters.sdk_cancelled_params(), before);
}
#[tokio::test]
async fn rmcp_progress_cancel_observer_scope_control() {
use super::{sdk_cancelled_params_decoded, sdk_progress_notification_serialized};
let a = Arc::new(CounterSet::default());
let b = Arc::new(CounterSet::default());
sdk_cancelled_params_decoded();
sdk_progress_notification_serialized();
assert_eq!(a.sdk_cancelled_params(), 0);
tokio::join!(
observe(a.clone(), async {
sdk_cancelled_params_decoded();
}),
observe(b.clone(), async {
sdk_progress_notification_serialized();
})
);
assert_eq!(
[a.sdk_cancelled_params(), a.sdk_progress_notification()],
[1, 0]
);
assert_eq!(
[b.sdk_cancelled_params(), b.sdk_progress_notification()],
[0, 1]
);
let body = Body::from_stream(stream::once(async {
sdk_progress_notification_serialized();
Ok::<_, std::convert::Infallible>("data: terminal\n\n")
}));
let response = observe_body(Response::new(body), a.clone());
assert_eq!(a.sdk_progress_notification(), 0);
axum::body::to_bytes(response.into_body(), 100)
.await
.unwrap();
assert_eq!(a.sdk_progress_notification(), 1);
assert_eq!(b.sdk_progress_notification(), 1);
}
@@ -0,0 +1,312 @@
//! #107: HTTP wire controls are independent of the SDK execution oracle.
//! A real committed Tool removal exercises the watcher; existing mcp_signals::scenarios covers
//! Resource/Prompt publications, isolation, coalescing, reconnect and authoritative recovery.
use super::{CounterSet, support::*};
use serde_json::{Value, json};
use std::{sync::Arc, time::Duration};
#[path = "rmcp_signals_test_support.rs"]
mod fixtures;
use fixtures::{Endpoint, terminal};
const SUB_ID: &str = "io.modelcontextprotocol/subscriptionId";
const ACK: &str = "notifications/subscriptions/acknowledged";
const TOOLS: &str = "notifications/tools/list_changed";
const INVALID_FILTER: &str = "invalid subscriptions/listen notification filter";
fn counts(c: &CounterSet) -> [usize; 3] {
[
c.sdk_subscriptions_listen(),
c.sdk_subscriptions_acknowledged(),
c.sdk_signal_notification(),
]
}
fn ack(id: &Value, notifications: Value) -> Value {
json!({"jsonrpc":"2.0", "method":ACK,
"params":{"_meta":{SUB_ID:id},"notifications":notifications}})
}
fn listen_body(id: Value, params: Value) -> Value {
json!({"jsonrpc":"2.0","id":id,"method":"subscriptions/listen","params":params})
}
async fn catalog_control(revision: &str) -> [usize; 3] {
let h = Endpoint::started().await;
let session = if revision == LEGACY_REVISION {
Some(h.session().await)
} else {
None
};
let admission_before = h.counters.snapshot().admission;
let before_list = h.tools(revision, session.as_deref()).await;
assert_eq!(
h.counters.snapshot().admission - admission_before,
1,
"positive control: the HTTP request must carry this observer"
);
assert_eq!(before_list["result"]["tools"].as_array().unwrap().len(), 1);
assert_eq!(before_list["result"]["tools"][0]["name"], TOOL_NAME);
let id = json!(u64::MAX);
let before = counts(&h.counters);
let mut stream = if revision == MODERN_REVISION {
let mut stream = h
.listen(
id.clone(),
json!({
"toolsListChanged":true,"resourcesListChanged":true,"promptsListChanged":true,
"resourceSubscriptions":["crank://CANARY-URI"], "unknown":null
}),
)
.await;
// Whole-frame equality proves ack first, exact id, no result/id/URI/payload leakage.
assert_eq!(
stream.frame().await,
ack(
&id,
json!({
"toolsListChanged":true,"resourcesListChanged":true,"promptsListChanged":true
})
)
);
stream
} else {
h.legacy_stream(session.as_deref().unwrap()).await
};
// Enough for the existing one-second watcher to establish its initial committed fingerprint.
stream.silent().await;
h.draft_without_tools().await;
stream.silent().await;
assert_eq!(
h.tools(revision, session.as_deref()).await["result"]["tools"]
.as_array()
.unwrap()
.len(),
1
);
h.publish_without_tools().await;
let expected = if revision == MODERN_REVISION {
json!({"jsonrpc":"2.0","method":TOOLS,"params":{"_meta":{SUB_ID:id}}})
} else {
json!({"jsonrpc":"2.0","method":TOOLS})
};
assert_eq!(
stream.frame().await,
expected,
"exact committed signal, no catalog payload"
);
stream.silent().await;
assert_eq!(
h.tools(revision, session.as_deref()).await["result"]["tools"],
json!([])
);
let after = counts(&h.counters);
std::array::from_fn(|i| after[i] - before[i])
}
#[tokio::test]
async fn modern_wire_control() {
catalog_control(MODERN_REVISION).await;
}
#[tokio::test]
async fn legacy_wire_control() {
catalog_control(LEGACY_REVISION).await;
}
#[tokio::test]
async fn modern_sdk_runtime_oracle() {
// All real HTTP/commit assertions above must pass before missing SDK behavior can be RED.
assert_eq!(
catalog_control(MODERN_REVISION).await,
[1, 1, 1],
"real HTTP listen decode / ack serialization / watcher signal serialization SDK entries"
);
}
#[tokio::test]
async fn legacy_sdk_runtime_oracle() {
assert_eq!(
catalog_control(LEGACY_REVISION).await,
[0, 0, 1],
"legacy GET must use SDK signal serialization but not modern listen/ack"
);
}
#[tokio::test]
async fn modern_false_absent_and_uri_only_do_not_opt_in() {
let h = Endpoint::started().await;
let mut absent = h.listen(json!("absent"), json!({})).await;
assert_eq!(absent.frame().await, ack(&json!("absent"), json!({})));
let mut disabled = h
.listen(
json!("disabled"),
json!({
"toolsListChanged":false,"resourcesListChanged":false,"promptsListChanged":false,
"resourceSubscriptions":["crank://CANARY-URI"]
}),
)
.await;
assert_eq!(disabled.frame().await, ack(&json!("disabled"), json!({})));
// A simultaneous positive stream proves the publication was visible to the running watchers.
let mut enabled = h
.listen(json!("enabled"), json!({"toolsListChanged":true}))
.await;
assert_eq!(
enabled.frame().await,
ack(&json!("enabled"), json!({"toolsListChanged":true}))
);
enabled.silent().await;
h.draft_without_tools().await;
h.publish_without_tools().await;
assert_eq!(
enabled.frame().await,
json!({"jsonrpc":"2.0","method":TOOLS,"params":{"_meta":{SUB_ID:"enabled"}}})
);
absent.silent().await;
disabled.silent().await;
let body = terminal(
h.post(
MODERN_REVISION,
None,
json!({
"jsonrpc":"2.0","id":4,"method":"resources/subscribe",
"params":{"_meta":modern_meta(),"uri":"crank://CANARY-URI"}
}),
)
.await,
)
.await;
assert_eq!(body["error"]["code"], -32601);
assert!(body.get("result").is_none());
assert!(!body.to_string().contains("CANARY"));
}
#[tokio::test]
async fn modern_http_filter_shape_and_bounds_stay_compatible() {
let h = Endpoint::started().await;
let mut invalid = vec![
json!({}),
json!({"notifications":null}),
json!({"notifications":[]}),
json!({"notifications":{"toolsListChanged":"CANARY"}}),
json!({"notifications":{"resourceSubscriptions":[null]}}),
json!({"notifications":{"resourceSubscriptions":vec!["CANARY";33]}}),
json!({"notifications":{"resourceSubscriptions":["X".repeat(2049)]}}),
];
for key in [
"toolsListChanged",
"resourcesListChanged",
"promptsListChanged",
"resourceSubscriptions",
] {
let mut filter = json!({});
filter[key] = Value::Null;
invalid.push(json!({"notifications":filter}));
}
for mut params in invalid {
params["_meta"] = modern_meta();
let body = terminal(
h.post(MODERN_REVISION, None, listen_body(json!(7), params))
.await,
)
.await;
assert_eq!(body["id"], 7);
assert_eq!(body["error"]["code"], -32602);
assert_eq!(body["error"]["message"], INVALID_FILTER);
assert!(body.get("result").is_none());
assert!(!body.to_string().contains("CANARY"));
assert!(body.to_string().len() < 4096);
}
// Inclusive bounds, unknown null extension and explicit false are accepted, never acknowledged
// as a URI-content subscription or an extra list-change type.
let mut stream = h
.listen(
json!(8),
json!({
"resourceSubscriptions":vec!["é".repeat(1024);32], "toolsListChanged":false,
"unknown":null
}),
)
.await;
assert_eq!(stream.frame().await, ack(&json!(8), json!({})));
}
#[tokio::test]
async fn modern_http_ids_are_lossless_and_bounded() {
let h = Endpoint::started().await;
for id in [
json!("a".repeat(62)),
json!("é".repeat(31)),
json!(u64::MAX),
json!(9_007_199_254_740_993_u64),
json!(1.25),
json!(1.0),
] {
let mut stream = h.listen(id.clone(), json!({})).await;
let frame = stream.frame().await;
assert_eq!(frame, ack(&id, json!({})));
assert_eq!(frame["params"]["_meta"][SUB_ID].to_string(), id.to_string());
}
for id in [json!("a".repeat(63)), json!("é".repeat(32))] {
let body = terminal(
h.post(
MODERN_REVISION,
None,
listen_body(
id.clone(),
json!({"_meta":modern_meta(),"notifications":{}}),
),
)
.await,
)
.await;
assert_eq!(body["id"], id);
assert_eq!(body["error"]["code"], -32600);
assert!(body.get("result").is_none());
}
}
#[tokio::test]
async fn modern_http_meta_admission_precedes_sdk_decode() {
let h = Endpoint::started().await;
for meta in [
Value::Null,
json!([]),
json!({META_PROTOCOL_VERSION:MODERN_REVISION,
META_CLIENT_CAPABILITIES:null}),
] {
let before = counts(&h.counters);
let response = h
.post(
MODERN_REVISION,
None,
listen_body(json!(9), json!({"_meta":meta,"notifications":{}})),
)
.await;
// Admission rejections are HTTP 400, not a successful SSE response.
assert_eq!(response.status(), 400);
let raw = tokio::time::timeout(Duration::from_secs(6), response.text())
.await
.unwrap()
.unwrap();
let body: Value = serde_json::from_str(&raw).unwrap();
assert_eq!(body["error"]["code"], -32020);
assert!(body.get("result").is_none());
assert_eq!(
counts(&h.counters),
before,
"admission must reject before any SDK entry"
);
}
// clientInfo is optional at HTTP admission; SDK decoding must not newly require it.
let mut meta = modern_meta();
meta.as_object_mut().unwrap().remove(META_CLIENT_INFO);
let response = h
.post(
MODERN_REVISION,
None,
listen_body(
json!(10),
json!({"_meta":meta,"notifications":{},"extension":null}),
),
)
.await;
let mut stream = fixtures::Events::open(response);
assert_eq!(stream.frame().await, ack(&json!(10), json!({})));
}
@@ -0,0 +1,280 @@
//! Small real catalog fixture; broader Resource/Prompt mutations stay in mcp_signals::scenarios.
use super::*;
use crank_core::{AgentStatus, AgentVersion, ToolSelectionPolicy};
use crank_registry::{CreateAgentDraftVersionRequest, PublishAgentRequest, PublishRequest};
use crank_runtime::{
InMemoryCoordinationStateStore, RequestRateLimitConfig, RequestRateLimiter, SecretCrypto,
};
pub(super) struct Endpoint {
pub registry: crank_registry::PostgresRegistry,
pub counters: Arc<CounterSet>,
key: String,
url: String,
server: tokio::task::JoinHandle<()>,
}
impl Drop for Endpoint {
fn drop(&mut self) {
self.server.abort();
}
}
impl Endpoint {
pub async fn started() -> Self {
// First caller labels the shared, exit-cleaned disposable PostgreSQL with this owner.
crank_test_support::postgres_schema_url_for_task("signals_owner", "t_7d5f77a6").await;
let registry = test_registry().await;
// This fixture only lists/removes a Tool; no upstream execution is needed.
let operation = test_operation("http://127.0.0.1:9");
registry
.create_operation(&workspace_id(), &operation, Some("alice"))
.await
.unwrap();
registry
.publish_operation(PublishRequest {
workspace_id: &workspace_id(),
operation_id: &operation.id,
version: 1,
published_at: &test_time(),
published_by: Some("alice"),
})
.await
.unwrap();
publish_agent(&registry, &operation).await;
let key = create_api_key(&registry).await;
let counters = Arc::new(CounterSet::default());
let app = crate::build_app(
registry.clone(),
Duration::ZERO,
None,
SecretCrypto::new("test-master-key-00000000000000000000000000000000").unwrap(),
crank_runtime::community_with_outbound_policy(
crank_runtime::OutboundHttpPolicy::allowing_hosts(["127.0.0.1"]),
)
.build(),
RequestRateLimiter::new(RequestRateLimitConfig::new(10_000, 10_000).unwrap()),
Arc::new(InMemoryCoordinationStateStore::default()),
Arc::new(crate::session::InMemorySessionStore::default()),
Arc::new(crate::auth::CommunityMachineCredentialVerifier),
);
let app = observe_requests(app, counters.clone(), None);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let url = format!(
"http://{}/v1/{WORKSPACE_SLUG}/{AGENT_SLUG}",
listener.local_addr().unwrap()
);
let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
Self {
registry,
counters,
key,
url,
server,
}
}
pub async fn post(
&self,
revision: &str,
session: Option<&str>,
body: Value,
) -> reqwest::Response {
let mut request = reqwest::Client::new()
.post(&self.url)
.bearer_auth(&self.key)
.header("Accept", "application/json, text/event-stream")
.header("MCP-Protocol-Version", revision);
if revision == MODERN_REVISION {
request = request.header("Mcp-Method", body["method"].as_str().unwrap());
}
if let Some(session) = session {
request = request.header("MCP-Session-Id", session);
}
tokio::time::timeout(Duration::from_secs(6), request.json(&body).send())
.await
.unwrap()
.unwrap()
}
pub async fn listen(&self, id: Value, notifications: Value) -> Events {
Events::open(
self.post(
MODERN_REVISION,
None,
json!({
"jsonrpc":"2.0", "id":id, "method":"subscriptions/listen",
"params":{"_meta":modern_meta(), "notifications":notifications}
}),
)
.await,
)
}
pub async fn session(&self) -> String {
let response = self.post(LEGACY_REVISION, None, legacy_initialize(1)).await;
assert_eq!(response.status(), 200);
let session = response.headers()["MCP-Session-Id"]
.to_str()
.unwrap()
.to_owned();
let body = terminal(response).await;
assert_eq!(body["result"]["protocolVersion"], LEGACY_REVISION);
let response = self
.post(LEGACY_REVISION, Some(&session), initialized_notification())
.await;
assert_eq!(response.status(), 202);
session
}
pub async fn legacy_stream(&self, session: &str) -> Events {
let response = tokio::time::timeout(
Duration::from_secs(6),
reqwest::Client::new()
.get(&self.url)
.bearer_auth(&self.key)
.header("Accept", "text/event-stream")
.header("MCP-Protocol-Version", LEGACY_REVISION)
.header("MCP-Session-Id", session)
.send(),
)
.await
.unwrap()
.unwrap();
Events::open(response)
}
pub async fn tools(&self, revision: &str, session: Option<&str>) -> Value {
let params = if revision == MODERN_REVISION {
json!({"_meta":modern_meta()})
} else {
json!({})
};
terminal(
self.post(
revision,
session,
json!({"jsonrpc":"2.0","id":2,"method":"tools/list","params":params}),
)
.await,
)
.await
}
pub async fn draft_without_tools(&self) {
self.registry
.create_agent_draft_version(CreateAgentDraftVersionRequest {
workspace_id: &workspace_id(),
agent_id: &agent_id(),
version: &AgentVersion {
agent_id: agent_id(),
version: 2,
status: AgentStatus::Draft,
instructions: json!({}),
tool_selection_policy: ToolSelectionPolicy::default(),
created_at: test_time(),
},
bindings: &[],
updated_at: &test_time(),
})
.await
.unwrap();
}
pub async fn publish_without_tools(&self) {
self.registry
.publish_agent(PublishAgentRequest {
workspace_id: &workspace_id(),
agent_id: &agent_id(),
version: 2,
published_at: &test_time(),
published_by: Some("alice"),
expected_state: None,
})
.await
.unwrap();
}
}
pub(super) struct Events {
response: reqwest::Response,
buffer: Vec<u8>,
}
impl Events {
pub fn open(response: reqwest::Response) -> Self {
assert_eq!(response.status(), 200, "notification stream must open");
assert!(
response.headers()["content-type"]
.to_str()
.unwrap()
.starts_with("text/event-stream")
);
Self {
response,
buffer: Vec::new(),
}
}
// One absolute deadline: keepalive comments cannot extend a missing-frame assertion forever.
pub async fn next(&mut self, wait: Duration) -> Option<Value> {
let deadline = tokio::time::Instant::now() + wait;
loop {
if let Some(index) = self.buffer.windows(2).position(|w| w == b"\n\n") {
let frame: Vec<u8> = self.buffer.drain(..index + 2).collect();
let frame = std::str::from_utf8(&frame).unwrap();
if let Some(data) = frame.lines().find_map(|line| line.strip_prefix("data:")) {
return Some(serde_json::from_str(data.trim()).expect("SSE data must be JSON"));
}
continue;
}
match tokio::time::timeout_at(deadline, self.response.chunk()).await {
Err(_) => return None,
Ok(Err(error)) => panic!("SSE transport failure, not silence: {error}"),
Ok(Ok(None)) => panic!("SSE closed unexpectedly, not silence"),
Ok(Ok(Some(bytes))) => self.buffer.extend_from_slice(&bytes),
}
}
}
pub async fn frame(&mut self) -> Value {
self.next(Duration::from_secs(6))
.await
.expect("notification must arrive before deadline")
}
pub async fn silent(&mut self) {
assert_eq!(
self.next(Duration::from_millis(2200)).await,
None,
"no duplicate/unrequested signal"
);
}
}
pub(super) async fn terminal(response: reqwest::Response) -> Value {
let status = response.status();
assert!(
status == 200 || status == 404,
"unexpected terminal status {status}"
);
let sse = response.headers()["content-type"]
.to_str()
.unwrap()
.starts_with("text/event-stream");
let raw = tokio::time::timeout(Duration::from_secs(6), response.text())
.await
.unwrap()
.unwrap();
let body: Value = if sse {
let frames: Vec<Value> = raw
.lines()
.filter_map(|line| line.strip_prefix("data:"))
.map(|data| serde_json::from_str(data.trim()).unwrap())
.collect();
assert_eq!(
frames.len(),
1,
"one terminal frame, no notification: {raw}"
);
frames.into_iter().next().unwrap()
} else {
serde_json::from_str(&raw).unwrap()
};
assert_eq!(
status.as_u16(),
if body["error"]["code"] == -32601 {
404
} else {
200
}
);
body
}
+8
View File
@@ -41,6 +41,14 @@ Completion-срез #107 на базе rc.20/rmcp3.9.0 подключает `com
Logging-срез #107 на базе rc.22/rmcp3.9.0 использует существующий общий `protocol/logging.rs`, уже подключённый к штатному `build_app` HTTP: legacy `logging/setLevel` после прежней bounded string boundary декодируется в настоящий `SetLevelRequestParams`, а modern `_meta[io.modelcontextprotocol/logLevel]` — в SDK `LoggingLevel`. Неизвестные legacy поля, включая `_meta`, остаются игнорируемыми; неверные уровни дают прежний безопасный `INVALID_LEVEL`, modern отсутствие/неверное значение не включает logging. Domain severity ordering/store сохраняются явно: SDK enum не задаёт Ord. `notifications/message.params` сериализуется через `LoggingMessageNotificationParam` только из закрытого safe vocabulary; JSON-RPC envelope остаётся прежним. HTTP ATDD наблюдает реальные SDK decode/serialization обеих revisions и revoked-auth rejection; существующая logging-матрица и streamed progress regression сохраняют opt-in/isolation/filtering/JSON silence и carried scope. Очереди, try_lock/drop, transport/session/auth/lifecycle/capabilities не меняются; собственного runtime parsing уровня и handwritten params builder больше нет. Потребитель — действующий MCP HTTP клиент; signals/progress/cancel/subscriptions/прочие notifications и envelopes/transport/lifecycle ещё не объявляются перенесёнными. Полный #107, feature qualification и production deployment этим срезом не завершены.
Progress/cancel-срез #107 на базе rc.23/rmcp3.9.0 подключает штатный SSE `lifecycle::progress_frame` обеих revisions к сериализации `ProgressNotificationParam`, а legacy `handle_cancelled_notification` — к декодированию `CancelledNotificationParam.request_id`. Локальная projection+restore сохраняет исходные JSON numbers токена/ID и целочисленный u64 progress, включая значения вне i64/exact-f64; message и omissions берутся из SDK. Decoder передаёт SDK только requestId, не валидируя reason/_meta/extensions. Session+credential ownership, bounded queues/slots, transport, auth и modern stream-close cancellation не меняются. Runtime ATDD подтверждает SDK seams отдельно от wire; unit regression проверяет точную числовую форму. Decoder ignore действует только после HTTP admission: `_meta:[]` сохраняет прежний HTTP400/-32020 до SDK decoder. Отдельная HTTP-регрессия проверяет отказ без отмены активного вызова, а допустимый `_meta:{}` с reason/extensions — успешную SDK-отмену. Это частичная миграция params, не завершение #107, feature qualification или production deployment.
Catalog-change signals/subscriptions-срез #107 на базе rc.24/rmcp3.9.0 использует прежний `protocol/signals.rs` watcher: штатный modern `subscriptions/listen` декодирует notifications через `SubscriptionsListenRequestParams`/`SubscriptionFilter`, а acknowledgment и три list-change notification сериализуются настоящими SDK notification types в `protocol/signals_sdk.rs`. Тонкая входная projection сохраняет прежний запрет explicit null известных filter fields и игнорирование extensions; `_meta` по-прежнему проверяется только HTTP admission до decoder. SDK `NotificationMetaObject` хранит исходный JSON subscriptionId без сужения через RequestId; legacy frames остаются без params, modern ack первым сообщает только true accepted subset. URI-content subscriptions остаются unsupported, bounds32/2048 и64-byte id bound сохранены. Ближайший потребитель уже подключён: действующий `build_app` modern listen SSE и legacy GET SSE после committed catalog changes. HTTP ATDD независимо проверяет SDK execution и wire обеих revisions; прежние signals integration сохраняют Resource/Prompt/Tool delivery, scope, coalescing/recovery. Handwritten filter field DTO и frame builders заменены; fingerprint, watcher timing/queue/drop, auth/session/ownership/TTL/capabilities и transport не меняются. Полный #107, external-client/feature qualification и production deployment этим срезом не завершены.
Envelopes-срез #107 на базе rc.25/rmcp3.9.0 заменяет handwritten `jsonrpc_result`/`jsonrpc_error` в `jsonrpc.rs` сериализацией настоящих `JsonRpcResponse<Value>` и `JsonRpcError`/`ErrorData`. Уже подключённые consumers — общий `build_app` HTTP JSON и lifecycle SSE terminal обеих revisions; новые dispatch/transport пути не добавляются. Локальная projection+restore сразу возвращает исходные JSON id (включая null, u64 и точную floating-point форму) и i64 error code, которые SDK-типы не представляют полностью; произвольный result и omission error.data сохраняются. Прежний guard correlation не меняется: JSON protocol errors содержат correlation data, lifecycle SSE terminal errors по-прежнему её опускают. Runtime wire controls и отдельный SDK oracle проверяют success/protocol error, а affected regressions — admission, revoked credentials, tool isError и cancellation. Входная валидация, safe response id, auth, статусы/headers, очереди/сессии и transport остаются прежними; это не завершение #107, feature qualification или production deployment.
Negotiation-results-срез #107 на базе rc.26/rmcp3.9.0 заменяет handwritten ответы legacy `initialize` и modern `server/discover` на настоящие `InitializeResult`/`DiscoverResult` в `protocol/lifecycle_sdk.rs`. Уже подключённый потребитель — штатный `build_app` HTTP JSON/SSE. Версии и их порядок заданы прежним allowlist, capabilities поступают только из registry; server identity, omissions и discovery ttlMs=0/cacheScope=private сохранены. SDK `ServerCapabilities` не представляет дополнительные top-level имена registry: после typed serialization восстанавливаются только отсутствующие ключи, без замены SDK-known полей. HTTP ATDD отдельно проверяет прежний wire и SDK execution, legacy initialize→initialized→защищённый вызов и отсутствие session operations у modern discovery; affected regression сохраняет frozen advertisement, unsupported revision rejection, auth/revocation/Agent scope и legacy transport lifecycle. Следующий initialize-input-срез на базе rc.27 заменяет `app/request.rs::InitializeParams` декодированием настоящего `InitializeRequestParams` в `protocol/lifecycle_sdk.rs`: штатный `handle_initialize` использует SDK `protocol_version` в прежнем allowlist. Локальная projection передаёт только protocolVersion с инертными обязательными SDK capabilities/clientInfo; исходные ignored clientInfo/extensions не валидируются, а raw capabilities сохраняют прежний object-предикат elicitation. HTTP admission (включая запрет sequence params и malformed _meta) остаётся до SDK. Отдельный typed runtime oracle и JSON/SSE tolerance/session ATDD подтверждают использование результата SDK, отсутствие новых отказов и прежний initialize→initialized→защищённый вызов. Generic dispatch/ping, session storage/TTL/reconnect, admission/auth и transport не переносились. Существующий SSE error.data omission не исправляется; полный #107, feature qualification и production deployment не завершены.
Проверяемый результат:
- Через SDK проходят действующие Tools, Resources, Prompts, completion, уведомления и подписки в применимых revisions, а также progress/cancel и существующая logging policy.