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
417 lines
14 KiB
Rust
417 lines
14 KiB
Rust
//! #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(¶ms);
|
|
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(¶ms);
|
|
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(¶ms);
|
|
})
|
|
.await;
|
|
assert_eq!(
|
|
c.sdk_initialize_input(),
|
|
1,
|
|
"another request scope is isolated"
|
|
);
|
|
}
|