From 9b3e0248d19aee4cb2e7bdfdb566ae61e1f615a4 Mon Sep 17 00:00:00 2001 From: bsodfather Date: Fri, 13 Nov 2026 04:14:34 +0000 Subject: [PATCH] MCP: execute Resources through request-scoped SDK handlers --- crates/crank-community-mcp/src/app.rs | 2 + .../crank-community-mcp/src/app/dispatch.rs | 3 +- .../src/app/dispatch_observer.rs | 58 +++ .../src/app/legacy_dispatch.rs | 10 +- .../crank-community-mcp/src/app/response.rs | 73 +-- .../src/app/rmcp_dispatch.rs | 34 +- .../src/app/rmcp_resources.rs | 423 ++++++++++++++++++ .../src/app/rmcp_resources_projection.rs | 148 ++++++ .../rmcp_resources_handler_runtime_tests.rs | 125 ++++++ .../src/rmcp_resources_handler_tests.rs | 328 ++++++++++++++ .../src/rmcp_resources_runtime_tests.rs | 105 ++++- 11 files changed, 1203 insertions(+), 106 deletions(-) create mode 100644 crates/crank-community-mcp/src/app/rmcp_resources.rs create mode 100644 crates/crank-community-mcp/src/app/rmcp_resources_projection.rs create mode 100644 crates/crank-community-mcp/src/rmcp_resources_handler_runtime_tests.rs create mode 100644 crates/crank-community-mcp/src/rmcp_resources_handler_tests.rs diff --git a/crates/crank-community-mcp/src/app.rs b/crates/crank-community-mcp/src/app.rs index 36f98c9..c864526 100644 --- a/crates/crank-community-mcp/src/app.rs +++ b/crates/crank-community-mcp/src/app.rs @@ -41,6 +41,8 @@ mod rmcp_http; #[path = "rmcp_http_tests.rs"] mod rmcp_http_tests; mod rmcp_progress_cancel; +mod rmcp_resources; +mod rmcp_resources_projection; #[cfg(test)] mod rmcp_session_tests; #[cfg(test)] diff --git a/crates/crank-community-mcp/src/app/dispatch.rs b/crates/crank-community-mcp/src/app/dispatch.rs index 4c747d3..389cec4 100644 --- a/crates/crank-community-mcp/src/app/dispatch.rs +++ b/crates/crank-community-mcp/src/app/dispatch.rs @@ -415,8 +415,7 @@ pub(super) async fn handle_modern_request( }; let (templates, next_cursor) = match list_resource_templates( state, - &path.workspace_slug, - &path.agent_slug, + resource_service_context(path, credential, transport_correlation, message), version, command, ) diff --git a/crates/crank-community-mcp/src/app/dispatch_observer.rs b/crates/crank-community-mcp/src/app/dispatch_observer.rs index f18926a..46fbc60 100644 --- a/crates/crank-community-mcp/src/app/dispatch_observer.rs +++ b/crates/crank-community-mcp/src/app/dispatch_observer.rs @@ -55,6 +55,12 @@ pub(crate) struct CounterSet { sdk_tools_list_result: AtomicUsize, sdk_tools_call_result: AtomicUsize, sdk_resources_dispatch: AtomicUsize, + sdk_resources_list_handler_completed: AtomicUsize, + sdk_resources_read_handler_completed: AtomicUsize, + sdk_resources_templates_handler_completed: AtomicUsize, + sdk_resources_list_handler_consumed: AtomicUsize, + sdk_resources_read_handler_consumed: AtomicUsize, + sdk_resources_templates_handler_consumed: AtomicUsize, sdk_resources_list_result: AtomicUsize, sdk_resources_read_result: AtomicUsize, sdk_resource_templates_list_result: AtomicUsize, @@ -89,6 +95,30 @@ pub(crate) struct CounterSet { } impl CounterSet { + pub(crate) fn sdk_resources_list_handler_completed(&self) -> usize { + self.sdk_resources_list_handler_completed + .load(Ordering::SeqCst) + } + pub(crate) fn sdk_resources_read_handler_completed(&self) -> usize { + self.sdk_resources_read_handler_completed + .load(Ordering::SeqCst) + } + pub(crate) fn sdk_resources_templates_handler_completed(&self) -> usize { + self.sdk_resources_templates_handler_completed + .load(Ordering::SeqCst) + } + pub(crate) fn sdk_resources_list_handler_consumed(&self) -> usize { + self.sdk_resources_list_handler_consumed + .load(Ordering::SeqCst) + } + pub(crate) fn sdk_resources_read_handler_consumed(&self) -> usize { + self.sdk_resources_read_handler_consumed + .load(Ordering::SeqCst) + } + pub(crate) fn sdk_resources_templates_handler_consumed(&self) -> usize { + self.sdk_resources_templates_handler_consumed + .load(Ordering::SeqCst) + } pub(crate) fn sdk_inbound_response_decoded(&self) -> usize { self.sdk_inbound_response_decoded.load(Ordering::SeqCst) } @@ -309,6 +339,31 @@ pub(crate) fn sdk_tools_call_result_serialized() { increment(|counters| &counters.sdk_tools_call_result); } +/// Mark inside the ServerHandler override after domain await and typed result/error construction. +pub(crate) fn sdk_resources_list_handler_completed() { + increment(|c| &c.sdk_resources_list_handler_completed); +} +/// Mark inside the ServerHandler override after domain await and typed result/error construction. +pub(crate) fn sdk_resources_read_handler_completed() { + increment(|c| &c.sdk_resources_read_handler_completed); +} +/// Mark inside the ServerHandler override after domain await and typed result/error construction. +pub(crate) fn sdk_resources_templates_handler_completed() { + increment(|c| &c.sdk_resources_templates_handler_completed); +} +/// Mark in the caller only after matching and consuming the actual trait Result. +pub(crate) fn sdk_resources_list_handler_consumed() { + increment(|c| &c.sdk_resources_list_handler_consumed); +} +/// Mark in the caller only after matching and consuming the actual trait Result. +pub(crate) fn sdk_resources_read_handler_consumed() { + increment(|c| &c.sdk_resources_read_handler_consumed); +} +/// Mark in the caller only after matching and consuming the actual trait Result. +pub(crate) fn sdk_resources_templates_handler_consumed() { + increment(|c| &c.sdk_resources_templates_handler_consumed); +} + /// Mark only after converting a Resources request through the real SDK typed path. pub(crate) fn sdk_resources_dispatch_enter() { increment(|counters| &counters.sdk_resources_dispatch); @@ -333,6 +388,9 @@ pub(crate) fn sdk_resource_templates_list_result_serialized() { #[path = "../rmcp_resources_runtime_tests.rs"] mod rmcp_resources_runtime_tests; +#[path = "../rmcp_resources_handler_runtime_tests.rs"] +mod rmcp_resources_handler_runtime_tests; + /// Mark only after converting a Prompts request through the real SDK typed path. pub(crate) fn sdk_prompts_dispatch_enter() { increment(|counters| &counters.sdk_prompts_dispatch); diff --git a/crates/crank-community-mcp/src/app/legacy_dispatch.rs b/crates/crank-community-mcp/src/app/legacy_dispatch.rs index 32f7ac8..22cde24 100644 --- a/crates/crank-community-mcp/src/app/legacy_dispatch.rs +++ b/crates/crank-community-mcp/src/app/legacy_dispatch.rs @@ -431,8 +431,14 @@ pub(super) async fn handle_legacy_request( }; let (templates, next_cursor) = match list_resource_templates( &state, - &path.workspace_slug, - &path.agent_slug, + ServiceContext { + workspace_slug: &session.workspace_slug, + agent_slug: &session.agent_slug, + credential, + correlation: transport_correlation, + continuation: ContinuationSupport::from_supported(session.supports_elicitation), + locale: execution_locale(message), + }, &session.protocol_version, command, ) diff --git a/crates/crank-community-mcp/src/app/response.rs b/crates/crank-community-mcp/src/app/response.rs index 6472413..a55642f 100644 --- a/crates/crank-community-mcp/src/app/response.rs +++ b/crates/crank-community-mcp/src/app/response.rs @@ -134,35 +134,11 @@ pub(super) fn resources_list_result( next_cursor: Option, version: &str, ) -> Result { - let modern = version == crate::jsonrpc::MODERN_PROTOCOL_VERSION; - let result = rmcp::model::ListResourcesResult { - resources: resources - .iter() - .cloned() - .map(serde_json::from_value) - .collect::>()?, - next_cursor, - result_type: modern.then_some(ResultType::COMPLETE), - ttl_ms: modern.then_some(0), - cache_scope: modern.then_some(CacheScope::Private), - meta: None, - }; - let mut result = serde_json::to_value(result)?; + let (result, extras) = + super::rmcp_resources_projection::list(&resources, next_cursor, version)?; + let result = super::rmcp_resources_projection::serialize(result, extras, "resources")?; #[cfg(test)] super::dispatch_observer::sdk_resources_list_result_serialized(); - preserve_resource_fields( - &resources, - &mut result["resources"], - &[ - "uri", - "name", - "title", - "description", - "mimeType", - "size", - "_meta", - ], - ); Ok(result) } @@ -170,20 +146,10 @@ pub(super) fn resource_read_result( contents: Value, version: &str, ) -> Result { - let mut result = - rmcp::model::ReadResourceResult::new(serde_json::from_value(contents.clone())?); - let modern = version == crate::jsonrpc::MODERN_PROTOCOL_VERSION; - result.result_type = modern.then_some(ResultType::COMPLETE); - result.ttl_ms = modern.then_some(0); - result.cache_scope = modern.then_some(CacheScope::Private); - let mut result = serde_json::to_value(result)?; + let (result, extras) = super::rmcp_resources_projection::read(&contents, version)?; + let result = super::rmcp_resources_projection::serialize(result, extras, "contents")?; #[cfg(test)] super::dispatch_observer::sdk_resources_read_result_serialized(); - preserve_resource_fields( - contents.as_array().expect("validated contents array"), - &mut result["contents"], - &["uri", "mimeType", "text", "blob", "_meta"], - ); Ok(result) } @@ -192,34 +158,11 @@ pub(super) fn resource_templates_list_result( next_cursor: Option, version: &str, ) -> Result { - let modern = version == crate::jsonrpc::MODERN_PROTOCOL_VERSION; - let result = rmcp::model::ListResourceTemplatesResult { - resource_templates: templates - .iter() - .cloned() - .map(serde_json::from_value) - .collect::>()?, - next_cursor, - result_type: modern.then_some(ResultType::COMPLETE), - ttl_ms: modern.then_some(0), - cache_scope: modern.then_some(CacheScope::Private), - meta: None, - }; - let mut result = serde_json::to_value(result)?; + let (result, extras) = + super::rmcp_resources_projection::templates(&templates, next_cursor, version)?; + let result = super::rmcp_resources_projection::serialize(result, extras, "resourceTemplates")?; #[cfg(test)] super::dispatch_observer::sdk_resource_templates_list_result_serialized(); - preserve_resource_fields( - &templates, - &mut result["resourceTemplates"], - &[ - "uriTemplate", - "name", - "title", - "description", - "mimeType", - "_meta", - ], - ); Ok(result) } diff --git a/crates/crank-community-mcp/src/app/rmcp_dispatch.rs b/crates/crank-community-mcp/src/app/rmcp_dispatch.rs index 06fd69f..a931906 100644 --- a/crates/crank-community-mcp/src/app/rmcp_dispatch.rs +++ b/crates/crank-community-mcp/src/app/rmcp_dispatch.rs @@ -2,7 +2,7 @@ use std::sync::Arc; -use rmcp::model::{CallToolRequestParams, PaginatedRequestParams, ReadResourceRequestParams}; +use rmcp::model::{CallToolRequestParams, PaginatedRequestParams}; use serde_json::Value; use super::{AppState, lifecycle::ToolCallLifecycle}; @@ -101,31 +101,16 @@ pub(super) async fn handle_resources_command( revision: &str, command: crate::protocol::ResourcesCommand, ) -> crate::protocol::ResourcesOutcome { - use crate::protocol::{ResourceReadCommand, ResourcesCommand}; - let command = match command { - ResourcesCommand::List(list) => ResourcesCommand::List(sdk_resource_page(list)), - ResourcesCommand::Read(read) => { - let params = ReadResourceRequestParams::new(read.uri); - ResourcesCommand::Read(ResourceReadCommand { uri: params.uri }) - } - }; - #[cfg(test)] - super::dispatch_observer::sdk_resources_dispatch_enter(); - crate::protocol::handle_resources_command(state, context, revision, command).await + super::rmcp_resources::handle(state, context, revision, command).await } pub(super) async fn list_resource_templates( state: &Arc, - workspace_slug: &str, - agent_slug: &str, + context: ServiceContext<'_>, revision: &str, command: crate::protocol::ResourcesListCommand, ) -> Result<(Vec, Option), crate::protocol::ResourceTemplatesListError> { - let command = sdk_resource_page(command); - #[cfg(test)] - super::dispatch_observer::sdk_resources_dispatch_enter(); - crate::protocol::list_resource_templates(state, workspace_slug, agent_slug, revision, command) - .await + super::rmcp_resources::templates(state, context, revision, command).await } pub(super) async fn handle_completion_command( @@ -168,14 +153,3 @@ pub(super) async fn handle_completion_command( }; crate::protocol::handle_completion_command(state, context, revision, command).await } - -fn sdk_resource_page( - list: crate::protocol::ResourcesListCommand, -) -> crate::protocol::ResourcesListCommand { - let params = PaginatedRequestParams::default().with_cursor(list.cursor); - // Crank's page limit is not an SDK field; retain its existing validation and clamping. - crate::protocol::ResourcesListCommand { - cursor: params.cursor, - limit: list.limit, - } -} diff --git a/crates/crank-community-mcp/src/app/rmcp_resources.rs b/crates/crank-community-mcp/src/app/rmcp_resources.rs new file mode 100644 index 0000000..4954bb0 --- /dev/null +++ b/crates/crank-community-mcp/src/app/rmcp_resources.rs @@ -0,0 +1,423 @@ +//! Request-owned Resources trait adapter. Crank remains the only domain executor. +use std::sync::{Arc, Mutex}; + +use crank_core::{CorrelationContext, ExecutionLocale}; +use rmcp::{ErrorData, RoleServer, ServerHandler, model::*, service::RequestContext}; +use serde_json::Value; + +use super::{AppState, rmcp_resources_projection as projection}; +use crate::{ + auth::VerifiedMachineCredential, + protocol::{ + self, ContinuationSupport, ResourceReadCommand, ResourceTemplatesListError, + ResourcesCommand, ResourcesListCommand, ResourcesOutcome, ServiceContext, + }, +}; + +#[derive(Clone)] +struct ResourceScope { + workspace_slug: String, + agent_slug: String, + credential: VerifiedMachineCredential, + correlation: CorrelationContext, + continuation: ContinuationSupport, + locale: ExecutionLocale, + revision: String, + limit: Option, +} + +impl ResourceScope { + fn new(context: ServiceContext<'_>, revision: &str, limit: Option) -> Self { + Self { + workspace_slug: context.workspace_slug.to_owned(), + agent_slug: context.agent_slug.to_owned(), + credential: context.credential.clone(), + correlation: context.correlation.clone(), + continuation: context.continuation, + locale: context.locale, + revision: revision.to_owned(), + limit, + } + } + + fn context(&self) -> ServiceContext<'_> { + ServiceContext { + workspace_slug: &self.workspace_slug, + agent_slug: &self.agent_slug, + credential: &self.credential, + correlation: &self.correlation, + continuation: self.continuation, + locale: self.locale, + } + } +} + +enum ReplyExtras { + List(projection::Projection), + Read(projection::Projection), + Templates(projection::Projection), + DomainError(ResourcesOutcome), + TemplateError(ResourceTemplatesListError), +} + +#[derive(Clone)] +struct ResourceHandler { + state: Arc, + reply: Arc>>, + #[cfg(test)] + domain: Option>, +} + +fn internal() -> ErrorData { + ErrorData::internal_error("resource handler unavailable", None) +} + +impl ResourceHandler { + fn new(state: &Arc) -> Self { + Self { + state: state.clone(), + reply: Arc::new(Mutex::new(None)), + #[cfg(test)] + domain: None, + } + } + + async fn execute(&self, scope: &ResourceScope, command: ResourcesCommand) -> ResourcesOutcome { + #[cfg(test)] + if let Some(domain) = &self.domain { + return domain.resources(command).await; + } + protocol::handle_resources_command(&self.state, scope.context(), &scope.revision, command) + .await + } + + async fn execute_templates( + &self, + scope: &ResourceScope, + command: ResourcesListCommand, + ) -> Result<(Vec, Option), ResourceTemplatesListError> { + #[cfg(test)] + if let Some(domain) = &self.domain { + return domain.templates(command).await; + } + protocol::list_resource_templates( + &self.state, + &scope.workspace_slug, + &scope.agent_slug, + &scope.revision, + command, + ) + .await + } + + fn save(&self, extras: ReplyExtras) -> Result<(), ErrorData> { + let mut slot = self.reply.lock().map_err(|_| internal())?; + if slot.is_some() { + return Err(internal()); + } + *slot = Some(extras); + Ok(()) + } + + fn take(&self) -> Option { + self.reply.lock().ok()?.take() + } + + fn scope(context: &RequestContext) -> Result { + context + .extensions + .get::() + .cloned() + .ok_or_else(internal) + } + + fn domain_error(&self, outcome: ResourcesOutcome) -> ErrorData { + let error = match &outcome { + ResourcesOutcome::Listed { .. } | ResourcesOutcome::Read { .. } => return internal(), + ResourcesOutcome::InvalidParams(detail) => { + ErrorData::invalid_params(detail.clone(), None) + } + ResourcesOutcome::NotAvailable => { + ErrorData::invalid_params("the requested resource is not available", None) + } + _ => internal(), + }; + if self.save(ReplyExtras::DomainError(outcome)).is_err() { + return internal(); + } + error + } + + fn project_list( + &self, + outcome: ResourcesOutcome, + revision: &str, + ) -> Result { + match outcome { + ResourcesOutcome::Listed { + resources, + next_cursor, + } => { + let (result, extras) = + projection::list(&resources, next_cursor, revision).map_err(|_| internal())?; + self.save(ReplyExtras::List(extras))?; + Ok(result) + } + other => Err(self.domain_error(other)), + } + } + + fn project_read( + &self, + outcome: ResourcesOutcome, + revision: &str, + ) -> Result { + match outcome { + ResourcesOutcome::Read { contents } => { + let (result, extras) = + projection::read(&contents, revision).map_err(|_| internal())?; + self.save(ReplyExtras::Read(extras))?; + Ok(result.into()) + } + other => Err(self.domain_error(other)), + } + } + + fn project_templates( + &self, + outcome: Result<(Vec, Option), ResourceTemplatesListError>, + revision: &str, + ) -> Result { + match outcome { + Ok((templates, next_cursor)) => { + let (result, extras) = projection::templates(&templates, next_cursor, revision) + .map_err(|_| internal())?; + self.save(ReplyExtras::Templates(extras))?; + Ok(result) + } + Err(error) => { + let sdk_error = match error { + ResourceTemplatesListError::InvalidCursor => { + ErrorData::invalid_params("invalid resources/templates/list cursor", None) + } + ResourceTemplatesListError::Unavailable => internal(), + }; + self.save(ReplyExtras::TemplateError(error))?; + Err(sdk_error) + } + } + } +} + +impl ServerHandler for ResourceHandler { + async fn list_resources( + &self, + request: Option, + context: RequestContext, + ) -> Result { + let scope = Self::scope(&context)?; + let command = ResourcesCommand::List(ResourcesListCommand { + cursor: request.unwrap_or_default().cursor, + limit: scope.limit, + }); + let outcome = self.execute(&scope, command).await; + let result = self.project_list(outcome, &scope.revision); + #[cfg(test)] + super::dispatch_observer::sdk_resources_list_handler_completed(); + result + } + + async fn read_resource( + &self, + request: ReadResourceRequestParams, + context: RequestContext, + ) -> Result { + let scope = Self::scope(&context)?; + let command = ResourcesCommand::Read(ResourceReadCommand { uri: request.uri }); + let outcome = self.execute(&scope, command).await; + let result = self.project_read(outcome, &scope.revision); + #[cfg(test)] + super::dispatch_observer::sdk_resources_read_handler_completed(); + result + } + + async fn list_resource_templates( + &self, + request: Option, + context: RequestContext, + ) -> Result { + let scope = Self::scope(&context)?; + let command = ResourcesListCommand { + cursor: request.unwrap_or_default().cursor, + limit: scope.limit, + }; + let outcome = self.execute_templates(&scope, command).await; + let result = self.project_templates(outcome, &scope.revision); + #[cfg(test)] + super::dispatch_observer::sdk_resources_templates_handler_completed(); + result + } +} + +/// Public SDK Peer construction only; the inert seed service closes before domain execution. +/// shortcut: the closed Peer cannot send callbacks, revisit if Resources require peer messaging. +async fn request_context( + handler: &ResourceHandler, + scope: ResourceScope, +) -> Result, ErrorData> { + let ping = + serde_json::from_value(serde_json::json!({"jsonrpc":"2.0", "id":1, "method":"ping"})) + .map_err(|_| internal())?; + let (transport, receiver) = rmcp::transport::OneshotTransport::::new(ping); + let revision = + serde_json::from_value(Value::String(scope.revision.clone())).map_err(|_| internal())?; + let info = InitializeRequestParams::new( + ClientCapabilities::default(), + Implementation::new("crank-resource-context", "1"), + ) + .with_protocol_version(revision); + let mut running = rmcp::service::serve_directly(handler.clone(), transport, Some(info)); + let peer = running.peer().clone(); + running.close().await.map_err(|_| internal())?; + drop(receiver); + let mut context = RequestContext::new(RequestId::Number(1), peer); + context.extensions.insert(scope); + Ok(context) +} + +fn restore_list( + handler: &ResourceHandler, + result: Result, +) -> ResourcesOutcome { + match (result, handler.take()) { + (Ok(result), Some(ReplyExtras::List(extras))) => { + let cursor = result.next_cursor.clone(); + match projection::serialize(result, extras, "resources") { + Ok(mut result) => match result["resources"].take() { + Value::Array(resources) => ResourcesOutcome::Listed { + resources, + next_cursor: cursor, + }, + _ => ResourcesOutcome::CatalogUnavailable, + }, + Err(_) => ResourcesOutcome::CatalogUnavailable, + } + } + (Err(_), Some(ReplyExtras::DomainError(error))) => error, + _ => ResourcesOutcome::CatalogUnavailable, + } +} + +fn restore_read( + handler: &ResourceHandler, + result: Result, +) -> ResourcesOutcome { + match (result, handler.take()) { + (Ok(ReadResourceResponse::Complete(result)), Some(ReplyExtras::Read(extras))) => { + match projection::serialize(result, extras, "contents") { + Ok(mut result) => ResourcesOutcome::Read { + contents: result["contents"].take(), + }, + Err(_) => ResourcesOutcome::ArtifactUnavailable, + } + } + (Err(_), Some(ReplyExtras::DomainError(error))) => error, + _ => ResourcesOutcome::ArtifactUnavailable, + } +} + +fn restore_templates( + handler: &ResourceHandler, + result: Result, +) -> Result<(Vec, Option), ResourceTemplatesListError> { + match (result, handler.take()) { + (Ok(result), Some(ReplyExtras::Templates(extras))) => { + let cursor = result.next_cursor.clone(); + let mut result = projection::serialize(result, extras, "resourceTemplates") + .map_err(|_| ResourceTemplatesListError::Unavailable)?; + match result["resourceTemplates"].take() { + Value::Array(templates) => Ok((templates, cursor)), + _ => Err(ResourceTemplatesListError::Unavailable), + } + } + (Err(_), Some(ReplyExtras::TemplateError(error))) => Err(error), + _ => Err(ResourceTemplatesListError::Unavailable), + } +} + +pub(super) async fn handle( + state: &Arc, + context: ServiceContext<'_>, + revision: &str, + command: ResourcesCommand, +) -> ResourcesOutcome { + let limit = match &command { + ResourcesCommand::List(list) => list.limit, + _ => None, + }; + let handler = ResourceHandler::new(state); + let context = + match request_context(&handler, ResourceScope::new(context, revision, limit)).await { + Ok(context) => context, + Err(_) => return ResourcesOutcome::CatalogUnavailable, + }; + #[cfg(test)] + super::dispatch_observer::sdk_resources_dispatch_enter(); + match command { + ResourcesCommand::List(list) => { + let result = ServerHandler::list_resources( + &handler, + Some(PaginatedRequestParams::default().with_cursor(list.cursor)), + context, + ) + .await; + let outcome = restore_list(&handler, result); + #[cfg(test)] + super::dispatch_observer::sdk_resources_list_handler_consumed(); + outcome + } + ResourcesCommand::Read(read) => { + let result = ServerHandler::read_resource( + &handler, + ReadResourceRequestParams::new(read.uri), + context, + ) + .await; + let outcome = restore_read(&handler, result); + #[cfg(test)] + super::dispatch_observer::sdk_resources_read_handler_consumed(); + outcome + } + } +} + +pub(super) async fn templates( + state: &Arc, + context: ServiceContext<'_>, + revision: &str, + command: ResourcesListCommand, +) -> Result<(Vec, Option), ResourceTemplatesListError> { + let handler = ResourceHandler::new(state); + let context = request_context( + &handler, + ResourceScope::new(context, revision, command.limit), + ) + .await + .map_err(|_| ResourceTemplatesListError::Unavailable)?; + #[cfg(test)] + super::dispatch_observer::sdk_resources_dispatch_enter(); + let result = ServerHandler::list_resource_templates( + &handler, + Some(PaginatedRequestParams::default().with_cursor(command.cursor)), + context, + ) + .await; + let outcome = restore_templates(&handler, result); + #[cfg(test)] + super::dispatch_observer::sdk_resources_templates_handler_consumed(); + outcome +} + +#[cfg(test)] +#[path = "../rmcp_resources_handler_tests.rs"] +mod tests; diff --git a/crates/crank-community-mcp/src/app/rmcp_resources_projection.rs b/crates/crank-community-mcp/src/app/rmcp_resources_projection.rs new file mode 100644 index 0000000..8220502 --- /dev/null +++ b/crates/crank-community-mcp/src/app/rmcp_resources_projection.rs @@ -0,0 +1,148 @@ +//! Lossless Resource-only projection shared by the handler and existing wire builders. +use rmcp::model::{ + CacheScope, ListResourceTemplatesResult, ListResourcesResult, ReadResourceResult, ResultType, +}; +use serde::{Serialize, de::DeserializeOwned}; +use serde_json::{Map, Value}; + +pub(super) const RESOURCE_FIELDS: &[&str] = &[ + "uri", + "name", + "title", + "description", + "mimeType", + "size", + "_meta", +]; +pub(super) const TEMPLATE_FIELDS: &[&str] = &[ + "uriTemplate", + "name", + "title", + "description", + "mimeType", + "_meta", +]; +pub(super) const CONTENT_FIELDS: &[&str] = &["uri", "mimeType", "text", "blob", "_meta"]; + +/// Only unrepresentable fields plus order/identity witnesses, never a saved success response. +pub(super) struct Projection { + extras: Vec>, + identities: Vec>, +} + +fn invalid() -> serde_json::Error { + ::custom("invalid resource projection") +} + +impl Projection { + fn project( + raw: &[Value], + fields: &[&str], + ) -> Result<(Vec, Self), serde_json::Error> { + let mut extras = Vec::with_capacity(raw.len()); + let mut identities = Vec::with_capacity(raw.len()); + let mut typed = Vec::with_capacity(raw.len()); + for raw in raw { + let mut visible = raw.as_object().ok_or_else(invalid)?.clone(); + let extra = visible + .iter() + .filter(|(key, value)| !fields.contains(&key.as_str()) || value.is_null()) + .map(|(key, value)| (key.clone(), value.clone())) + .collect(); + let identity = visible + .iter() + .filter(|(key, _)| matches!(key.as_str(), "uri" | "uriTemplate" | "name")) + .map(|(key, value)| (key.clone(), value.clone())) + .collect(); + // Opaque descriptor JSON must not acquire SDK annotation/icon schema validation. + visible.remove("annotations"); + visible.remove("icons"); + typed.push(serde_json::from_value(Value::Object(visible))?); + extras.push(extra); + identities.push(identity); + } + Ok((typed, Self { extras, identities })) + } + + pub(super) fn restore(self, serialized: &mut Value) -> Result<(), serde_json::Error> { + let array = serialized.as_array_mut().ok_or_else(invalid)?; + if array.len() != self.extras.len() { + return Err(invalid()); + } + for ((item, extras), identity) in array.iter_mut().zip(self.extras).zip(self.identities) { + let item = item.as_object_mut().ok_or_else(invalid)?; + if identity + .iter() + .any(|(key, value)| item.get(key) != Some(value)) + { + return Err(invalid()); + } + item.extend(extras); + } + Ok(()) + } +} + +pub(super) fn list( + resources: &[Value], + next_cursor: Option, + version: &str, +) -> Result<(ListResourcesResult, Projection), serde_json::Error> { + let (resources, extras) = Projection::project(resources, RESOURCE_FIELDS)?; + let modern = version == crate::jsonrpc::MODERN_PROTOCOL_VERSION; + Ok(( + ListResourcesResult { + resources, + next_cursor, + result_type: modern.then_some(ResultType::COMPLETE), + ttl_ms: modern.then_some(0), + cache_scope: modern.then_some(CacheScope::Private), + meta: None, + }, + extras, + )) +} + +pub(super) fn templates( + templates: &[Value], + next_cursor: Option, + version: &str, +) -> Result<(ListResourceTemplatesResult, Projection), serde_json::Error> { + let (resource_templates, extras) = Projection::project(templates, TEMPLATE_FIELDS)?; + let modern = version == crate::jsonrpc::MODERN_PROTOCOL_VERSION; + Ok(( + ListResourceTemplatesResult { + resource_templates, + next_cursor, + result_type: modern.then_some(ResultType::COMPLETE), + ttl_ms: modern.then_some(0), + cache_scope: modern.then_some(CacheScope::Private), + meta: None, + }, + extras, + )) +} + +pub(super) fn read( + contents: &Value, + version: &str, +) -> Result<(ReadResourceResult, Projection), serde_json::Error> { + let (contents, extras) = + Projection::project(contents.as_array().ok_or_else(invalid)?, CONTENT_FIELDS)?; + let modern = version == crate::jsonrpc::MODERN_PROTOCOL_VERSION; + let mut result = ReadResourceResult::new(contents); + result.result_type = modern.then_some(ResultType::COMPLETE); + result.ttl_ms = modern.then_some(0); + result.cache_scope = modern.then_some(CacheScope::Private); + Ok((result, extras)) +} + +pub(super) fn serialize( + result: impl Serialize, + extras: Projection, + field: &str, +) -> Result { + let mut result = serde_json::to_value(result)?; + extras.restore(result.get_mut(field).ok_or_else(invalid)?)?; + Ok(result) +} diff --git a/crates/crank-community-mcp/src/rmcp_resources_handler_runtime_tests.rs b/crates/crank-community-mcp/src/rmcp_resources_handler_runtime_tests.rs new file mode 100644 index 0000000..cebc11a --- /dev/null +++ b/crates/crank-community-mcp/src/rmcp_resources_handler_runtime_tests.rs @@ -0,0 +1,125 @@ +//! Actual handler completion and Result consumption, separate from DTO serialization. +use super::{CounterSet, observe, rmcp_resources_runtime_tests::control, support::*}; +use std::sync::Arc; + +pub(super) async fn foreign_agent(registry: &crank_registry::PostgresRegistry) -> &'static str { + use crank_core::{Agent, AgentId, AgentStatus, AgentVersion, ToolSelectionPolicy}; + use crank_registry::{CreateAgentRequest, PublishAgentRequest}; + let id = AgentId::new("agent_resources_foreign"); + registry + .create_agent(CreateAgentRequest { + agent: &Agent { + id: id.clone(), + workspace_id: workspace_id(), + slug: "resources-foreign".to_owned(), + display_name: "Other published Agent".to_owned(), + description: String::new(), + status: AgentStatus::Draft, + current_draft_version: 1, + latest_published_version: None, + created_at: test_time(), + updated_at: test_time(), + published_at: None, + }, + version: &AgentVersion { + agent_id: id.clone(), + version: 1, + status: AgentStatus::Draft, + instructions: serde_json::json!({}), + tool_selection_policy: ToolSelectionPolicy::default(), + created_at: test_time(), + }, + bindings: &[], + }) + .await + .unwrap(); + registry + .publish_agent(PublishAgentRequest { + workspace_id: &workspace_id(), + agent_id: &id, + version: 1, + published_at: &test_time(), + published_by: Some("alice"), + expected_state: None, + }) + .await + .unwrap(); + "resources-foreign" +} + +pub(super) fn counts(c: &CounterSet) -> [usize; 6] { + [ + c.sdk_resources_list_handler_completed(), + c.sdk_resources_read_handler_completed(), + c.sdk_resources_templates_handler_completed(), + c.sdk_resources_list_handler_consumed(), + c.sdk_resources_read_handler_consumed(), + c.sdk_resources_templates_handler_consumed(), + ] +} + +pub(super) fn delta(c: &CounterSet, before: [usize; 6], method: &str) -> ([usize; 6], [usize; 6]) { + let after = counts(c); + let expected = match method { + "resources/list" => [1, 0, 0, 1, 0, 0], + "resources/read" => [0, 1, 0, 0, 1, 0], + "resources/templates/list" => [0, 0, 1, 0, 0, 1], + _ => panic!("not a Resources family: {method}"), + }; + (std::array::from_fn(|i| after[i] - before[i]), expected) +} + +#[tokio::test] +async fn rmcp_resources_handler_legacy() { + control(LEGACY_REVISION, true).await; +} + +#[tokio::test] +async fn rmcp_resources_handler_modern() { + control(MODERN_REVISION, true).await; +} + +#[tokio::test] +async fn rmcp_resources_handler_observer_positive_control() { + use super::{ + sdk_resources_list_handler_completed, sdk_resources_list_handler_consumed, + sdk_resources_read_handler_completed, sdk_resources_read_handler_consumed, + sdk_resources_templates_handler_completed, sdk_resources_templates_handler_consumed, + }; + let a = Arc::new(CounterSet::default()); + let b = Arc::new(CounterSet::default()); + sdk_resources_list_handler_completed(); + sdk_resources_read_handler_completed(); + sdk_resources_templates_handler_completed(); + sdk_resources_list_handler_consumed(); + sdk_resources_read_handler_consumed(); + sdk_resources_templates_handler_consumed(); + assert_eq!(counts(&a), [0; 6], "no-scope markers must be no-ops"); + let snapshot = a.snapshot(); + tokio::join!( + observe(a.clone(), async { + sdk_resources_list_handler_completed(); + tokio::task::yield_now().await; + sdk_resources_read_handler_completed(); + sdk_resources_templates_handler_completed(); + sdk_resources_list_handler_consumed(); + sdk_resources_read_handler_consumed(); + sdk_resources_templates_handler_consumed(); + }), + observe(b.clone(), async { + sdk_resources_read_handler_completed(); + tokio::task::yield_now().await; + sdk_resources_read_handler_consumed(); + }), + ); + assert_eq!(counts(&a), [1; 6]); + assert_eq!(counts(&b), [0, 1, 0, 0, 1, 0]); + assert_eq!(a.snapshot(), snapshot); + assert_eq!(b.snapshot(), CounterSet::default().snapshot()); + for c in [&a, &b] { + assert_eq!(c.sdk_resources_dispatch(), 0); + assert_eq!(c.sdk_resources_list_result(), 0); + assert_eq!(c.sdk_resources_read_result(), 0); + assert_eq!(c.sdk_resource_templates_list_result(), 0); + } +} diff --git a/crates/crank-community-mcp/src/rmcp_resources_handler_tests.rs b/crates/crank-community-mcp/src/rmcp_resources_handler_tests.rs new file mode 100644 index 0000000..9503254 --- /dev/null +++ b/crates/crank-community-mcp/src/rmcp_resources_handler_tests.rs @@ -0,0 +1,328 @@ +//! Synthetic domain replies exercise the real trait/restore path, not wire producer coverage. +use super::*; +use serde_json::json; +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst}; + +type TemplateReply = Result<(Vec, Option), ResourceTemplatesListError>; + +#[derive(Default)] +pub(super) struct Domain { + outcome: Mutex>, + templates: Mutex>, + calls: AtomicUsize, + pending: bool, + started: tokio::sync::Notify, + release: tokio::sync::Notify, + dropped: AtomicBool, + finished: AtomicBool, +} +struct DropWitness<'a>(&'a AtomicBool); +impl Drop for DropWitness<'_> { + fn drop(&mut self) { + self.0.store(true, SeqCst); + } +} +impl Domain { + pub(super) async fn resources(&self, command: ResourcesCommand) -> ResourcesOutcome { + self.calls.fetch_add(1, SeqCst); + match command { + ResourcesCommand::List(list) => { + assert_eq!(list.limit, Some(7)); + assert_eq!(list.cursor.as_deref(), Some("opaque")); + } + ResourcesCommand::Read(read) => assert_eq!(read.uri, "crank://read"), + } + let _guard = DropWitness(&self.dropped); + if self.pending { + self.started.notify_one(); + self.release.notified().await; + } + self.finished.store(true, SeqCst); + self.outcome + .lock() + .unwrap() + .take() + .expect("exactly one domain execution") + } + pub(super) async fn templates( + &self, + command: ResourcesListCommand, + ) -> Result<(Vec, Option), ResourceTemplatesListError> { + self.calls.fetch_add(1, SeqCst); + assert_eq!(command.limit, Some(7)); + assert_eq!(command.cursor.as_deref(), Some("opaque")); + self.templates + .lock() + .unwrap() + .take() + .expect("exactly one template execution") + } +} +fn scope(revision: &str) -> ResourceScope { + ResourceScope { + workspace_slug: "fresh-workspace".into(), + agent_slug: "fresh-agent".into(), + credential: VerifiedMachineCredential { + machine_access_mode: crank_core::MachineAccessMode::StaticAgentKey, + max_security_level: crank_core::OperationSecurityLevel::Standard, + scopes: vec![crank_core::PlatformApiKeyScope::Read], + platform_api_key_id: Some("fresh-key".into()), + }, + correlation: CorrelationContext::generate(), + continuation: ContinuationSupport::from_supported(false), + locale: ExecutionLocale::En, + revision: revision.into(), + limit: Some(7), + } +} +async fn state() -> Arc { + crank_test_support::postgres_schema_url_for_task("resources_handler_local", "t_b2b08b44").await; + super::super::rmcp_tools_tests::test_state().await +} +fn handler(state: &Arc, outcome: ResourcesOutcome) -> ResourceHandler { + let mut handler = ResourceHandler::new(state); + handler.domain = Some(Arc::new(Domain { + outcome: Mutex::new(Some(outcome)), + ..Default::default() + })); + handler +} +fn page() -> Option { + Some(PaginatedRequestParams::default().with_cursor(Some("opaque".into()))) +} +async fn context(handler: &ResourceHandler, revision: &str) -> RequestContext { + let context = request_context(handler, scope(revision)).await.unwrap(); + // Closed Peer and released seed handler ownership independently witness bootstrap cleanup. + assert!(context.peer.is_transport_closed()); + assert_eq!(Arc::strong_count(&handler.reply), 1); + assert_eq!(handler.domain.as_ref().unwrap().calls.load(SeqCst), 0); + assert_eq!( + ResourceHandler::scope(&context) + .unwrap() + .credential + .platform_api_key_id + .as_ref() + .map(|id| id.as_str()), + Some("fresh-key") + ); + context +} + +#[tokio::test] +async fn rmcp_resources_trait_lossless_populated_results() { + let state = state().await; + for revision in ["2025-11-25", "2026-07-28"] { + let raw = vec![ + json!({"uri":"crank://a", "name":"a", "description":null, "annotations":{"arbitrary":[null,{"nested":true}]}, "icons":{"not":"an SDK icon array"}, "x": [1,null]}), + json!({"uri":"crank://b","name":"b"}), + ]; + let h = handler( + &state, + ResourcesOutcome::Listed { + resources: raw.clone(), + next_cursor: Some("next".into()), + }, + ); + let c = context(&h, revision).await; + let mut result = ServerHandler::list_resources(&h, page(), c).await.unwrap(); + // Mutating a known field demonstrates the actual typed result is consumed, not old success. + result.resources[0].title = Some("from-sdk-result".into()); + result.next_cursor = Some("typed-cursor".into()); + match restore_list(&h, Ok(result)) { + ResourcesOutcome::Listed { + resources, + next_cursor, + } => { + let mut expected = raw; + expected[0]["title"] = json!("from-sdk-result"); + assert_eq!(resources, expected); + assert_eq!(next_cursor.as_deref(), Some("typed-cursor")); + } + _ => panic!("list restore failed"), + } + assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1); + let text = serde_json::to_string_pretty(&json!({"exact":true})).unwrap(); + let raw = json!([{"uri":"crank://text", "text":text, "mimeType":null, "annotations": [null,42], "x":null}, {"uri":"crank://blob", "blob":"AAEC/w==", "icons":false}]); + let h = handler( + &state, + ResourcesOutcome::Read { + contents: raw.clone(), + }, + ); + let c = context(&h, revision).await; + let result = + ServerHandler::read_resource(&h, ReadResourceRequestParams::new("crank://read"), c) + .await; + match restore_read(&h, result) { + ResourcesOutcome::Read { contents } => assert_eq!(contents, raw), + _ => panic!("read restore failed"), + } + let raw = vec![ + json!({"uriTemplate":"crank://{id}", "name":"template", "parameters":{"id":{"type":"string","default":null}}, "annotations":false, "icons":[{"unknown":null}], "description":null, "x":{"nested":[null]}}), + ]; + let mut h = ResourceHandler::new(&state); + h.domain = Some(Arc::new(Domain { + templates: Mutex::new(Some(Ok((raw.clone(), Some("next".into()))))), + ..Default::default() + })); + let c = context(&h, revision).await; + let result = ServerHandler::list_resource_templates(&h, page(), c).await; + let (actual, cursor) = restore_templates(&h, result).ok().unwrap(); + assert_eq!(actual, raw); + assert_eq!(cursor.as_deref(), Some("next")); + assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1); + } +} + +#[tokio::test] +async fn rmcp_resources_trait_errors_and_broken_projection_fail_closed() { + let state = state().await; + let contract = crate::tool_error::control_tool_error_contract( + crate::tool_error::McpControlError::CatalogRevisionChanged, + "request", + "trace", + ExecutionLocale::En, + ); + for outcome in [ + ResourcesOutcome::InvalidParams("exact detail".into()), + ResourcesOutcome::NotAvailable, + ResourcesOutcome::CatalogUnavailable, + ResourcesOutcome::ArtifactUnavailable, + ResourcesOutcome::ExecutionError(contract.clone()), + ] { + let expected = std::mem::discriminant(&outcome); + let h = handler(&state, outcome); + let c = context(&h, "2026-07-28").await; + let result = + ServerHandler::read_resource(&h, ReadResourceRequestParams::new("crank://read"), c) + .await; + assert!(result.is_err()); + let actual = restore_read(&h, result); + assert_eq!(std::mem::discriminant(&actual), expected); + match actual { + ResourcesOutcome::ExecutionError(actual) => assert_eq!(actual, contract), + ResourcesOutcome::InvalidParams(detail) => assert_eq!(detail, "exact detail"), + _ => {} + } + assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1); + } + for error in [ + ResourceTemplatesListError::InvalidCursor, + ResourceTemplatesListError::Unavailable, + ] { + let expected = std::mem::discriminant(&error); + let mut h = ResourceHandler::new(&state); + h.domain = Some(Arc::new(Domain { + templates: Mutex::new(Some(Err(error))), + ..Default::default() + })); + let c = context(&h, "2026-07-28").await; + let result = ServerHandler::list_resource_templates(&h, page(), c).await; + assert!(result.is_err()); + assert_eq!( + std::mem::discriminant(&restore_templates(&h, result).err().unwrap()), + expected + ); + } + let h = handler( + &state, + ResourcesOutcome::Listed { + resources: vec![json!({"name":"missing-required-uri"})], + next_cursor: None, + }, + ); + let c = context(&h, "2026-07-28").await; + let result = ServerHandler::list_resources(&h, page(), c).await; + assert!(result.is_err()); + assert!(matches!( + restore_list(&h, result), + ResourcesOutcome::CatalogUnavailable + )); + assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1); + let h = handler( + &state, + ResourcesOutcome::Listed { + resources: vec![json!({"uri":"crank://a","name":"a"})], + next_cursor: None, + }, + ); + let mut c = context(&h, "2026-07-28").await; + c.extensions = Default::default(); + assert!(ServerHandler::list_resources(&h, page(), c).await.is_err()); + assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 0); + let c = context(&h, "2026-07-28").await; + let mut result = ServerHandler::list_resources(&h, page(), c).await.unwrap(); + result.resources.clear(); + assert!(matches!( + restore_list(&h, Ok(result)), + ResourcesOutcome::CatalogUnavailable + )); + // An impossible domain variant or unpaired SDK Err cannot become a saved success. + let h = handler( + &state, + ResourcesOutcome::Read { + contents: json!([]), + }, + ); + let c = context(&h, "2026-07-28").await; + let result = ServerHandler::list_resources(&h, page(), c).await; + assert!(result.is_err()); + assert!(matches!( + restore_list(&h, result), + ResourcesOutcome::CatalogUnavailable + )); + assert!(matches!( + restore_read(&h, Err(internal())), + ResourcesOutcome::ArtifactUnavailable + )); + let h = handler( + &state, + ResourcesOutcome::Listed { + resources: vec![ + json!({"uri":"crank://a","name":"a","x":1}), + json!({"uri":"crank://b","name":"b","x":2}), + ], + next_cursor: None, + }, + ); + let c = context(&h, "2026-07-28").await; + let mut result = ServerHandler::list_resources(&h, page(), c).await.unwrap(); + result.resources.swap(0, 1); + assert!(matches!( + restore_list(&h, Ok(result)), + ResourcesOutcome::CatalogUnavailable + )); +} + +#[tokio::test] +async fn rmcp_resources_parent_drop_releases_domain_future_without_detached_execution() { + let state = state().await; + let mut h = ResourceHandler::new(&state); + let domain = Arc::new(Domain { + pending: true, + ..Default::default() + }); + h.domain = Some(domain.clone()); + let c = context(&h, "2026-07-28").await; + let mut parent = Box::pin(ServerHandler::read_resource( + &h, + ReadResourceRequestParams::new("crank://read"), + c, + )); + tokio::select! { _ = &mut parent => panic!("domain should be waiting"), _ = domain.started.notified() => {} } + assert!(!domain.dropped.load(SeqCst)); + drop(parent); + assert!( + domain.dropped.load(SeqCst), + "owned domain future must be dropped synchronously" + ); + domain.release.notify_one(); + tokio::task::yield_now().await; + assert!( + !domain.finished.load(SeqCst), + "no detached future may resume execution" + ); + assert!(h.take().is_none()); + assert_eq!(domain.calls.load(SeqCst), 1); + assert_eq!(Arc::strong_count(&domain), 2); +} diff --git a/crates/crank-community-mcp/src/rmcp_resources_runtime_tests.rs b/crates/crank-community-mcp/src/rmcp_resources_runtime_tests.rs index 94a1d39..d2d959b 100644 --- a/crates/crank-community-mcp/src/rmcp_resources_runtime_tests.rs +++ b/crates/crank-community-mcp/src/rmcp_resources_runtime_tests.rs @@ -1,4 +1,4 @@ -//! #107 Resources: existing wire GREEN is independent of the missing SDK typed-path oracle. +//! #107 Resources: wire GREEN is independent of actual ServerHandler execution. use super::{CounterSet, observe, support::*}; use axum::{body::Body, response::Response}; use futures_util::{StreamExt, stream}; @@ -8,6 +8,8 @@ use std::{sync::Arc, time::Duration}; mod fixtures; use fixtures::{Endpoint, TEXT, URI}; +use super::rmcp_resources_handler_runtime_tests as handler; + // As in rmcp_result_runtime_tests: deferred body polling keeps this request's observer. fn observe_body(response: Response, counters: Arc) -> Response { let (parts, body) = response.into_parts(); @@ -113,11 +115,16 @@ async fn success( std::array::from_fn(|i| after[i] - before[i]), ) } -async fn control(revision: &str) -> Vec<([usize; 4], [usize; 4])> { - let h = Endpoint::started().await; +pub(super) async fn control( + revision: &str, + require_handler: bool, +) -> Vec<([usize; 4], [usize; 4])> { + crank_test_support::postgres_schema_url_for_task("resources_handler", "t_48a39ca6").await; + let mut h = Endpoint::started().await; let session = h.session(revision).await; let session = session.as_deref(); let mut deltas = Vec::new(); + let mut handlers = Vec::new(); // Preference order negotiates JSON or terminal SSE in both Resources revisions. for sse in [false, true] { let mut cursor = None; @@ -127,8 +134,10 @@ async fn control(revision: &str) -> Vec<([usize; 4], [usize; 4])> { if let Some(ref cursor) = cursor { params["cursor"] = json!(cursor); } + let before = handler::counts(&h.counters); let (result, delta) = success(&h, revision, session, "resources/list", params, sse).await; + handlers.push(handler::delta(&h.counters, before, "resources/list")); let resources = result["resources"].as_array().unwrap(); assert_eq!(resources.len(), 1, "{result}"); let item = &resources[0]; @@ -155,6 +164,7 @@ async fn control(revision: &str) -> Vec<([usize; 4], [usize; 4])> { (json!("sdk_b"), json!("crank://resources/sdk-b")) ] ); + let before = handler::counts(&h.counters); let (result, delta) = success( &h, revision, @@ -168,7 +178,9 @@ async fn control(revision: &str) -> Vec<([usize; 4], [usize; 4])> { result["contents"], json!([{"uri":URI,"mimeType":"text/plain","text":TEXT}]) ); + handlers.push(handler::delta(&h.counters, before, "resources/read")); deltas.push((delta, [1, 0, 1, 0])); + let before = handler::counts(&h.counters); let (result, delta) = success( &h, revision, @@ -180,6 +192,11 @@ async fn control(revision: &str) -> Vec<([usize; 4], [usize; 4])> { .await; assert_eq!(result["resourceTemplates"], json!([])); assert!(result.get("nextCursor").is_none()); + handlers.push(handler::delta( + &h.counters, + before, + "resources/templates/list", + )); deltas.push((delta, [1, 0, 0, 1])); } // Malformed parameters/cursors and indistinguishable unavailable URIs remain command errors. @@ -188,8 +205,13 @@ async fn control(revision: &str) -> Vec<([usize; 4], [usize; 4])> { ("resources/list", json!({"limit":"invalid"})), ("resources/templates/list", json!({"cursor":"invalid"})), ("resources/templates/list", json!({"limit":"invalid"})), + ("resources/read", json!({"uri":42})), + ("resources/read", json!({})), ("resources/read", json!({"uri":"crank://resources/unbound"})), ] { + let before = handler::counts(&h.counters); + let parsing_reject = params.get("limit").is_some() + || (method == "resources/read" && !params["uri"].is_string()); let req = request(revision, method, params); let body = wire( h.post(revision, session, &req, false).await, @@ -198,8 +220,66 @@ async fn control(revision: &str) -> Vec<([usize; 4], [usize; 4])> { ) .await; assert_eq!(body["error"]["code"], -32602, "{body}"); + let expected_message = if parsing_reject { + format!("invalid {method} parameters") + } else if method == "resources/read" { + "the requested resource is not available".to_owned() + } else { + format!("invalid {method} cursor") + }; + assert_eq!(body["error"]["message"], expected_message, "{body}"); assert!(body.get("result").is_none(), "{body}"); + if parsing_reject { + assert_eq!( + handler::counts(&h.counters), + before, + "parsing reject: {req}" + ); + } else { + handlers.push(handler::delta(&h.counters, before, method)); + } } + // Fresh scope and Agent binding are checked even after a successful handshake/read. + let foreign_slug = handler::foreign_agent(&h.registry).await; + let original_url = h.url.clone(); + h.url = format!( + "{}/{foreign_slug}", + original_url.rsplit_once('/').unwrap().0 + ); + for method in [ + "resources/list", + "resources/read", + "resources/templates/list", + ] { + let before = handler::counts(&h.counters); + let req = request(revision, method, json!({"uri":URI})); + // Agent-bound credential lookup intentionally does not reveal the other Agent. + assert_eq!(h.post(revision, session, &req, false).await.status(), 401); + assert_eq!(handler::counts(&h.counters), before, "cross-agent: {req}"); + } + h.url = original_url; + sqlx::query( + "update platform_api_keys set scopes_json = '[]'::jsonb where id = 'pk_dispatch_observer'", + ) + .execute(h.registry.pool()) + .await + .unwrap(); + for method in [ + "resources/list", + "resources/read", + "resources/templates/list", + ] { + let before = handler::counts(&h.counters); + let req = request(revision, method, json!({"uri":URI})); + assert_eq!(h.post(revision, session, &req, false).await.status(), 403); + assert_eq!( + handler::counts(&h.counters), + before, + "read scope required: {req}" + ); + } + sqlx::query("update platform_api_keys set scopes_json = '[\"read\",\"write\"]'::jsonb where id = 'pk_dispatch_observer'") + .execute(h.registry.pool()).await.unwrap(); // An existing session does not preserve revoked authorization. h.registry .revoke_platform_api_key( @@ -215,24 +295,35 @@ async fn control(revision: &str) -> Vec<([usize; 4], [usize; 4])> { ("resources/templates/list", json!({})), ] { let req = request(revision, method, params); + let before = handler::counts(&h.counters); assert_eq!(h.post(revision, session, &req, false).await.status(), 401); + assert_eq!(handler::counts(&h.counters), before, "revoked: {req}"); } eprintln!( "existing GREEN Resources wire {revision}: pagination, exact content URI/bytes, empty templates, JSON/SSE negotiation, InvalidParams, revoked401; actual/expected SDK deltas={deltas:?}" ); + eprintln!( + "Resources handler {revision}: completed[list,read,templates], consumed[list,read,templates]; actual/expected per admitted request={handlers:?}; parsing/revoked guards=0" + ); + if require_handler { + assert!( + handlers.iter().all(|(actual, expected)| actual == expected), + "ServerHandler completion/Result consumption missing after successful HTTP wire/error/guard checks ({revision}): {handlers:?}" + ); + } deltas } #[tokio::test] async fn rmcp_resources_wire_legacy() { - control(LEGACY_REVISION).await; + control(LEGACY_REVISION, false).await; } #[tokio::test] async fn rmcp_resources_wire_modern() { - control(MODERN_REVISION).await; + control(MODERN_REVISION, false).await; } #[tokio::test] async fn rmcp_resources_sdk_legacy() { - let deltas = control(LEGACY_REVISION).await; + let deltas = control(LEGACY_REVISION, false).await; assert!( deltas.iter().all(|(actual, expected)| actual == expected), "SDK typed dispatch/result missing after successful HTTP: {deltas:?}" @@ -240,7 +331,7 @@ async fn rmcp_resources_sdk_legacy() { } #[tokio::test] async fn rmcp_resources_sdk_modern() { - let deltas = control(MODERN_REVISION).await; + let deltas = control(MODERN_REVISION, false).await; assert!( deltas.iter().all(|(actual, expected)| actual == expected), "SDK typed dispatch/result missing after successful HTTP: {deltas:?}"