refactor: drop modern naming and dead cleanup

Author: DaleSeo

README.md

@@ -94,7 +94,7 @@ let client = ClientInfo::default()
     )
     .await?;
 
-// Or probe the modern lifecycle and fall back when a legacy server reports
+// Or probe the discover lifecycle and fall back when a legacy server reports
 // that server/discover is not implemented.
 let client = ClientInfo::default()
     .serve_with_lifecycle(
@@ -108,7 +108,7 @@ let client = ClientInfo::default()
 ```
 
 `ClientLifecycleMode::Initialize` is equivalent to the existing `serve()` behavior.
-Modern startup does not send `notifications/initialized`; discovery completes
+Discover startup does not send `notifications/initialized`; discovery completes
 startup, and each subsequent request carries its protocol version, client
 information, and capabilities in `_meta`.
 

conformance/src/bin/client.rs

@@ -853,9 +853,9 @@ fn conformance_protocol_version() -> ProtocolVersion {
         .unwrap_or(ProtocolVersion::V_2026_07_28)
 }
 
-/// Runs draft stateless scenarios through the public modern lifecycle and
+/// Runs draft stateless scenarios through the public discover lifecycle and
 /// Streamable HTTP transport.
-async fn run_modern_client(server_url: &str) -> anyhow::Result<()> {
+async fn run_discover_client(server_url: &str) -> anyhow::Result<()> {
     let mut preferred_versions = vec![conformance_protocol_version()];
     for version in ProtocolVersion::KNOWN_VERSIONS.iter().rev() {
         if !preferred_versions.contains(version) {
@@ -922,14 +922,14 @@ async fn main() -> anyhow::Result<()> {
     match scenario.as_str() {
         // Non-auth scenarios
         "initialize" => run_basic_client(&server_url).await?,
-        "json-schema-ref-no-deref" => run_modern_client(&server_url).await?,
+        "json-schema-ref-no-deref" => run_discover_client(&server_url).await?,
         "tools_call" => run_tools_call_client(&server_url, &ctx).await?,
         "elicitation-sep1034-client-defaults" => {
             run_elicitation_defaults_client(&server_url).await?
         }
         "sse-retry" => run_sse_retry_client(&server_url).await?,
         "request-metadata" | "sep-2322-client-request-state" => {
-            run_modern_client(&server_url).await?
+            run_discover_client(&server_url).await?
         }
         "http-standard-headers" | "http-custom-headers" | "http-invalid-tool-headers" => {
             run_tools_call_client(&server_url, &ctx).await?

crates/rmcp/Cargo.toml

@@ -303,24 +303,24 @@ required-features = ["server", "client"]
 path = "tests/test_protocol_version_negotiation.rs"
 
 [[test]]
-name = "test_client_startup_modes"
+name = "test_client_lifecycle_modes"
 required-features = ["client", "server"]
-path = "tests/test_client_startup_modes.rs"
+path = "tests/test_client_lifecycle_modes.rs"
 
 [[test]]
-name = "test_modern_server_requests"
+name = "test_stateless_server_requests"
 required-features = ["client", "server"]
-path = "tests/test_modern_server_requests.rs"
+path = "tests/test_stateless_server_requests.rs"
 
 [[test]]
-name = "test_modern_http_client_startup"
+name = "test_discover_http_client_startup"
 required-features = [
   "client",
   "reqwest",
   "transport-streamable-http-client-reqwest",
   "transport-streamable-http-server",
 ]
-path = "tests/test_modern_http_client_startup.rs"
+path = "tests/test_discover_http_client_startup.rs"
 
 [[test]]
 name = "test_streamable_http_standard_headers"

crates/rmcp/src/model/meta.rs

@@ -439,7 +439,7 @@ impl RequestMetaObject {
         meta
     }
 
-    /// Create request metadata with the client context required by the modern lifecycle.
+    /// Create request metadata with the client context SEP-2575 requires on every request.
     pub fn with_client_context(
         protocol_version: ProtocolVersion,
         client_info: Implementation,

crates/rmcp/src/service.rs

@@ -577,7 +577,7 @@ impl PeerRequestOptions {
 
     /// Adds request metadata while preserving any other configured options.
     ///
-    /// Explicit values take precedence over modern-lifecycle metadata defaults.
+    /// Explicit values take precedence over discover-lifecycle metadata defaults.
     pub fn with_meta(mut self, meta: RequestMetaObject) -> Self {
         self.meta = Some(meta);
         self

crates/rmcp/src/service/client.rs

@@ -62,7 +62,7 @@ pub enum ClientInitializeError {
         server_supported: Vec<ProtocolVersion>,
     },
 
-    #[error("modern startup requires at least one preferred protocol version")]
+    #[error("discover startup requires at least one preferred protocol version")]
     NoPreferredProtocolVersion,
 
     #[error("Cancelled")]
@@ -325,7 +325,7 @@ where
             legacy_startup(&service, &mut transport, &id_provider, &peer, client_info).await?;
         }
         ClientLifecycleMode::Discover { preferred_versions } => {
-            modern_startup(
+            discover_startup(
                 &service,
                 &mut transport,
                 &id_provider,
@@ -339,7 +339,7 @@ where
             preferred_versions,
             legacy_version,
         } => {
-            let modern_result = modern_startup(
+            let discover_result = discover_startup(
                 &service,
                 &mut transport,
                 &id_provider,
@@ -348,7 +348,7 @@ where
                 preferred_versions,
             )
             .await;
-            match modern_result {
+            match discover_result {
                 Ok(()) => {}
                 Err(ClientInitializeError::JsonRpcError(error))
                     if error.code == crate::model::ErrorCode::METHOD_NOT_FOUND =>
@@ -423,7 +423,7 @@ where
     Ok(())
 }
 
-async fn modern_startup<S, T>(
+async fn discover_startup<S, T>(
     service: &S,
     transport: &mut T,
     id_provider: &Arc<AtomicU32RequestIdProvider>,

crates/rmcp/src/service/server.rs

@@ -243,7 +243,7 @@ where
                 Err(error) => ServerJsonRpcMessage::error(error, Some(id)),
             };
             transport.send(response).await.map_err(|error| {
-                ServerInitializeError::transport::<T>(error, "sending modern request response")
+                ServerInitializeError::transport::<T>(error, "sending negotiated request response")
             })?;
             return Ok(serve_inner(service, transport, peer, peer_rx, ct));
         }

crates/rmcp/src/transport/streamable_http_client.rs

@@ -1007,30 +1007,15 @@ impl<C: StreamableHttpClient> Worker for StreamableHttpClientWorker<C> {
                         );
                     if is_fallback_initialize {
                         saved_init_request = Some(message.clone());
-                        streams.abort_all();
-                        while streams.join_next().await.is_some() {}
-                        if let Some(cleanup) = session_cleanup_info.take() {
-                            match tokio::time::timeout(
-                                SESSION_CLEANUP_TIMEOUT,
-                                cleanup.client.delete_session(
-                                    cleanup.uri,
-                                    cleanup.session_id,
-                                    cleanup.auth_header,
-                                    cleanup.protocol_headers,
-                                ),
-                            )
-                            .await
-                            {
-                                Ok(Ok(())) => {}
-                                Ok(Err(error)) => tracing::debug!(
-                                    "failed to clean up discovery session before legacy fallback: {error}"
-                                ),
-                                Err(_) => tracing::warn!(
-                                    "discovery session cleanup timed out before legacy fallback"
-                                ),
-                            }
-                        }
-                        session_id = None;
+                        // Servers do not assign sessions to `server/discover`, so a
+                        // fallback initialize starts from a clean slate: no session
+                        // ID, no cleanup state, and no streams to tear down.
+                        debug_assert!(
+                            session_id.is_none()
+                                && session_cleanup_info.is_none()
+                                && streams.is_empty(),
+                            "discover bootstrap must not create session state"
+                        );
 
                         let response = self
                             .client

…/rmcp/tests/test_client_startup_modes.rs …mcp/tests/test_client_lifecycle_modes.rscrates/rmcp/tests/test_client_startup_modes.rs renamed to crates/rmcp/tests/test_client_lifecycle_modes.rs crates/rmcp/tests/test_client_startup_modes.rs renamed to crates/rmcp/tests/test_client_lifecycle_modes.rs

@@ -12,42 +12,42 @@ use rmcp::{
 };
 
 #[derive(Clone, Default)]
-struct ModernClient;
+struct DiscoverClient;
 
-impl ClientHandler for ModernClient {}
+impl ClientHandler for DiscoverClient {}
 
 #[derive(Clone, Default)]
-struct ModernServer;
+struct StatelessServer;
 
-impl ServerHandler for ModernServer {}
+impl ServerHandler for StatelessServer {}
 
 #[tokio::test]
-async fn high_level_server_accepts_modern_startup_without_initialize() {
+async fn high_level_server_accepts_discover_startup_without_initialize() {
     let (server_transport, client_transport) = tokio::io::duplex(4096);
     let server_task = tokio::spawn(async move {
-        ModernServer
+        StatelessServer
             .serve(server_transport)
             .await
             .expect("server should accept discover")
     });
 
-    let client = ModernClient
+    let client = DiscoverClient
         .serve_with_lifecycle(
             client_transport,
             ClientLifecycleMode::Discover {
                 preferred_versions: vec![ProtocolVersion::V_2026_07_28],
             },
         )
         .await
-        .expect("modern client should start");
+        .expect("discover client should start");
     client.list_tools(None).await.expect("list tools");
     client.cancel().await.expect("cancel client");
     let server = server_task.await.expect("server task");
     server.cancel().await.expect("cancel server");
 }
 
 #[tokio::test]
-async fn modern_startup_discovers_without_initialize() {
+async fn discover_startup_omits_initialize() {
     let (server_transport, client_transport) = tokio::io::duplex(4096);
     let mut server = IntoTransport::<rmcp::RoleServer, _, _>::into_transport(server_transport);
     let server_task = tokio::spawn(async move {
@@ -67,7 +67,7 @@ async fn modern_startup_discovers_without_initialize() {
                 ServerResult::DiscoverResult(DiscoverResult::new(
                     vec![ProtocolVersion::V_2026_07_28],
                     ServerCapabilities::default(),
-                    Implementation::new("modern-server", "1.0.0"),
+                    Implementation::new("discover-server", "1.0.0"),
                 )),
                 request.id,
             ))
@@ -100,15 +100,15 @@ async fn modern_startup_discovers_without_initialize() {
             .expect("send tools response");
     });
 
-    let client = ModernClient
+    let client = DiscoverClient
         .serve_with_lifecycle(
             client_transport,
             ClientLifecycleMode::Discover {
                 preferred_versions: vec![ProtocolVersion::V_2026_07_28],
             },
         )
         .await
-        .expect("modern client should start");
+        .expect("discover client should start");
     let mut caller_meta = rmcp::model::RequestMetaObject::new();
     caller_meta.insert("example.test/extension".into(), serde_json::json!(7));
     caller_meta.set_protocol_version(ProtocolVersion::V_2025_11_25);
@@ -176,7 +176,7 @@ async fn auto_startup_falls_back_after_discover_method_not_found() {
         ));
     });
 
-    let client = ModernClient
+    let client = DiscoverClient
         .serve_with_lifecycle(
             client_transport,
             ClientLifecycleMode::Auto {
@@ -191,7 +191,7 @@ async fn auto_startup_falls_back_after_discover_method_not_found() {
 }
 
 #[tokio::test]
-async fn modern_startup_retries_a_mutually_supported_version() {
+async fn discover_startup_retries_a_mutually_supported_version() {
     let unsupported: ProtocolVersion =
         serde_json::from_value(serde_json::json!("2099-01-01")).unwrap();
     let (server_transport, client_transport) = tokio::io::duplex(4096);
@@ -231,15 +231,15 @@ async fn modern_startup_retries_a_mutually_supported_version() {
                 ServerResult::DiscoverResult(DiscoverResult::new(
                     vec![ProtocolVersion::V_2026_07_28],
                     ServerCapabilities::default(),
-                    Implementation::new("modern-server", "1.0.0"),
+                    Implementation::new("discover-server", "1.0.0"),
                 )),
                 second.id,
             ))
             .await
             .expect("send discover response");
     });
 
-    let client = ModernClient
+    let client = DiscoverClient
         .serve_with_lifecycle(
             client_transport,
             ClientLifecycleMode::Discover {
@@ -250,13 +250,13 @@ async fn modern_startup_retries_a_mutually_supported_version() {
             },
         )
         .await
-        .expect("modern client should retry");
+        .expect("discover client should retry");
     client.cancel().await.expect("cancel client");
     server_task.await.expect("server task");
 }
 
 #[tokio::test]
-async fn modern_startup_retries_current_version_once_when_server_reports_it_supported() {
+async fn discover_startup_retries_current_version_once_when_server_reports_it_supported() {
     let (server_transport, client_transport) = tokio::io::duplex(4096);
     let mut server = IntoTransport::<rmcp::RoleServer, _, _>::into_transport(server_transport);
     let server_task = tokio::spawn(async move {
@@ -290,23 +290,23 @@ async fn modern_startup_retries_current_version_once_when_server_reports_it_supp
                 ServerResult::DiscoverResult(DiscoverResult::new(
                     vec![ProtocolVersion::V_2026_07_28],
                     ServerCapabilities::default(),
-                    Implementation::new("modern-server", "1.0.0"),
+                    Implementation::new("discover-server", "1.0.0"),
                 )),
                 second.id,
             ))
             .await
             .expect("send discover response");
     });
 
-    let client = ModernClient
+    let client = DiscoverClient
         .serve_with_lifecycle(
             client_transport,
             ClientLifecycleMode::Discover {
                 preferred_versions: vec![ProtocolVersion::V_2026_07_28],
             },
         )
         .await
-        .expect("modern client should retry once");
+        .expect("discover client should retry once");
     client.cancel().await.expect("cancel client");
     server_task.await.expect("server task");
 }

…tests/test_modern_http_client_startup.rs …sts/test_discover_http_client_startup.rscrates/rmcp/tests/test_modern_http_client_startup.rs renamed to crates/rmcp/tests/test_discover_http_client_startup.rs crates/rmcp/tests/test_modern_http_client_startup.rs renamed to crates/rmcp/tests/test_discover_http_client_startup.rs

@@ -22,9 +22,9 @@ use rmcp::{
 use tokio_util::sync::CancellationToken;
 
 #[derive(Clone, Default)]
-struct ModernHttpServer;
+struct DiscoverHttpServer;
 
-impl ServerHandler for ModernHttpServer {
+impl ServerHandler for DiscoverHttpServer {
     fn supported_protocol_versions(&self) -> Cow<'static, [ProtocolVersion]> {
         Cow::Borrowed(&[ProtocolVersion::V_2026_07_28])
     }
@@ -47,11 +47,11 @@ impl ServerHandler for LegacyHttpServer {
 }
 
 #[tokio::test]
-async fn modern_http_client_bootstraps_headers_without_initialize() {
+async fn discover_http_client_bootstraps_headers_without_initialize() {
     let ct = CancellationToken::new();
-    let service: StreamableHttpService<ModernHttpServer, LocalSessionManager> =
+    let service: StreamableHttpService<DiscoverHttpServer, LocalSessionManager> =
         StreamableHttpService::new(
-            || Ok(ModernHttpServer),
+            || Ok(DiscoverHttpServer),
             Default::default(),
             StreamableHttpServerConfig::default()
                 .with_stateful_mode(false)
@@ -83,7 +83,7 @@ async fn modern_http_client_bootstraps_headers_without_initialize() {
             },
         )
         .await
-        .expect("modern HTTP client should start");
+        .expect("discover HTTP client should start");
     client.list_tools(None).await.expect("list tools");
     client.cancel().await.expect("cancel client");