fix(server): remove initialized notification gate to support Streamable HTTP (#788)

* fix(server): remove initialized notification gate to support Streamable HTTP

The server's init handshake loop fatally rejected any request arriving
before the `notifications/initialized` message. This breaks Streamable
HTTP clients where each JSON-RPC message is a separate POST with no
ordering guarantee — `tools/list` can easily arrive before `initialized`.

Remove the ~40-line wait loop and enter `serve_inner` immediately after
sending `InitializeResult`. The `initialized` notification is now
handled as a regular notification by the main service loop, matching the
TypeScript SDK behavior (validated in typescript-sdk#578).

Also remove the now-unreachable `ExpectedInitializedNotification` error
variant from `ServerInitializeError`.

Closes #783

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(server): keep ExpectedInitializedNotification as deprecated

Retain the variant for semver compatibility — removing it would be a
breaking change caught by cargo-semver-checks. Mark it deprecated with
a note that it is never constructed and will be removed in a future
major release.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Anar Azadaliyev <anar.azadaliye@gmail.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

crates/rmcp/tests/test_server_initialization.rs

@@ -6,7 +6,6 @@ use common::handlers::TestServer;
 use rmcp::{
     ServiceExt,
     model::{ClientJsonRpcMessage, ServerJsonRpcMessage, ServerResult},
-    service::ServerInitializeError,
     transport::{IntoTransport, Transport},
 };
 
@@ -54,7 +53,7 @@ async fn do_initialize(client: &mut impl Transport<rmcp::RoleClient>) {
     let _response = client.receive().await.unwrap();
 }
 
-// Server responds with EmptyResult to setLevel received before initialized.
+// Server handles setLevel sent before initialized notification (processed by serve_inner).
 #[tokio::test]
 async fn server_init_set_level_response_is_empty_result() {
     let (server_transport, client_transport) = tokio::io::duplex(4096);
@@ -64,7 +63,14 @@ async fn server_init_set_level_response_is_empty_result() {
     do_initialize(&mut client).await;
     client.send(set_level_request(2)).await.unwrap();
 
-    let response = client.receive().await.unwrap();
+    // The handler may send logging notifications before the response;
+    // skip notifications to find the EmptyResult response.
+    let response = loop {
+        let msg = client.receive().await.unwrap();
+        if matches!(msg, ServerJsonRpcMessage::Response(_)) {
+            break msg;
+        }
+    };
     assert!(
         matches!(
             response,
@@ -85,7 +91,13 @@ async fn server_init_succeeds_after_set_level_before_initialized() {
 
     do_initialize(&mut client).await;
     client.send(set_level_request(2)).await.unwrap();
-    let _response = client.receive().await.unwrap();
+    // Skip notifications until we get the response
+    loop {
+        let msg = client.receive().await.unwrap();
+        if matches!(msg, ServerJsonRpcMessage::Response(_)) {
+            break;
+        }
+    }
     client.send(initialized_notification()).await.unwrap();
 
     let result = server_handle.await.unwrap();
@@ -179,23 +191,66 @@ async fn server_init_succeeds_after_ping_before_initialized() {
     result.unwrap().cancel().await.unwrap();
 }
 
-// Server returns ExpectedInitializedNotification for any other message before initialized.
+// Server buffers tools/list sent before initialized and processes it after initialization.
 #[tokio::test]
-async fn server_init_rejects_unexpected_message_before_initialized() {
+async fn server_init_buffers_request_before_initialized() {
     let (server_transport, client_transport) = tokio::io::duplex(4096);
     let server_handle =
         tokio::spawn(async move { TestServer::new().serve(server_transport).await });
     let mut client = IntoTransport::<rmcp::RoleClient, _, _>::into_transport(client_transport);
 
     do_initialize(&mut client).await;
+    // Send tools/list before initialized notification
     client.send(list_tools_request(2)).await.unwrap();
+    // Now send initialized notification
+    client.send(initialized_notification()).await.unwrap();
+
+    // The buffered tools/list should be processed — expect a response
+    let response = client.receive().await.unwrap();
+    assert!(
+        matches!(response, ServerJsonRpcMessage::Response(_)),
+        "expected response for buffered tools/list, got: {response:?}"
+    );
 
     let result = server_handle.await.unwrap();
     assert!(
-        matches!(
-            result,
-            Err(ServerInitializeError::ExpectedInitializedNotification(_))
-        ),
-        "expected ExpectedInitializedNotification error"
+        result.is_ok(),
+        "server should initialize successfully when buffering pre-init messages"
     );
+    result.unwrap().cancel().await.unwrap();
+}
+
+// Server buffers multiple requests before initialized and processes them in order.
+#[tokio::test]
+async fn server_init_buffers_multiple_requests_before_initialized() {
+    let (server_transport, client_transport) = tokio::io::duplex(4096);
+    let server_handle =
+        tokio::spawn(async move { TestServer::new().serve(server_transport).await });
+    let mut client = IntoTransport::<rmcp::RoleClient, _, _>::into_transport(client_transport);
+
+    do_initialize(&mut client).await;
+    // Send two requests before initialized
+    client.send(list_tools_request(2)).await.unwrap();
+    client.send(ping_request(3)).await.unwrap();
+    // Now send initialized notification
+    client.send(initialized_notification()).await.unwrap();
+
+    // Both buffered messages should get responses
+    let response1 = client.receive().await.unwrap();
+    let response2 = client.receive().await.unwrap();
+    assert!(
+        matches!(response1, ServerJsonRpcMessage::Response(_)),
+        "expected response for first buffered message, got: {response1:?}"
+    );
+    assert!(
+        matches!(response2, ServerJsonRpcMessage::Response(_)),
+        "expected response for second buffered message, got: {response2:?}"
+    );
+
+    let result = server_handle.await.unwrap();
+    assert!(
+        result.is_ok(),
+        "server should initialize successfully with multiple buffered messages"
+    );
+    result.unwrap().cancel().await.unwrap();
 }