From 835947e9fcd2c50a123274ed62da9dd5e2471ef7 Mon Sep 17 00:00:00 2001 From: bsodfather Date: Thu, 12 Nov 2026 02:20:43 +0000 Subject: [PATCH] refactor(mcp): migrate progress and legacy cancel params to rmcp SDK --- crates/crank-community-mcp/src/app.rs | 1 + .../src/app/dispatch_observer.rs | 23 + .../src/app/legacy_dispatch.rs | 33 +- .../crank-community-mcp/src/app/lifecycle.rs | 30 +- .../src/app/lifecycle_tests.rs | 38 ++ .../src/app/rmcp_progress_cancel.rs | 31 ++ .../src/app/rmcp_progress_cancel_tests.rs | 52 ++ .../src/rmcp_progress_cancel_http_support.rs | 290 +++++++++++ .../src/rmcp_progress_cancel_runtime_tests.rs | 457 ++++++++++++++++++ docs/development/rmcp-migration-plan.md | 2 + 10 files changed, 931 insertions(+), 26 deletions(-) create mode 100644 crates/crank-community-mcp/src/app/rmcp_progress_cancel.rs create mode 100644 crates/crank-community-mcp/src/app/rmcp_progress_cancel_tests.rs create mode 100644 crates/crank-community-mcp/src/rmcp_progress_cancel_http_support.rs create mode 100644 crates/crank-community-mcp/src/rmcp_progress_cancel_runtime_tests.rs diff --git a/crates/crank-community-mcp/src/app.rs b/crates/crank-community-mcp/src/app.rs index c06eaf5..36f98c9 100644 --- a/crates/crank-community-mcp/src/app.rs +++ b/crates/crank-community-mcp/src/app.rs @@ -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)] diff --git a/crates/crank-community-mcp/src/app/dispatch_observer.rs b/crates/crank-community-mcp/src/app/dispatch_observer.rs index 6be1304..73203ad 100644 --- a/crates/crank-community-mcp/src/app/dispatch_observer.rs +++ b/crates/crank-community-mcp/src/app/dispatch_observer.rs @@ -66,9 +66,19 @@ pub(crate) struct CounterSet { sdk_logging_dispatch: AtomicUsize, sdk_logging_level: AtomicUsize, sdk_logging_notification: AtomicUsize, + sdk_progress_notification: AtomicUsize, + sdk_cancelled_params: AtomicUsize, } impl CounterSet { + 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 +312,19 @@ 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; + fn increment(counter: impl Fn(&CounterSet) -> &AtomicUsize) { let _ = OBSERVER.try_with(|counters| { counter(counters).fetch_add(1, Ordering::SeqCst); diff --git a/crates/crank-community-mcp/src/app/legacy_dispatch.rs b/crates/crank-community-mcp/src/app/legacy_dispatch.rs index 52d1304..8249beb 100644 --- a/crates/crank-community-mcp/src/app/legacy_dispatch.rs +++ b/crates/crank-community-mcp/src/app/legacy_dispatch.rs @@ -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(¶ms(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() diff --git a/crates/crank-community-mcp/src/app/lifecycle.rs b/crates/crank-community-mcp/src/app/lifecycle.rs index dce6a49..459b386 100644 --- a/crates/crank-community-mcp/src/app/lifecycle.rs +++ b/crates/crank-community-mcp/src/app/lifecycle.rs @@ -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, }) } diff --git a/crates/crank-community-mcp/src/app/lifecycle_tests.rs b/crates/crank-community-mcp/src/app/lifecycle_tests.rs index 681788d..1861b7f 100644 --- a/crates/crank-community-mcp/src/app/lifecycle_tests.rs +++ b/crates/crank-community-mcp/src/app/lifecycle_tests.rs @@ -7,6 +7,44 @@ fn token(value: Value) -> Option { 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!( diff --git a/crates/crank-community-mcp/src/app/rmcp_progress_cancel.rs b/crates/crank-community-mcp/src/app/rmcp_progress_cancel.rs new file mode 100644 index 0000000..7036522 --- /dev/null +++ b/crates/crank-community-mcp/src/app/rmcp_progress_cancel.rs @@ -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 { + 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::(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; diff --git a/crates/crank-community-mcp/src/app/rmcp_progress_cancel_tests.rs b/crates/crank-community-mcp/src/app/rmcp_progress_cancel_tests.rs new file mode 100644 index 0000000..13c2c6a --- /dev/null +++ b/crates/crank-community-mcp/src/app/rmcp_progress_cancel_tests.rs @@ -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(¶ms).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(¶ms), None, "{params}"); + } +} diff --git a/crates/crank-community-mcp/src/rmcp_progress_cancel_http_support.rs b/crates/crank-community-mcp/src/rmcp_progress_cancel_http_support.rs new file mode 100644 index 0000000..57fbd2a --- /dev/null +++ b/crates/crank-community-mcp/src/rmcp_progress_cancel_http_support.rs @@ -0,0 +1,290 @@ +//! 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(super) struct Endpoint { + pub registry: crank_registry::PostgresRegistry, + pub counters: Arc, + pub key: String, + pub other_key: String, + pub gate: Arc, + pub started: Arc, + url: String, + servers: Vec>, +} +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(®istry, &operation).await; + let key = create_api_key(®istry).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 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()), + Arc::new(crate::session::InMemorySessionStore::default()), + 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, + 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, + 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 { + 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 { + 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() + } +} diff --git a/crates/crank-community-mcp/src/rmcp_progress_cancel_runtime_tests.rs b/crates/crank-community-mcp/src/rmcp_progress_cancel_runtime_tests.rs new file mode 100644 index 0000000..7208445 --- /dev/null +++ b/crates/crank-community-mcp/src/rmcp_progress_cancel_runtime_tests.rs @@ -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"] +mod fixtures; +use fixtures::Endpoint; + +fn observe_body(response: Response, counters: Arc) -> 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 { + 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); +} diff --git a/docs/development/rmcp-migration-plan.md b/docs/development/rmcp-migration-plan.md index 0004b62..5115633 100644 --- a/docs/development/rmcp-migration-plan.md +++ b/docs/development/rmcp-migration-plan.md @@ -41,6 +41,8 @@ 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. + Проверяемый результат: - Через SDK проходят действующие Tools, Resources, Prompts, completion, уведомления и подписки в применимых revisions, а также progress/cancel и существующая logging policy. -- 2.54.0