feat: gate not-found code at server boundary

Author: DaleSeo

conformance/src/bin/server.rs

@@ -615,7 +615,7 @@ impl ServerHandler for ConformanceServer {
                 } else {
                     Err(ErrorData::resource_not_found(
                         format!("Resource not found: {}", uri),
-                        None,
+                        Some(json!({ "uri": uri })),
                     ))
                 }
             }

crates/rmcp/src/handler/server.rs

@@ -22,7 +22,12 @@ impl<H: ServerHandler> Service<RoleServer> for H {
         request: <RoleServer as ServiceRole>::PeerReq,
         context: RequestContext<RoleServer>,
     ) -> Result<<RoleServer as ServiceRole>::Resp, McpError> {
-        match request {
+        // SEP-2164: peers negotiating 2026-07-28+ receive the standard INVALID_PARAMS code
+        // for resource-not-found; older peers keep the legacy RESOURCE_NOT_FOUND.
+        let use_invalid_params = context
+            .protocol_version()
+            .is_some_and(|v| v.as_str() >= ProtocolVersion::V_2026_07_28.as_str());
+        let result = match request {
             ClientRequest::InitializeRequest(request) => self
                 .initialize(request.params, context)
                 .await
@@ -127,7 +132,13 @@ impl<H: ServerHandler> Service<RoleServer> for H {
                 .cancel_task(request.params, context)
                 .await
                 .map(ServerResult::CancelTaskResult),
-        }
+        };
+        result.map_err(|mut error| {
+            if use_invalid_params && error.code == ErrorCode::RESOURCE_NOT_FOUND {
+                error.code = ErrorCode::INVALID_PARAMS;
+            }
+            error
+        })
     }
 
     async fn handle_notification(

crates/rmcp/src/model.rs

@@ -548,22 +548,10 @@ impl ErrorData {
         Self::new(ErrorCode::RESOURCE_NOT_FOUND, message, data)
     }
 
-    /// Create a resource-not-found error using the code required by the negotiated protocol version.
-    ///
-    /// SEP-2164 standardizes resource-not-found as JSON-RPC `INVALID_PARAMS` (`-32602`)
-    /// starting with protocol version `2026-07-28`. Older protocol versions continue to use
-    /// the legacy MCP-specific `RESOURCE_NOT_FOUND` code (`-32002`).
-    pub fn resource_not_found_for(
-        protocol_version: &ProtocolVersion,
-        message: impl Into<Cow<'static, str>>,
-        data: Option<Value>,
-    ) -> Self {
-        let code = if protocol_version.as_str() >= ProtocolVersion::V_2026_07_28.as_str() {
-            ErrorCode::INVALID_PARAMS
-        } else {
-            ErrorCode::RESOURCE_NOT_FOUND
-        };
-        Self::new(code, message, data)
+    /// Whether this error signals a resource-not-found condition under either the legacy
+    /// `RESOURCE_NOT_FOUND` (`-32002`) or the standardized `INVALID_PARAMS` (`-32602`) code.
+    pub fn is_resource_not_found(&self) -> bool {
+        self.code == ErrorCode::RESOURCE_NOT_FOUND || self.code == ErrorCode::INVALID_PARAMS
     }
 
     pub fn parse_error(message: impl Into<Cow<'static, str>>, data: Option<Value>) -> Self {
@@ -4044,23 +4032,14 @@ mod tests {
     }
 
     #[test]
-    fn resource_not_found_for_uses_legacy_code_for_older_protocol_versions() {
-        let error = ErrorData::resource_not_found_for(
-            &ProtocolVersion::V_2025_11_25,
-            "resource not found",
-            None,
-        );
-        assert_eq!(error.code, ErrorCode::RESOURCE_NOT_FOUND);
+    fn is_resource_not_found_recognizes_legacy_and_standard_codes() {
+        assert!(ErrorData::new(ErrorCode::RESOURCE_NOT_FOUND, "", None).is_resource_not_found());
+        assert!(ErrorData::new(ErrorCode::INVALID_PARAMS, "", None).is_resource_not_found());
     }
 
     #[test]
-    fn resource_not_found_for_uses_invalid_params_for_sep_2164_protocol_versions() {
-        let error = ErrorData::resource_not_found_for(
-            &ProtocolVersion::V_2026_07_28,
-            "resource not found",
-            None,
-        );
-        assert_eq!(error.code, ErrorCode::INVALID_PARAMS);
+    fn is_resource_not_found_rejects_unrelated_codes() {
+        assert!(!ErrorData::new(ErrorCode::METHOD_NOT_FOUND, "", None).is_resource_not_found());
     }
 
     #[test]

crates/rmcp/src/service.rs

@@ -674,6 +674,14 @@ impl<R: ServiceRole> RequestContext<R> {
     }
 }
 
+#[cfg(feature = "server")]
+impl RequestContext<RoleServer> {
+    /// The protocol version the client negotiated, or `None` before peer info is recorded.
+    pub fn protocol_version(&self) -> Option<&crate::model::ProtocolVersion> {
+        self.peer.peer_info().map(|info| &info.protocol_version)
+    }
+}
+
 /// Request execution context
 #[derive(Debug, Clone)]
 #[non_exhaustive]

crates/rmcp/tests/test_resource_not_found_version.rs

@@ -0,0 +1,91 @@
+//! SEP-2164: the resource-not-found error code follows the negotiated protocol version.
+//!
+//! `2026-07-28` and newer get the standard `INVALID_PARAMS` (-32602); older versions
+//! keep the legacy `RESOURCE_NOT_FOUND` (-32002).
+#![cfg(not(feature = "local"))]
+#![cfg(feature = "client")]
+
+use rmcp::{
+    ClientHandler, RoleServer, ServerHandler, ServiceError, ServiceExt,
+    model::{
+        ClientInfo, ErrorCode, ErrorData, ProtocolVersion, ReadResourceRequestParams,
+        ReadResourceResult,
+    },
+    service::RequestContext,
+};
+
+#[derive(Debug, Clone, Default)]
+struct ResourceServer;
+
+impl ServerHandler for ResourceServer {
+    async fn read_resource(
+        &self,
+        _request: ReadResourceRequestParams,
+        _context: RequestContext<RoleServer>,
+    ) -> Result<ReadResourceResult, ErrorData> {
+        Err(ErrorData::resource_not_found("resource not found", None))
+    }
+}
+
+#[derive(Debug, Clone)]
+struct VersionedClient {
+    protocol_version: ProtocolVersion,
+}
+
+impl ClientHandler for VersionedClient {
+    fn get_info(&self) -> ClientInfo {
+        let mut info = ClientInfo::default();
+        info.protocol_version = self.protocol_version.clone();
+        info
+    }
+}
+
+async fn not_found_code(client_version: ProtocolVersion) -> ErrorCode {
+    let (server_transport, client_transport) = tokio::io::duplex(4096);
+
+    let server_handle = tokio::spawn(async move {
+        ResourceServer
+            .serve(server_transport)
+            .await?
+            .waiting()
+            .await?;
+        anyhow::Ok(())
+    });
+
+    let client = VersionedClient {
+        protocol_version: client_version,
+    }
+    .serve(client_transport)
+    .await
+    .expect("client should connect");
+
+    let error = client
+        .read_resource(ReadResourceRequestParams::new("missing://resource"))
+        .await
+        .expect_err("missing resource should error");
+
+    let code = match error {
+        ServiceError::McpError(data) => data.code,
+        other => panic!("expected McpError, got: {other:?}"),
+    };
+
+    client.cancel().await.expect("client should cancel");
+    server_handle.await.expect("server task").expect("server");
+    code
+}
+
+#[tokio::test]
+async fn legacy_version_gets_resource_not_found_code() {
+    assert_eq!(
+        not_found_code(ProtocolVersion::V_2025_11_25).await,
+        ErrorCode::RESOURCE_NOT_FOUND,
+    );
+}
+
+#[tokio::test]
+async fn sep_2164_version_gets_invalid_params_code() {
+    assert_eq!(
+        not_found_code(ProtocolVersion::V_2026_07_28).await,
+        ErrorCode::INVALID_PARAMS,
+    );
+}