Compare commits

...
Author SHA1 Message Date
bsodfather 986cd78b96 Merge pull request 'MCP: execute negotiation and ping through SDK handlers' (#140) from delivery/rmcp107-negotiation-handlers into main
CI / UI Checks (push) Successful in 10s
CI / Rust Checks (push) Successful in 1h1m4s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 2s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 1h29m23s
2026-11-13 21:19:48 +00:00
bsodfather bcdf57074b MCP: execute negotiation and ping through SDK handlers
CI / UI Checks (pull_request) Successful in 12s
CI / Rust Checks (pull_request) Successful in 49m59s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 2s
CI / Deploy (pull_request) Skipped
2026-11-13 20:27:41 +00:00
bsodfather b39e4a3470 Merge pull request 'MCP: execute Tools through request-scoped SDK handlers' (#139) from delivery/rmcp107-tools into main
CI / UI Checks (push) Successful in 10s
CI / Rust Checks (push) Successful in 44m4s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 1h1m38s
2026-11-13 17:37:31 +00:00
bsodfather 3b30aad28e MCP: execute Tools through request-scoped SDK handlers
CI / UI Checks (pull_request) Successful in 8s
CI / Rust Checks (pull_request) Successful in 35m42s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
CI / Deploy (pull_request) Skipped
2026-11-13 16:57:28 +00:00
bsodfather 5611e81579 Merge pull request 'MCP: execute completion through request-scoped SDK handler' (#138) from delivery/rmcp107-completion-handler into main
CI / UI Checks (push) Successful in 14s
CI / Rust Checks (push) Successful in 58m31s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 1h23m37s
2026-11-13 14:12:04 +00:00
bsodfather b769a2ed2e feat(mcp): execute completion through request-scoped SDK handler
CI / UI Checks (pull_request) Successful in 11s
CI / Rust Checks (pull_request) Successful in 40m11s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
CI / Deploy (pull_request) Skipped
2026-11-13 13:28:36 +00:00
bsodfather 0139eeaac6 Merge pull request 'MCP: execute Prompts through request-scoped SDK handlers' (#137) from delivery/rmcp107-prompts-handlers into main
CI / UI Checks (push) Successful in 9s
CI / Rust Checks (push) Successful in 54m59s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 2s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 1h24m37s
2026-11-13 08:11:47 +00:00
bsodfather 5cce1b09df feat(mcp): execute Prompts through request-scoped SDK handlers
CI / UI Checks (pull_request) Successful in 14s
CI / Rust Checks (pull_request) Successful in 37m47s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
CI / Deploy (pull_request) Skipped
2026-11-13 07:30:32 +00:00
bsodfather 5b0af84d5a Merge pull request 'MCP: execute Resources through request-scoped SDK handlers' (#136) from delivery/rmcp107-resource-handlers into main
CI / UI Checks (push) Successful in 8s
CI / Rust Checks (push) Successful in 38m5s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 58m42s
2026-11-13 04:55:00 +00:00
bsodfather 9b3e0248d1 MCP: execute Resources through request-scoped SDK handlers
CI / UI Checks (pull_request) Successful in 8s
CI / Rust Checks (pull_request) Successful in 37m50s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 2s
CI / Deploy (pull_request) Skipped
2026-11-13 04:14:34 +00:00
bsodfather 163b519979 Merge pull request 'MCP: SDK inbound responses with authorization before ACK' (#135) from delivery/rmcp107-responses into main
CI / UI Checks (push) Successful in 8s
CI / Rust Checks (push) Successful in 36m24s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 57m11s
2026-11-13 01:22:04 +00:00
bsodfather 65144fd8c6 MCP: classify inbound responses through SDK with fresh authorization
CI / UI Checks (pull_request) Successful in 10s
CI / Rust Checks (pull_request) Successful in 37m3s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
CI / Deploy (pull_request) Skipped
2026-11-13 00:41:28 +00:00
bsodfather 66bb135398 Merge pull request 'MCP: dispatch requests and notifications through SDK envelopes' (#134) from delivery/rmcp107-dispatch into main
CI / UI Checks (push) Successful in 9s
CI / Rust Checks (push) Successful in 46m33s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 2s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 1h6m32s
2026-11-12 22:34:08 +00:00
bsodfather 7a1fc0d761 Merge pull request 'MCP: consume SDK initialized notification in legacy handshake' (#133) from delivery/rmcp107-initialized into main
CI / UI Checks (push) Successful in 12s
CI / Rust Checks (push) Successful in 43m14s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 1h2m47s
2026-11-12 19:42:10 +00:00
bsodfather a4cf5ed8cf Merge pull request 'MCP: route runtime ping through rmcp while preserving wire compatibility' (#132) from delivery/rmcp107-ping into main
CI / UI Checks (push) Successful in 11s
CI / Rust Checks (push) Successful in 38m9s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 1h0m14s
2026-11-12 17:00:53 +00:00
bsodfather c32e24b268 Merge pull request 'MCP: SDK legacy initialize input with preserved session contract' (#131) from delivery/rmcp107-initialize-input into main
CI / UI Checks (push) Successful in 11s
CI / Rust Checks (push) Successful in 31m54s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 50m50s
2026-11-12 14:15:26 +00:00
bsodfather ca126004af Merge pull request 'MCP: SDK initialize/discover results with preserved wire contract' (#130) from delivery/rmcp107-negotiation into main
CI / UI Checks (push) Successful in 11s
CI / Rust Checks (push) Successful in 31m2s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 51m44s
2026-11-12 11:20:52 +00:00
39 changed files with 4874 additions and 603 deletions

No files matched your search

+8
View File
@@ -34,17 +34,25 @@ pub(crate) mod lifecycle;
mod metrics;
mod request;
mod response;
mod rmcp_completion;
mod rmcp_dispatch;
#[cfg(test)]
mod rmcp_http;
#[cfg(test)]
#[path = "rmcp_http_tests.rs"]
mod rmcp_http_tests;
mod rmcp_negotiation;
mod rmcp_progress_cancel;
mod rmcp_prompts;
mod rmcp_prompts_projection;
mod rmcp_resources;
mod rmcp_resources_projection;
#[cfg(test)]
mod rmcp_session_tests;
#[cfg(test)]
mod rmcp_tools;
mod rmcp_tools_projection;
mod rmcp_tools_runtime;
#[cfg(test)]
#[path = "rmcp_tools_tests.rs"]
mod rmcp_tools_tests;
+56 -63
View File
@@ -17,8 +17,8 @@ use crate::{
CompletionCommand, CompletionOutcome, ContinuationSupport, DispatchDecision, MethodHandler,
PromptGetCommand, PromptsCommand, PromptsListCommand, PromptsOutcome, RequestIdentity,
ResourceReadCommand, ResourcesCommand, ResourcesListCommand, ResourcesOutcome,
ServiceContext, ToolCallCommand, ToolsCommand, ToolsListCommand, ToolsOutcome,
declared_mcp_method, discover_result, validate_modern_request_name,
ServiceContext, ToolCallCommand, ToolsCommand, ToolsListCommand, declared_mcp_method,
validate_modern_request_name,
},
session::SessionState,
tool_error::execution_locale,
@@ -38,12 +38,10 @@ use time::OffsetDateTime;
use super::response::{
completion_result, internal_jsonrpc_error, prompt_arguments_error_response, prompt_get_result,
prompts_list_result, resource_error_response, resource_read_result,
resource_templates_list_result, resources_list_result, tools_list_result,
resource_templates_list_result, resources_list_result,
};
use super::{AgentRoutePath, AppState, TRANSPORT_SESSION_TTL_MS};
use crate::protocol::ResourceTemplatesListError;
const SERVER_NAME: &str = "crank-mcp-server";
const SERVER_VERSION: &str = env!("CARGO_PKG_VERSION");
/// Serve a request of the modern stateless era.
/// No session is created, read or required; identity comes from the per-request `_meta` metadata that
@@ -111,32 +109,43 @@ pub(super) async fn handle_modern_request(
DispatchDecision::Allowed {
handler: MethodHandler::Discover,
..
} => transport_response(
StatusCode::OK,
jsonrpc_result(
request_id(message),
discover_result(version, SERVER_NAME, SERVER_VERSION),
),
response_mode,
None,
Some(version),
),
} => {
let result = match super::rmcp_negotiation::discover(version).await {
Ok(result) => result,
Err(error) => return sdk_error_response(message, response_mode, version, error),
};
transport_response(
StatusCode::OK,
jsonrpc_result(
request_id(message),
crate::protocol::project_modern_cacheable_result(version, result),
),
response_mode,
None,
Some(version),
)
}
DispatchDecision::Allowed {
handler: MethodHandler::Ping,
..
} => transport_response(
StatusCode::OK,
jsonrpc_result(
request_id(message),
crate::protocol::project_modern_result(
version,
crate::protocol::ping_result(&json!({"method": "ping"}), version),
} => {
if let Err(error) = super::rmcp_negotiation::ping().await {
return sdk_error_response(message, response_mode, version, error);
}
transport_response(
StatusCode::OK,
jsonrpc_result(
request_id(message),
crate::protocol::project_modern_result(
version,
json!({"protocolVersion": version}),
),
),
),
response_mode,
None,
Some(version),
),
response_mode,
None,
Some(version),
)
}
DispatchDecision::Allowed {
handler: MethodHandler::ToolList,
..
@@ -170,36 +179,7 @@ pub(super) async fn handle_modern_request(
None,
)
.await;
match outcome {
ToolsOutcome::List { tools, next_cursor } => {
match tools_list_result(tools, next_cursor, version) {
Ok(result) => transport_response(
StatusCode::OK,
jsonrpc_result(request_id(message), result),
response_mode,
None,
Some(version),
),
Err(error) => internal_jsonrpc_error(message, error),
}
}
ToolsOutcome::InvalidParams(message_text) => transport_response(
StatusCode::OK,
jsonrpc_error(request_id(message), -32602, message_text),
response_mode,
None,
Some(version),
),
ToolsOutcome::CatalogUnavailable => {
internal_jsonrpc_error(message, "published catalog is unavailable")
}
// A list command never produces a call outcome; it is answered with the adapter's
// internal error instead of being silently ignored.
ToolsOutcome::Call(_) => internal_jsonrpc_error(
message,
"unexpected shared tools outcome for a tools/list",
),
}
super::response::sdk_tools_response(message, response_mode, version, outcome)
}
DispatchDecision::Allowed {
handler: MethodHandler::ToolCall,
@@ -415,8 +395,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,
)
@@ -762,6 +741,19 @@ pub(super) async fn handle_modern_request(
}
}
pub(super) fn sdk_error_response(
message: &Value,
mode: ResponseMode,
revision: &str,
error: rmcp::ErrorData,
) -> Response {
let mut envelope = jsonrpc_error(request_id(message), i64::from(error.code.0), error.message);
if let Some(data) = error.data {
envelope["error"]["data"] = data;
}
transport_response(StatusCode::OK, envelope, mode, None, Some(revision))
}
/// The verified, era-neutral context of a Resource command: the same workspace/Agent/credential/
/// correlation the Tools service receives.
fn resource_service_context<'a>(
@@ -821,6 +813,10 @@ pub(super) async fn handle_initialize(
None,
);
};
let initialize_result = match super::rmcp_negotiation::initialize(protocol_version).await {
Ok(result) => result,
Err(error) => return sdk_error_response(message, response_mode, protocol_version, error),
};
let now = OffsetDateTime::now_utc();
let expires_at = add_millis(now, TRANSPORT_SESSION_TTL_MS);
let supports_elicitation = raw_params
@@ -846,10 +842,7 @@ pub(super) async fn handle_initialize(
transport_response(
StatusCode::OK,
jsonrpc_result(
request_id(message),
crate::protocol::initialize_result(protocol_version, SERVER_NAME, SERVER_VERSION),
),
jsonrpc_result(request_id(message), initialize_result),
response_mode,
Some(&session_id),
Some(protocol_version),
@@ -54,15 +54,31 @@ pub(crate) struct CounterSet {
sdk_tools_dispatch: AtomicUsize,
sdk_tools_list_result: AtomicUsize,
sdk_tools_call_result: AtomicUsize,
sdk_tools_list_handler_completed: AtomicUsize,
sdk_tools_list_handler_consumed: AtomicUsize,
sdk_tools_call_handler_completed: AtomicUsize,
sdk_tools_call_handler_consumed: 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,
sdk_prompts_list_handler_completed: AtomicUsize,
sdk_prompts_get_handler_completed: AtomicUsize,
sdk_prompts_list_handler_consumed: AtomicUsize,
sdk_prompts_get_handler_consumed: AtomicUsize,
sdk_prompts_dispatch: AtomicUsize,
sdk_prompts_list_result: AtomicUsize,
sdk_prompts_get_result: AtomicUsize,
sdk_completion_dispatch: AtomicUsize,
sdk_completion_result: AtomicUsize,
sdk_completion_handler_completed: AtomicUsize,
sdk_completion_handler_consumed: AtomicUsize,
sdk_logging_dispatch: AtomicUsize,
sdk_logging_level: AtomicUsize,
sdk_logging_notification: AtomicUsize,
@@ -73,18 +89,89 @@ pub(crate) struct CounterSet {
sdk_signal_notification: AtomicUsize,
sdk_jsonrpc_response: AtomicUsize,
sdk_jsonrpc_error: AtomicUsize,
sdk_ping_request: AtomicUsize,
sdk_ping_result: AtomicUsize,
sdk_inbound_response_decoded: AtomicUsize,
sdk_inbound_error_decoded: AtomicUsize,
sdk_inbound_response_consumed: AtomicUsize,
sdk_inbound_error_consumed: AtomicUsize,
sdk_dispatch_decoded: AtomicUsize,
sdk_dispatch_consumed: AtomicUsize,
sdk_initialized_decoded: AtomicUsize,
sdk_initialized_consumed: AtomicUsize,
sdk_initialize_input: AtomicUsize,
sdk_initialize_result: AtomicUsize,
sdk_discover_result: AtomicUsize,
sdk_initialize_handler_completed: AtomicUsize,
sdk_initialize_handler_consumed: AtomicUsize,
sdk_discover_handler_completed: AtomicUsize,
sdk_discover_handler_consumed: AtomicUsize,
sdk_ping_handler_completed: AtomicUsize,
sdk_ping_handler_consumed: AtomicUsize,
}
impl CounterSet {
pub(crate) fn sdk_tools_list_handler_completed(&self) -> usize {
self.sdk_tools_list_handler_completed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_tools_list_handler_consumed(&self) -> usize {
self.sdk_tools_list_handler_consumed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_tools_call_handler_completed(&self) -> usize {
self.sdk_tools_call_handler_completed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_tools_call_handler_consumed(&self) -> usize {
self.sdk_tools_call_handler_consumed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_prompts_list_handler_completed(&self) -> usize {
self.sdk_prompts_list_handler_completed
.load(Ordering::SeqCst)
}
pub(crate) fn sdk_prompts_get_handler_completed(&self) -> usize {
self.sdk_prompts_get_handler_completed
.load(Ordering::SeqCst)
}
pub(crate) fn sdk_prompts_list_handler_consumed(&self) -> usize {
self.sdk_prompts_list_handler_consumed
.load(Ordering::SeqCst)
}
pub(crate) fn sdk_prompts_get_handler_consumed(&self) -> usize {
self.sdk_prompts_get_handler_consumed.load(Ordering::SeqCst)
}
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)
}
pub(crate) fn sdk_inbound_error_decoded(&self) -> usize {
self.sdk_inbound_error_decoded.load(Ordering::SeqCst)
}
pub(crate) fn sdk_inbound_response_consumed(&self) -> usize {
self.sdk_inbound_response_consumed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_inbound_error_consumed(&self) -> usize {
self.sdk_inbound_error_consumed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_dispatch_decoded(&self) -> usize {
self.sdk_dispatch_decoded.load(Ordering::SeqCst)
}
@@ -97,20 +184,28 @@ impl CounterSet {
pub(crate) fn sdk_initialized_consumed(&self) -> usize {
self.sdk_initialized_consumed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_ping_request(&self) -> usize {
self.sdk_ping_request.load(Ordering::SeqCst)
}
pub(crate) fn sdk_ping_result(&self) -> usize {
self.sdk_ping_result.load(Ordering::SeqCst)
}
pub(crate) fn sdk_initialize_input(&self) -> usize {
self.sdk_initialize_input.load(Ordering::SeqCst)
}
pub(crate) fn sdk_initialize_result(&self) -> usize {
self.sdk_initialize_result.load(Ordering::SeqCst)
pub(crate) fn sdk_initialize_handler_completed(&self) -> usize {
self.sdk_initialize_handler_completed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_discover_result(&self) -> usize {
self.sdk_discover_result.load(Ordering::SeqCst)
pub(crate) fn sdk_initialize_handler_consumed(&self) -> usize {
self.sdk_initialize_handler_consumed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_discover_handler_completed(&self) -> usize {
self.sdk_discover_handler_completed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_discover_handler_consumed(&self) -> usize {
self.sdk_discover_handler_consumed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_ping_handler_completed(&self) -> usize {
self.sdk_ping_handler_completed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_ping_handler_consumed(&self) -> usize {
self.sdk_ping_handler_consumed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_jsonrpc_response(&self) -> usize {
self.sdk_jsonrpc_response.load(Ordering::SeqCst)
@@ -154,6 +249,12 @@ impl CounterSet {
pub(crate) fn sdk_completion_result(&self) -> usize {
self.sdk_completion_result.load(Ordering::SeqCst)
}
pub(crate) fn sdk_completion_handler_completed(&self) -> usize {
self.sdk_completion_handler_completed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_completion_handler_consumed(&self) -> usize {
self.sdk_completion_handler_consumed.load(Ordering::SeqCst)
}
pub(crate) fn sdk_prompts_dispatch(&self) -> usize {
self.sdk_prompts_dispatch.load(Ordering::SeqCst)
}
@@ -293,6 +394,48 @@ pub(crate) fn sdk_tools_call_result_serialized() {
increment(|counters| &counters.sdk_tools_call_result);
}
/// Mark after the SDK Tools handler awaits the domain operation and builds its typed result.
pub(crate) fn sdk_tools_list_handler_completed() {
increment(|counters| &counters.sdk_tools_list_handler_completed);
}
/// Mark only after the caller consumes the actual SDK handler result.
pub(crate) fn sdk_tools_list_handler_consumed() {
increment(|counters| &counters.sdk_tools_list_handler_consumed);
}
/// Mark after the SDK Tools handler awaits the domain operation and builds its typed result.
pub(crate) fn sdk_tools_call_handler_completed() {
increment(|counters| &counters.sdk_tools_call_handler_completed);
}
/// Mark only after the caller consumes the actual SDK handler result.
pub(crate) fn sdk_tools_call_handler_consumed() {
increment(|counters| &counters.sdk_tools_call_handler_consumed);
}
/// 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);
@@ -317,6 +460,29 @@ 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;
#[path = "../rmcp_prompts_handler_runtime_tests.rs"]
mod rmcp_prompts_handler_runtime_tests;
/// Mark inside the override after domain await and typed Result construction.
pub(crate) fn sdk_prompts_list_handler_completed() {
increment(|c| &c.sdk_prompts_list_handler_completed);
}
/// Mark inside the override after domain await and typed Result construction.
pub(crate) fn sdk_prompts_get_handler_completed() {
increment(|c| &c.sdk_prompts_get_handler_completed);
}
/// Mark after matching/restoring the actual trait Result in the caller.
pub(crate) fn sdk_prompts_list_handler_consumed() {
increment(|c| &c.sdk_prompts_list_handler_consumed);
}
/// Mark after matching/restoring the actual trait Result in the caller.
pub(crate) fn sdk_prompts_get_handler_consumed() {
increment(|c| &c.sdk_prompts_get_handler_consumed);
}
/// 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);
@@ -346,10 +512,24 @@ pub(crate) fn sdk_completion_result_serialized() {
increment(|counters| &counters.sdk_completion_result);
}
/// Mark inside the ServerHandler override after domain await and typed Result construction.
pub(crate) fn sdk_completion_handler_completed() {
increment(|counters| &counters.sdk_completion_handler_completed);
}
/// Mark in the caller only after matching and consuming the actual trait Result.
pub(crate) fn sdk_completion_handler_consumed() {
increment(|counters| &counters.sdk_completion_handler_consumed);
}
#[cfg(test)]
#[path = "../rmcp_completion_runtime_tests.rs"]
mod rmcp_completion_runtime_tests;
#[cfg(test)]
#[path = "../rmcp_completion_handler_runtime_tests.rs"]
mod rmcp_completion_handler_runtime_tests;
/// Mark only after constructing the real SDK typed legacy logging request.
pub(crate) fn sdk_logging_dispatch_enter() {
increment(|counters| &counters.sdk_logging_dispatch);
@@ -413,19 +593,32 @@ pub(crate) fn sdk_jsonrpc_error_serialized() {
#[path = "../rmcp_envelopes_runtime_tests.rs"]
mod rmcp_envelopes_runtime_tests;
/// Mark only after successfully serializing a real rmcp InitializeResult.
pub(crate) fn sdk_initialize_result_serialized() {
increment(|counters| &counters.sdk_initialize_result);
pub(crate) fn sdk_initialize_handler_completed() {
increment(|c| &c.sdk_initialize_handler_completed);
}
/// Mark only after successfully serializing a real rmcp DiscoverResult.
pub(crate) fn sdk_discover_result_serialized() {
increment(|counters| &counters.sdk_discover_result);
pub(crate) fn sdk_initialize_handler_consumed() {
increment(|c| &c.sdk_initialize_handler_consumed);
}
pub(crate) fn sdk_discover_handler_completed() {
increment(|c| &c.sdk_discover_handler_completed);
}
pub(crate) fn sdk_discover_handler_consumed() {
increment(|c| &c.sdk_discover_handler_consumed);
}
pub(crate) fn sdk_ping_handler_completed() {
increment(|c| &c.sdk_ping_handler_completed);
}
pub(crate) fn sdk_ping_handler_consumed() {
increment(|c| &c.sdk_ping_handler_consumed);
}
#[path = "../rmcp_lifecycle_negotiation_runtime_tests.rs"]
mod rmcp_lifecycle_negotiation_runtime_tests;
#[cfg(test)]
#[path = "../rmcp_negotiation_handler_runtime_tests.rs"]
mod rmcp_negotiation_handler_runtime_tests;
/// Mark only where SDK protocol_version is consumed by initialize negotiation, not at DTO creation.
pub(crate) fn sdk_initialize_input_consumed(_params: &rmcp::model::InitializeRequestParams) {
increment(|counters| &counters.sdk_initialize_input);
@@ -434,16 +627,6 @@ pub(crate) fn sdk_initialize_input_consumed(_params: &rmcp::model::InitializeReq
#[path = "../rmcp_initialize_input_runtime_tests.rs"]
mod rmcp_initialize_input_runtime_tests;
/// Mark only where a real SDK PingRequest is consumed by the shared runtime ping seam.
pub(crate) fn sdk_ping_request_consumed(_request: &rmcp::model::PingRequest) {
increment(|counters| &counters.sdk_ping_request);
}
/// Mark only after successfully serializing the real SDK ping result.
pub(crate) fn sdk_ping_result_serialized() {
increment(|counters| &counters.sdk_ping_result);
}
#[path = "../rmcp_ping_runtime_tests.rs"]
mod rmcp_ping_runtime_tests;
@@ -477,6 +660,26 @@ pub(crate) fn sdk_dispatch_envelope_consumed() {
#[path = "../rmcp_dispatch_runtime_tests.rs"]
mod rmcp_dispatch_runtime_tests;
/// Mark only after a real SDK success-response from_value succeeds.
pub(crate) fn sdk_inbound_response_decoded() {
increment(|c| &c.sdk_inbound_response_decoded);
}
/// Mark only after a real SDK error-response from_value succeeds.
pub(crate) fn sdk_inbound_error_decoded() {
increment(|c| &c.sdk_inbound_error_decoded);
}
/// Mark inside the matched typed SDK success variant that selects ACK.
pub(crate) fn sdk_inbound_response_consumed() {
increment(|c| &c.sdk_inbound_response_consumed);
}
/// Mark inside the matched typed SDK error variant that selects ACK.
pub(crate) fn sdk_inbound_error_consumed() {
increment(|c| &c.sdk_inbound_error_consumed);
}
#[path = "../rmcp_response_runtime_tests.rs"]
mod rmcp_response_runtime_tests;
fn increment(counter: impl Fn(&CounterSet) -> &AtomicUsize) {
let _ = OBSERVER.try_with(|counters| {
counter(counters).fetch_add(1, Ordering::SeqCst);
@@ -278,6 +278,17 @@ async fn mcp_post_response(
Err(_status) => return ambiguous_session_carrier_response(headers, message),
};
// Responses ACK before era/session resolution, but must not bypass fresh credentials.
// Method-bearing messages retain their existing scoped authorization path below.
if message
.as_object()
.is_some_and(|object| !object.contains_key("method"))
&& let Err(error) =
require_traced_machine_access(&state, path, headers, PlatformApiKeyScope::Read).await
{
return error.into_response();
}
// Single JSON-RPC envelope guard: only a well-formed message reaches era resolution, dispatch,
// approval or any outbound request. Syntactically valid JSON is not the same as a valid envelope.
let envelope = match crate::protocol::validate_jsonrpc_envelope(message) {
@@ -22,7 +22,6 @@ use super::response::{
completion_result, internal_jsonrpc_error, prompt_arguments_error_response, prompt_get_result,
prompts_list_result, resource_error_response, resource_read_result,
resource_templates_list_result, resources_list_result, take_confirmation_token,
tools_list_result,
};
use super::rmcp_dispatch::{
handle_resources_command, handle_tools_command, list_resource_templates,
@@ -36,7 +35,7 @@ use crate::{
EVENT_LEVEL_APPLIED, INVALID_LEVEL, Kind, LoggingOutcome, MethodHandler, PromptGetCommand,
PromptsCommand, PromptsListCommand, PromptsOutcome, RequestIdentity, ResourceReadCommand,
ResourcesCommand, ResourcesListCommand, ResourcesOutcome, ServiceContext, SetLevelCommand,
ToolCallCommand, ToolsCommand, ToolsListCommand, ToolsOutcome, handle_logging_command,
ToolCallCommand, ToolsCommand, ToolsListCommand, handle_logging_command,
},
tool_error::execution_locale,
transport::{ResponseMode, session_id_from_headers, transport_response},
@@ -107,14 +106,20 @@ pub(super) async fn handle_legacy_request(
Err(response) => return response,
};
if let Err(error) = super::rmcp_negotiation::ping().await {
return super::dispatch::sdk_error_response(
message,
response_mode,
&session.protocol_version,
error,
);
}
transport_response(
StatusCode::OK,
jsonrpc_result(
request_id(message),
crate::protocol::ping_result(
&json!({"method": "ping"}),
&session.protocol_version,
),
json!({"protocolVersion": session.protocol_version}),
),
response_mode,
None,
@@ -159,36 +164,12 @@ pub(super) async fn handle_legacy_request(
None,
)
.await;
match outcome {
ToolsOutcome::List { tools, next_cursor } => {
match tools_list_result(tools, next_cursor, &session.protocol_version) {
Ok(result) => transport_response(
StatusCode::OK,
jsonrpc_result(request_id(message), result),
response_mode,
None,
Some(&session.protocol_version),
),
Err(error) => internal_jsonrpc_error(message, error),
}
}
ToolsOutcome::InvalidParams(message_text) => transport_response(
StatusCode::OK,
jsonrpc_error(request_id(message), -32602, message_text),
response_mode,
None,
Some(&session.protocol_version),
),
ToolsOutcome::CatalogUnavailable => {
internal_jsonrpc_error(message, "published catalog is unavailable")
}
// A list command never produces a call outcome; it is answered with the adapter's
// internal error instead of being silently ignored.
ToolsOutcome::Call(_) => internal_jsonrpc_error(
message,
"unexpected shared tools outcome for a tools/list",
),
}
super::response::sdk_tools_response(
message,
response_mode,
&session.protocol_version,
outcome,
)
}
DispatchDecision::Allowed {
handler: MethodHandler::ToolCall,
@@ -431,8 +412,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,
)
@@ -41,11 +41,11 @@ use tokio::sync::{mpsc, watch};
use super::rmcp_dispatch::handle_tools_command;
use super::{
AppState,
response::{ToolCommandPayload, tool_command_payload, tool_command_response},
response::{ToolCommandPayload, sdk_tools_payload, sdk_tools_response},
};
use crate::{
jsonrpc::request_id,
protocol::{ContinuationSupport, ServiceContext, ToolCallCommand, ToolsCommand, ToolsOutcome},
protocol::{ContinuationSupport, ServiceContext, ToolCallCommand, ToolsCommand},
transport::{ResponseMode, sse_response},
};
@@ -393,7 +393,7 @@ pub(crate) async fn run_tool_call(
});
let message = wire.message.clone();
let correlation = request.correlation.clone();
let protocol_version = wire.protocol_version.clone();
let response_mode = wire.response_mode;
@@ -411,13 +411,7 @@ pub(crate) async fn run_tool_call(
outcome = &mut call => outcome,
_ = lifecycle.cancelled() => return cancelled_response(),
};
return tool_command_response(
&message,
response_mode,
&protocol_version,
&correlation,
outcome,
);
return sdk_tools_response(&message, response_mode, &protocol_version, outcome);
};
debug_assert!(matches!(response_mode, ResponseMode::Sse));
@@ -430,7 +424,6 @@ pub(crate) async fn run_tool_call(
token,
message,
protocol_version: protocol_version.clone(),
correlation,
pending: VecDeque::new(),
finished: false,
logging: crate::protocol::carry_scope(),
@@ -451,7 +444,7 @@ async fn call_future(
request: ToolCallRequest,
lifecycle: ToolCallLifecycle,
command: ToolCallCommand,
) -> ToolsOutcome {
) -> super::rmcp_tools_runtime::Outcome {
handle_tools_command(
&state,
ServiceContext {
@@ -478,13 +471,12 @@ fn cancelled_response() -> Response {
}
struct CallStream {
call: Pin<Box<dyn Future<Output = ToolsOutcome> + Send>>,
call: Pin<Box<dyn Future<Output = super::rmcp_tools_runtime::Outcome> + Send>>,
events: mpsc::Receiver<ProgressEvent>,
cancel: CancelSignal,
token: ProgressToken,
message: Value,
protocol_version: String,
correlation: CorrelationContext,
pending: VecDeque<Event>,
finished: bool,
/// The request's logging context, so the terminal event of the stream is projected exactly as the
@@ -496,7 +488,7 @@ struct CallStream {
enum Step {
Progress(ProgressEvent),
Outcome(ToolsOutcome),
Outcome(super::rmcp_tools_runtime::Outcome),
Cancelled,
}
@@ -541,12 +533,7 @@ async fn next_event_in_scope(
}
Step::Outcome(outcome) => {
call.finished = true;
let payload = match tool_command_payload(
&call.message,
&call.protocol_version,
&call.correlation,
outcome,
) {
let payload = match sdk_tools_payload(&call.message, &call.protocol_version, outcome) {
ToolCommandPayload::Ok(payload) => payload,
ToolCommandPayload::Internal(_) => jsonrpc_internal_error(&call.message),
};
+65 -157
View File
@@ -1,5 +1,7 @@
use axum::{http::StatusCode, response::Response};
use rmcp::model::{CacheScope, CallToolResult, ContentBlock, ListToolsResult, ResultType, Tool};
#[cfg(test)]
use rmcp::model::{CacheScope, ListToolsResult, Tool};
use rmcp::model::{CallToolResult, ContentBlock, ResultType};
use serde_json::{Value, json};
use crate::{
@@ -9,8 +11,11 @@ use crate::{
};
use crate::jsonrpc::jsonrpc_error;
#[cfg(test)]
use crate::protocol::{ToolCallOutcome, ToolsOutcome};
#[cfg(test)]
use crate::tool_error::{control_tool_error_contract, execution_locale};
#[cfg(test)]
use crank_core::CorrelationContext;
pub(crate) fn take_confirmation_token(arguments: &mut Value) -> Option<String> {
@@ -25,6 +30,7 @@ pub(crate) fn take_confirmation_token(arguments: &mut Value) -> Option<String> {
/// The era-neutral success payload of one `tools/call` (Story 3.4: the streamed response needs the
/// payload itself, because the terminal response is the last event of the request's stream).
#[cfg(test)]
pub(super) fn success_tool_payload(
message: &Value,
protocol_version: &str,
@@ -49,6 +55,7 @@ pub(crate) fn tool_error_response(
)
}
#[cfg(test)]
pub(super) fn tool_error_payload(
message: &Value,
protocol_version: &str,
@@ -79,6 +86,7 @@ fn call_result_payload(message: &Value, version: &str, mut result: CallToolResul
jsonrpc_result(request_id(message), result)
}
#[cfg(test)]
pub(super) fn sdk_tools_list_result(
tools: &[Value],
next_cursor: Option<String>,
@@ -95,6 +103,7 @@ pub(super) fn sdk_tools_list_result(
}
/// Serialize the SDK model, preserving catalog extensions that pinned Tool serde cannot represent.
#[cfg(test)]
pub(super) fn tools_list_result(
tools: Vec<Value>,
next_cursor: Option<String>,
@@ -134,35 +143,11 @@ pub(super) fn resources_list_result(
next_cursor: Option<String>,
version: &str,
) -> Result<Value, serde_json::Error> {
let modern = version == crate::jsonrpc::MODERN_PROTOCOL_VERSION;
let result = rmcp::model::ListResourcesResult {
resources: resources
.iter()
.cloned()
.map(serde_json::from_value)
.collect::<Result<_, _>>()?,
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 +155,10 @@ pub(super) fn resource_read_result(
contents: Value,
version: &str,
) -> Result<Value, serde_json::Error> {
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,88 +167,21 @@ pub(super) fn resource_templates_list_result(
next_cursor: Option<String>,
version: &str,
) -> Result<Value, serde_json::Error> {
let modern = version == crate::jsonrpc::MODERN_PROTOCOL_VERSION;
let result = rmcp::model::ListResourceTemplatesResult {
resource_templates: templates
.iter()
.cloned()
.map(serde_json::from_value)
.collect::<Result<_, _>>()?,
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)
}
// Pinned SDK serde drops unknown fields and optional nulls, including Crank template parameters.
// Treat annotations/icons as opaque too: their nested extensions are not represented by the SDK.
fn preserve_resource_fields(raw: &[Value], serialized: &mut Value, sdk_fields: &[&str]) {
for (raw, serialized) in raw
.iter()
.zip(serialized.as_array_mut().expect("SDK array"))
{
let serialized = serialized.as_object_mut().expect("SDK object");
for (key, value) in raw.as_object().expect("validated resource object") {
if !sdk_fields.contains(&key.as_str()) || value.is_null() {
serialized.insert(key.clone(), value.clone());
}
}
}
}
/// SDK pagination with lossless Crank argument schemas/defaults and optional nulls.
pub(super) fn prompts_list_result(
prompts: Vec<Value>,
next_cursor: Option<String>,
) -> Result<Value, serde_json::Error> {
let result = rmcp::model::ListPromptsResult {
prompts: prompts
.iter()
.cloned()
.map(serde_json::from_value)
.collect::<Result<Vec<rmcp::model::Prompt>, _>>()?,
next_cursor,
result_type: None,
ttl_ms: None,
cache_scope: None,
meta: None,
};
let mut result = serde_json::to_value(result)?;
preserve_resource_fields(
&prompts,
&mut result["prompts"],
&["name", "title", "description", "arguments", "_meta"],
);
for (raw, serialized) in prompts
.iter()
.zip(result["prompts"].as_array_mut().expect("SDK prompts"))
{
if let Some(arguments) = raw["arguments"].as_array() {
preserve_resource_fields(
arguments,
&mut serialized["arguments"],
&["name", "title", "description", "required"],
);
}
}
let (result, extras) = super::rmcp_prompts_projection::list(&prompts, next_cursor)?;
let result = super::rmcp_prompts_projection::serialize(result, extras, "prompts")?;
#[cfg(test)]
super::dispatch_observer::sdk_prompts_list_result_serialized();
Ok(result)
@@ -284,40 +192,8 @@ pub(super) fn prompt_get_result(
description: Option<String>,
messages: Vec<Value>,
) -> Result<Value, serde_json::Error> {
let sdk_messages = messages
.iter()
.cloned()
.map(|mut message| {
if message["role"] == "system" {
message["role"] = json!("user");
}
serde_json::from_value::<rmcp::model::PromptMessage>(message)
})
.collect::<Result<Vec<_>, _>>()?;
let mut result = rmcp::model::GetPromptResult::new(sdk_messages);
result.description = description;
// Era-specific resultType/cache projection remains at the existing dispatch boundary.
result.result_type = None;
let mut result = serde_json::to_value(result)?;
preserve_resource_fields(&messages, &mut result["messages"], &["role", "content"]);
for (raw, serialized) in messages
.iter()
.zip(result["messages"].as_array_mut().expect("SDK messages"))
{
if raw["role"] == "system" {
serialized["role"] = raw["role"].clone();
}
// Content extensions/optional nulls are opaque to the pinned SDK.
let content = serialized["content"].as_object_mut().expect("SDK content");
for (key, value) in raw["content"].as_object().expect("validated content") {
if !content.contains_key(key)
|| value.is_null()
|| matches!(key.as_str(), "annotations" | "resource")
{
content.insert(key.clone(), value.clone());
}
}
}
let (result, extras) = super::rmcp_prompts_projection::get(description, &messages)?;
let result = super::rmcp_prompts_projection::serialize(result, extras, "messages")?;
#[cfg(test)]
super::dispatch_observer::sdk_prompts_get_result_serialized();
Ok(result)
@@ -389,6 +265,7 @@ pub(super) enum ToolCommandPayload {
/// service never sees `ResponseMode`, the protocol revision, the request envelope or an
/// `axum::Response`. `ApprovalPending` is a success for the client (it still has to answer), while
/// an unavailable elicitation and a failing call keep their era-correct tool-error shape.
#[cfg(test)]
pub(super) fn tool_command_payload(
message: &Value,
protocol_version: &str,
@@ -433,22 +310,53 @@ pub(super) fn tool_command_payload(
}
}
/// The single-response form of [`tool_command_payload`].
pub(super) fn tool_command_response(
pub(super) fn sdk_tools_payload(
message: &Value,
response_mode: ResponseMode,
protocol_version: &str,
correlation: &CorrelationContext,
outcome: ToolsOutcome,
version: &str,
outcome: super::rmcp_tools_runtime::Outcome,
) -> ToolCommandPayload {
use super::rmcp_tools_runtime::Outcome;
let payload = match outcome {
Outcome::List { result, extras } => {
match super::rmcp_tools_projection::serialize_list(result, extras, version) {
Ok(result) => jsonrpc_result(request_id(message), result),
Err(_) => return ToolCommandPayload::Internal("invalid tool catalog"),
}
}
Outcome::Call(result) => call_result_payload(message, version, result),
Outcome::Error(error) => sdk_tools_error_payload(message, error),
};
ToolCommandPayload::Ok(payload)
}
pub(super) fn sdk_tools_error_payload(message: &Value, error: rmcp::ErrorData) -> Value {
let mut payload = jsonrpc_error(
request_id(message),
i64::from(error.code.0),
error.message.to_string(),
);
if let Some(data) = error.data {
payload["error"]["data"] = data;
}
payload
}
pub(super) fn sdk_tools_response(
message: &Value,
mode: ResponseMode,
version: &str,
outcome: super::rmcp_tools_runtime::Outcome,
) -> Response {
match tool_command_payload(message, protocol_version, correlation, outcome) {
ToolCommandPayload::Ok(payload) => transport_response(
StatusCode::OK,
let internal = matches!(&outcome, super::rmcp_tools_runtime::Outcome::Error(error) if error.code == rmcp::model::ErrorCode::INTERNAL_ERROR);
match sdk_tools_payload(message, version, outcome) {
ToolCommandPayload::Ok(payload) if internal => transport_response(
StatusCode::INTERNAL_SERVER_ERROR,
payload,
response_mode,
ResponseMode::Json,
None,
None,
Some(protocol_version),
),
ToolCommandPayload::Ok(payload) => {
transport_response(StatusCode::OK, payload, mode, None, Some(version))
}
ToolCommandPayload::Internal(detail) => internal_jsonrpc_error(message, detail),
}
}
@@ -0,0 +1,215 @@
//! Request-owned SDK completion handler; the domain future remains in its caller.
use std::sync::Arc;
use crank_core::{CorrelationContext, ExecutionLocale};
use rmcp::{ErrorData, RoleServer, ServerHandler, model::*, service::RequestContext};
use serde_json::{Map, Value};
use super::AppState;
use crate::{
auth::VerifiedMachineCredential,
protocol::{self, CompletionCommand, CompletionOutcome, CompletionReference, ServiceContext},
};
#[derive(Clone)]
struct Scope {
workspace: String,
agent: String,
credential: VerifiedMachineCredential,
correlation: CorrelationContext,
continuation: protocol::ContinuationSupport,
locale: ExecutionLocale,
revision: String,
context: Option<Map<String, Value>>,
}
impl Scope {
fn service(&self) -> ServiceContext<'_> {
ServiceContext {
workspace_slug: &self.workspace,
agent_slug: &self.agent,
credential: &self.credential,
correlation: &self.correlation,
continuation: self.continuation,
locale: self.locale,
}
}
}
#[derive(Clone)]
struct CompletionHandler {
state: Arc<AppState>,
#[cfg(test)]
domain: Option<Arc<tests::Domain>>,
}
fn internal() -> ErrorData {
ErrorData::internal_error("completion handler unavailable", None)
}
impl CompletionHandler {
async fn domain(&self, scope: &Scope, command: CompletionCommand) -> CompletionOutcome {
#[cfg(test)]
if let Some(domain) = &self.domain {
return domain.complete(command).await;
}
protocol::handle_completion_command(&self.state, scope.service(), &scope.revision, command)
.await
}
fn scope(context: &RequestContext<RoleServer>) -> Result<Scope, ErrorData> {
context
.extensions
.get::<Scope>()
.cloned()
.ok_or_else(internal)
}
async fn execute(
&self,
scope: &Scope,
params: CompleteRequestParams,
) -> Result<CompleteResult, ErrorData> {
let reference = match params.r#ref {
Reference::Prompt(prompt) => CompletionReference::Prompt { name: prompt.name },
Reference::Resource(resource) => CompletionReference::Resource { uri: resource.uri },
_ => {
return Err(ErrorData::invalid_params(
"invalid completion/complete parameters",
None,
));
}
};
// SDK context only accepts strings; retain the original JSON for domain validation.
let context = scope
.context
.clone()
.map(|arguments| serde_json::from_value(serde_json::json!({"arguments": arguments})))
.transpose()
.map_err(|_| internal())?;
let command = CompletionCommand {
reference,
argument: crate::protocol::CompletionArgument {
name: params.argument.name,
value: params.argument.value,
},
context,
};
match self.domain(scope, command).await {
CompletionOutcome::Completed {
values,
total,
has_more,
} => {
let mut info = CompletionInfo::new(values).map_err(|_| internal())?;
info.total = total.and_then(|v| u32::try_from(v).ok());
info.has_more = Some(has_more);
Ok(CompleteResult::new(info))
}
CompletionOutcome::InvalidParams(detail) => {
Err(ErrorData::invalid_params(detail, None))
}
CompletionOutcome::NotAvailable => Err(ErrorData::invalid_params(
"the completion reference is not available",
None,
)),
CompletionOutcome::CatalogUnavailable => Err(internal()),
}
}
}
impl ServerHandler for CompletionHandler {
async fn complete(
&self,
request: CompleteRequestParams,
context: RequestContext<RoleServer>,
) -> Result<CompleteResult, ErrorData> {
let scope = Self::scope(&context)?;
let result = self.execute(&scope, request).await;
#[cfg(test)]
super::dispatch_observer::sdk_completion_handler_completed();
result
}
}
async fn request_context(
handler: &CompletionHandler,
scope: Scope,
) -> Result<RequestContext<RoleServer>, 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::<RoleServer>::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-completion-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)
}
pub(super) async fn handle(
state: &Arc<AppState>,
context: ServiceContext<'_>,
revision: &str,
command: CompletionCommand,
) -> CompletionOutcome {
let (reference, context_args) = match command.reference {
CompletionReference::Prompt { name } => (
Reference::for_prompt(name),
command.context.and_then(|c| c.arguments),
),
CompletionReference::Resource { uri } => (
Reference::for_resource(uri),
command.context.and_then(|c| c.arguments),
),
};
let scope = Scope {
workspace: context.workspace_slug.to_owned(),
agent: context.agent_slug.to_owned(),
credential: context.credential.clone(),
correlation: context.correlation.clone(),
continuation: context.continuation,
locale: context.locale,
revision: revision.to_owned(),
context: context_args,
};
let handler = CompletionHandler {
state: state.clone(),
#[cfg(test)]
domain: None,
};
let sdk_context = match request_context(&handler, scope).await {
Ok(context) => context,
Err(_) => return CompletionOutcome::CatalogUnavailable,
};
#[cfg(test)]
super::dispatch_observer::sdk_completion_dispatch_enter();
let params = CompleteRequestParams::new(
reference,
ArgumentInfo::new(command.argument.name, command.argument.value),
);
let result = ServerHandler::complete(&handler, params, sdk_context).await;
restore(result)
}
fn restore(result: Result<CompleteResult, ErrorData>) -> CompletionOutcome {
let outcome = match result {
Ok(result) => CompletionOutcome::Completed {
values: result.completion.values,
total: result.completion.total.map(|v| v as usize),
has_more: result.completion.has_more.unwrap_or(false),
},
Err(error) if error.message == "the completion reference is not available" => {
CompletionOutcome::NotAvailable
}
Err(error) if error.code == ErrorCode::INVALID_PARAMS => {
CompletionOutcome::InvalidParams("invalid completion/complete parameters")
}
Err(_) => CompletionOutcome::CatalogUnavailable,
};
#[cfg(test)]
super::dispatch_observer::sdk_completion_handler_consumed();
outcome
}
#[cfg(test)]
#[path = "../rmcp_completion_handler_tests.rs"]
mod tests;
@@ -2,68 +2,18 @@
use std::sync::Arc;
use rmcp::model::{CallToolRequestParams, PaginatedRequestParams, ReadResourceRequestParams};
use serde_json::Value;
use super::{AppState, lifecycle::ToolCallLifecycle};
use crate::protocol::{
ServiceContext, ToolCallCommand, ToolCallOutcome, ToolsCommand, ToolsListCommand, ToolsOutcome,
};
// Crank extensions are not SDK fields and must survive the typed request boundary unchanged.
enum SdkToolsCommand {
List {
params: PaginatedRequestParams,
limit: Option<usize>,
},
Call {
params: CallToolRequestParams,
confirmation_token: Option<String>,
},
}
use crate::protocol::{ServiceContext, ToolsCommand};
pub(super) async fn handle_tools_command(
state: &Arc<AppState>,
context: ServiceContext<'_>,
command: ToolsCommand,
lifecycle: Option<ToolCallLifecycle>,
) -> ToolsOutcome {
let request = match command {
ToolsCommand::List(list) => SdkToolsCommand::List {
params: PaginatedRequestParams::default().with_cursor(list.cursor),
limit: list.limit,
},
ToolsCommand::Call(call) => {
let Value::Object(arguments) = call.arguments else {
return ToolsOutcome::Call(ToolCallOutcome::InvalidParams(
"tool arguments must be an object".to_owned(),
));
};
SdkToolsCommand::Call {
params: CallToolRequestParams::new(call.tool_name).with_arguments(arguments),
confirmation_token: call.confirmation_token,
}
}
};
#[cfg(test)]
super::dispatch_observer::sdk_tools_dispatch_enter();
let command = match request {
SdkToolsCommand::List { params, limit } => ToolsCommand::List(ToolsListCommand {
cursor: params.cursor,
limit,
}),
SdkToolsCommand::Call {
params,
confirmation_token,
} => ToolsCommand::Call(ToolCallCommand {
tool_name: params.name.into_owned(),
arguments: Value::Object(params.arguments.unwrap_or_default()),
confirmation_token,
}),
};
crate::protocol::handle_tools_command(state, context, command, lifecycle).await
) -> super::rmcp_tools_runtime::Outcome {
super::rmcp_tools_runtime::handle(state, context, command, lifecycle).await
}
pub(super) async fn handle_prompts_command(
@@ -72,27 +22,7 @@ pub(super) async fn handle_prompts_command(
revision: &str,
command: crate::protocol::PromptsCommand,
) -> crate::protocol::PromptsOutcome {
use crate::protocol::{PromptGetCommand, PromptsCommand, PromptsListCommand};
let command = match command {
PromptsCommand::List(list) => {
let params = PaginatedRequestParams::default().with_cursor(list.cursor);
PromptsCommand::List(PromptsListCommand {
cursor: params.cursor,
limit: list.limit,
})
}
PromptsCommand::Get(get) => {
let mut params = rmcp::model::GetPromptRequestParams::new(get.name);
params.arguments = get.arguments;
PromptsCommand::Get(PromptGetCommand {
name: params.name,
arguments: params.arguments,
})
}
};
#[cfg(test)]
super::dispatch_observer::sdk_prompts_dispatch_enter();
crate::protocol::handle_prompts_command(state, context, revision, command).await
super::rmcp_prompts::handle(state, context, revision, command).await
}
pub(super) async fn handle_resources_command(
@@ -101,31 +31,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<AppState>,
workspace_slug: &str,
agent_slug: &str,
context: ServiceContext<'_>,
revision: &str,
command: crate::protocol::ResourcesListCommand,
) -> Result<(Vec<Value>, Option<String>), 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(
@@ -134,48 +49,5 @@ pub(super) async fn handle_completion_command(
revision: &str,
command: crate::protocol::CompletionCommand,
) -> crate::protocol::CompletionOutcome {
use crate::protocol::{
CompletionArgument, CompletionCommand, CompletionOutcome, CompletionReference,
};
use rmcp::model::{ArgumentInfo, CompleteRequestParams, Reference};
let reference = match command.reference {
CompletionReference::Prompt { name } => Reference::for_prompt(name),
CompletionReference::Resource { uri } => Reference::for_resource(uri),
};
let params = CompleteRequestParams::new(
reference,
ArgumentInfo::new(command.argument.name, command.argument.value),
);
// SDK context only supports strings; retain arbitrary JSON unchanged for domain validation.
let context_arguments = command.context;
#[cfg(test)]
super::dispatch_observer::sdk_completion_dispatch_enter();
let reference = match params.r#ref {
Reference::Prompt(reference) => CompletionReference::Prompt {
name: reference.name,
},
Reference::Resource(reference) => CompletionReference::Resource { uri: reference.uri },
_ => return CompletionOutcome::InvalidParams("invalid completion/complete parameters"),
};
let command = CompletionCommand {
reference,
argument: CompletionArgument {
name: params.argument.name,
value: params.argument.value,
},
context: context_arguments,
};
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,
}
super::rmcp_completion::handle(state, context, revision, command).await
}
@@ -0,0 +1,176 @@
//! Request-owned SDK handlers for the existing HTTP negotiation and ping routes.
use std::borrow::Cow;
use rmcp::{ErrorData, RoleServer, ServerHandler, model::*, service::RequestContext};
use serde_json::{Value, json};
use crate::{jsonrpc::SUPPORTED_PROTOCOL_VERSIONS, protocol::advertised_server_capabilities};
const SERVER_NAME: &str = "crank-mcp-server";
const SERVER_VERSION: &str = env!("CARGO_PKG_VERSION");
#[derive(Clone)]
struct NegotiationHandler;
impl ServerHandler for NegotiationHandler {
fn supported_protocol_versions(&self) -> Cow<'static, [ProtocolVersion]> {
Cow::Owned(
SUPPORTED_PROTOCOL_VERSIONS
.iter()
.map(|v| version(v))
.collect(),
)
}
async fn initialize(
&self,
request: InitializeRequestParams,
_context: RequestContext<RoleServer>,
) -> Result<InitializeResult, ErrorData> {
let revision = request.protocol_version.as_str();
if !SUPPORTED_PROTOCOL_VERSIONS.contains(&revision) {
return Err(ErrorData::new(
ErrorCode(-32602),
format!("unsupported protocol version {revision}"),
None,
));
}
let caps = capabilities(&advertised_server_capabilities(revision));
#[cfg(test)]
super::dispatch_observer::sdk_initialize_handler_completed();
Ok(InitializeResult::new(caps)
.with_protocol_version(version(revision))
.with_server_info(Implementation::new(SERVER_NAME, SERVER_VERSION)))
}
async fn discover(
&self,
context: RequestContext<RoleServer>,
) -> Result<DiscoverResult, ErrorData> {
let revision = context
.extensions
.get::<ProtocolVersion>()
.ok_or_else(|| ErrorData::internal_error("discovery revision unavailable", None))?;
let revision = revision.as_str();
let result = DiscoverResult::new(
SUPPORTED_PROTOCOL_VERSIONS
.iter()
.map(|v| version(v))
.collect(),
capabilities(&advertised_server_capabilities(revision)),
)
.with_server_info(Implementation::new(SERVER_NAME, SERVER_VERSION))
.with_ttl_ms(0)
.with_cache_scope(CacheScope::Private);
#[cfg(test)]
super::dispatch_observer::sdk_discover_handler_completed();
Ok(result)
}
async fn ping(&self, _context: RequestContext<RoleServer>) -> Result<(), ErrorData> {
#[cfg(test)]
super::dispatch_observer::sdk_ping_handler_completed();
Ok(())
}
}
fn version(revision: &str) -> ProtocolVersion {
serde_json::from_value(Value::String(revision.to_owned()))
.expect("registered revisions are valid SDK versions")
}
fn capabilities(value: &Value) -> ServerCapabilities {
// Registry capabilities are the allowlist; the SDK must not supply defaults.
serde_json::from_value(value.clone()).expect("registered capabilities match SDK shapes")
}
async fn request_context() -> Result<RequestContext<RoleServer>, ErrorData> {
let ping: rmcp::model::ClientJsonRpcMessage =
serde_json::from_value(json!({"jsonrpc":"2.0", "id":1, "method":"ping"}))
.map_err(|_| ErrorData::internal_error("negotiation context unavailable", None))?;
let (transport, receiver) = rmcp::transport::OneshotTransport::<RoleServer>::new(ping);
let info = InitializeRequestParams::new(
ClientCapabilities::default(),
Implementation::new("crank-negotiation-context", "1"),
);
// Bootstrap only obtains a closed Peer; it must never run the request handler.
#[derive(Clone)]
struct Bootstrap;
impl ServerHandler for Bootstrap {}
let mut running = rmcp::service::serve_directly(Bootstrap, transport, Some(info));
let peer = running.peer().clone();
running
.close()
.await
.map_err(|_| ErrorData::internal_error("negotiation handler unavailable", None))?;
drop(receiver);
Ok(RequestContext::new(RequestId::Number(1), peer))
}
pub(super) async fn initialize(revision: &str) -> Result<Value, ErrorData> {
initialize_with(&NegotiationHandler, revision).await
}
async fn initialize_with(handler: &impl ServerHandler, revision: &str) -> Result<Value, ErrorData> {
let context = request_context().await?;
let params =
InitializeRequestParams::new(ClientCapabilities::default(), Implementation::new("", ""))
.with_protocol_version(version(revision));
let result = ServerHandler::initialize(handler, params, context).await?;
let mut value = serde_json::to_value(result)
.map_err(|_| ErrorData::internal_error("initialize result unavailable", None))?;
restore_capabilities(&mut value, revision);
#[cfg(test)]
super::dispatch_observer::sdk_initialize_handler_consumed();
Ok(value)
}
pub(super) async fn discover(revision: &str) -> Result<Value, ErrorData> {
discover_with(&NegotiationHandler, revision).await
}
async fn discover_with(handler: &impl ServerHandler, revision: &str) -> Result<Value, ErrorData> {
let mut context = request_context().await?;
context.extensions.insert(version(revision));
let result = ServerHandler::discover(handler, context).await?;
let mut value = serde_json::to_value(result)
.map_err(|_| ErrorData::internal_error("discover result unavailable", None))?;
restore_capabilities(&mut value, revision);
#[cfg(test)]
super::dispatch_observer::sdk_discover_handler_consumed();
Ok(value)
}
pub(super) async fn ping() -> Result<(), ErrorData> {
ping_with(&NegotiationHandler).await
}
async fn ping_with(handler: &impl ServerHandler) -> Result<(), ErrorData> {
let context = request_context().await?;
let result = ServerHandler::ping(handler, context).await;
#[cfg(test)]
super::dispatch_observer::sdk_ping_handler_consumed();
result
}
fn restore_capabilities(result: &mut Value, revision: &str) {
let advertised = advertised_server_capabilities(revision);
let represented =
serde_json::to_value(capabilities(&advertised)).expect("SDK capabilities serialize");
let caps = result["capabilities"]
.as_object_mut()
.expect("SDK capabilities serialize as object");
for (key, value) in advertised
.as_object()
.expect("registry capabilities are object")
{
// Restore only fields the SDK cannot represent, not removed typed capabilities.
if represented.get(key).is_none() {
caps.entry(key.clone()).or_insert_with(|| value.clone());
}
}
}
#[cfg(test)]
#[path = "../rmcp_negotiation_handler_tests.rs"]
mod tests;
@@ -0,0 +1,302 @@
//! Request-owned Prompts trait adapter; domain execution stays in the parent HTTP future.
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_prompts_projection as projection};
use crate::{
auth::VerifiedMachineCredential,
protocol::{
self, ContinuationSupport, PromptGetCommand, PromptsCommand, PromptsListCommand,
PromptsOutcome, ServiceContext,
},
};
#[derive(Clone)]
struct PromptScope {
workspace_slug: String,
agent_slug: String,
credential: VerifiedMachineCredential,
correlation: CorrelationContext,
continuation: ContinuationSupport,
locale: ExecutionLocale,
revision: String,
limit: Option<usize>,
}
impl PromptScope {
fn new(context: ServiceContext<'_>, revision: &str, limit: Option<usize>) -> 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),
Get(projection::Projection),
DomainError(PromptsOutcome),
}
#[derive(Clone)]
struct PromptHandler {
state: Arc<AppState>,
reply: Arc<Mutex<Option<ReplyExtras>>>,
#[cfg(test)]
domain: Option<Arc<tests::Domain>>,
}
fn internal() -> ErrorData {
ErrorData::internal_error("prompt handler unavailable", None)
}
impl PromptHandler {
fn new(state: &Arc<AppState>) -> Self {
Self {
state: state.clone(),
reply: Arc::new(Mutex::new(None)),
#[cfg(test)]
domain: None,
}
}
async fn execute(&self, scope: &PromptScope, command: PromptsCommand) -> PromptsOutcome {
#[cfg(test)]
if let Some(domain) = &self.domain {
return domain.prompts(command).await;
}
protocol::handle_prompts_command(&self.state, scope.context(), &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<ReplyExtras> {
self.reply.lock().ok()?.take()
}
fn scope(context: &RequestContext<RoleServer>) -> Result<PromptScope, ErrorData> {
context
.extensions
.get::<PromptScope>()
.cloned()
.ok_or_else(internal)
}
fn domain_error(&self, outcome: PromptsOutcome) -> ErrorData {
let error = match &outcome {
PromptsOutcome::Listed { .. } | PromptsOutcome::Got { .. } => return internal(),
PromptsOutcome::InvalidParams(detail) => {
ErrorData::invalid_params(detail.clone(), None)
}
PromptsOutcome::NotAvailable => {
ErrorData::invalid_params("the requested prompt is not available", None)
}
PromptsOutcome::ArgumentsRejected { .. } => {
ErrorData::invalid_params("the prompt arguments were rejected", None)
}
_ => internal(),
};
if self.save(ReplyExtras::DomainError(outcome)).is_err() {
return internal();
}
error
}
fn project_list(&self, outcome: PromptsOutcome) -> Result<ListPromptsResult, ErrorData> {
match outcome {
PromptsOutcome::Listed {
prompts,
next_cursor,
} => {
let (result, extras) =
projection::list(&prompts, next_cursor).map_err(|_| internal())?;
self.save(ReplyExtras::List(extras))?;
Ok(result)
}
other => Err(self.domain_error(other)),
}
}
fn project_get(&self, outcome: PromptsOutcome) -> Result<GetPromptResult, ErrorData> {
match outcome {
PromptsOutcome::Got {
description,
messages,
} => {
let (result, extras) =
projection::get(description, &messages).map_err(|_| internal())?;
self.save(ReplyExtras::Get(extras))?;
Ok(result)
}
other => Err(self.domain_error(other)),
}
}
}
impl ServerHandler for PromptHandler {
async fn list_prompts(
&self,
request: Option<PaginatedRequestParams>,
context: RequestContext<RoleServer>,
) -> Result<ListPromptsResult, ErrorData> {
let scope = Self::scope(&context)?;
let command = PromptsCommand::List(PromptsListCommand {
cursor: request.unwrap_or_default().cursor,
limit: scope.limit,
});
let outcome = self.execute(&scope, command).await;
let result = self.project_list(outcome);
#[cfg(test)]
super::dispatch_observer::sdk_prompts_list_handler_completed();
result
}
async fn get_prompt(
&self,
request: GetPromptRequestParams,
context: RequestContext<RoleServer>,
) -> Result<GetPromptResponse, ErrorData> {
let scope = Self::scope(&context)?;
let command = PromptsCommand::Get(PromptGetCommand {
name: request.name,
arguments: request.arguments,
});
let outcome = self.execute(&scope, command).await;
let result = self.project_get(outcome).map(Into::into);
#[cfg(test)]
super::dispatch_observer::sdk_prompts_get_handler_completed();
result
}
}
/// Public SDK context seed only; close the inert service before any domain execution.
/// shortcut: the closed Peer cannot send callbacks, revisit if Prompts need peer messaging.
async fn request_context(
handler: &PromptHandler,
scope: PromptScope,
) -> Result<RequestContext<RoleServer>, 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::<RoleServer>::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-prompt-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: &PromptHandler,
result: Result<ListPromptsResult, ErrorData>,
) -> PromptsOutcome {
match (result, handler.take()) {
(Ok(result), Some(ReplyExtras::List(extras))) => {
let cursor = result.next_cursor.clone();
match projection::serialize(result, extras, "prompts") {
Ok(mut result) => match result["prompts"].take() {
Value::Array(prompts) => PromptsOutcome::Listed {
prompts,
next_cursor: cursor,
},
_ => PromptsOutcome::CatalogUnavailable,
},
Err(_) => PromptsOutcome::CatalogUnavailable,
}
}
(Err(_), Some(ReplyExtras::DomainError(error))) => error,
_ => PromptsOutcome::CatalogUnavailable,
}
}
fn restore_get(
handler: &PromptHandler,
result: Result<GetPromptResponse, ErrorData>,
) -> PromptsOutcome {
match (result, handler.take()) {
(Ok(GetPromptResponse::Complete(result)), Some(ReplyExtras::Get(extras))) => {
let description = result.description.clone();
match projection::serialize(result, extras, "messages") {
Ok(mut result) => match result["messages"].take() {
Value::Array(messages) => PromptsOutcome::Got {
description,
messages,
},
_ => PromptsOutcome::CatalogUnavailable,
},
Err(_) => PromptsOutcome::CatalogUnavailable,
}
}
(Err(_), Some(ReplyExtras::DomainError(error))) => error,
_ => PromptsOutcome::CatalogUnavailable,
}
}
pub(super) async fn handle(
state: &Arc<AppState>,
context: ServiceContext<'_>,
revision: &str,
command: PromptsCommand,
) -> PromptsOutcome {
let limit = match &command {
PromptsCommand::List(list) => list.limit,
_ => None,
};
let handler = PromptHandler::new(state);
let context = match request_context(&handler, PromptScope::new(context, revision, limit)).await
{
Ok(context) => context,
Err(_) => return PromptsOutcome::CatalogUnavailable,
};
#[cfg(test)]
super::dispatch_observer::sdk_prompts_dispatch_enter();
match command {
PromptsCommand::List(list) => {
let result = ServerHandler::list_prompts(
&handler,
Some(PaginatedRequestParams::default().with_cursor(list.cursor)),
context,
)
.await;
let outcome = restore_list(&handler, result);
#[cfg(test)]
super::dispatch_observer::sdk_prompts_list_handler_consumed();
outcome
}
PromptsCommand::Get(get) => {
let mut request = GetPromptRequestParams::new(get.name);
request.arguments = get.arguments;
let result = ServerHandler::get_prompt(&handler, request, context).await;
let outcome = restore_get(&handler, result);
#[cfg(test)]
super::dispatch_observer::sdk_prompts_get_handler_consumed();
outcome
}
}
}
#[cfg(test)]
#[path = "../rmcp_prompts_handler_tests.rs"]
mod tests;
@@ -0,0 +1,194 @@
//! Prompt-only lossless projection: SDK fields remain sourced from the actual trait result.
use rmcp::model::{GetPromptResult, ListPromptsResult};
use serde::Serialize;
use serde_json::{Map, Value};
pub(super) fn invalid() -> serde_json::Error {
<serde_json::Error as serde::de::Error>::custom("invalid prompt projection")
}
// Store only differences from SDK serialization, not an alternate successful response.
pub(super) enum Projection {
Same,
Opaque(Value),
Object {
extras: Map<String, Value>,
absent: Vec<String>,
children: Vec<(String, Projection)>,
identity: Map<String, Value>,
},
Array(Vec<Projection>),
}
impl Projection {
fn between(raw: &Value, sdk: &Value) -> Self {
match (raw, sdk) {
(Value::Object(raw), Value::Object(sdk)) => {
let extras = raw
.iter()
.filter(|(k, _)| !sdk.contains_key(*k))
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
let absent = sdk
.keys()
.filter(|k| !raw.contains_key(*k))
.cloned()
.collect();
let children = raw
.iter()
.filter_map(|(k, v)| sdk.get(k).map(|s| (k.clone(), Self::between(v, s))))
.collect();
let identity = sdk
.iter()
.filter(|(k, _)| matches!(k.as_str(), "name" | "role" | "type" | "uri"))
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
Self::Object {
extras,
absent,
children,
identity,
}
}
(Value::Array(raw), Value::Array(sdk)) => Self::Array(
raw.iter()
.zip(sdk)
.map(|(r, s)| Self::between(r, s))
.collect(),
),
_ if raw == sdk => Self::Same,
_ => Self::Opaque(raw.clone()),
}
}
fn restore(self, sdk: &mut Value) -> Result<(), serde_json::Error> {
match self {
Self::Same => {}
Self::Opaque(value) => *sdk = value,
Self::Object {
extras,
absent,
children,
identity,
} => {
let object = sdk.as_object_mut().ok_or_else(invalid)?;
if identity.iter().any(|(k, v)| object.get(k) != Some(v)) {
return Err(invalid());
}
for (key, projection) in children {
projection.restore(object.get_mut(&key).ok_or_else(invalid)?)?;
}
for key in absent {
object.remove(&key);
}
object.extend(extras);
}
Self::Array(children) => {
let array = sdk.as_array_mut().ok_or_else(invalid)?;
if array.len() != children.len() {
return Err(invalid());
}
for (projection, item) in children.into_iter().zip(array) {
projection.restore(item)?;
}
}
}
Ok(())
}
}
fn visible(raw: &Value, fields: &[&str]) -> Result<Value, serde_json::Error> {
let raw = raw.as_object().ok_or_else(invalid)?;
Ok(Value::Object(
raw.iter()
.filter(|(key, _)| fields.contains(&key.as_str()))
.map(|(key, value)| (key.clone(), value.clone()))
.collect(),
))
}
pub(super) fn list(
prompts: &[Value],
next_cursor: Option<String>,
) -> Result<(ListPromptsResult, Projection), serde_json::Error> {
let mut typed = Vec::with_capacity(prompts.len());
for prompt in prompts {
let mut prompt = visible(
prompt,
&["name", "title", "description", "arguments", "_meta"],
)?;
if let Some(Value::Array(arguments)) = prompt.get_mut("arguments") {
for argument in arguments {
*argument = visible(argument, &["name", "title", "description", "required"])?;
}
}
typed.push(serde_json::from_value(prompt)?);
}
let result = ListPromptsResult {
prompts: typed,
next_cursor,
result_type: None,
ttl_ms: None,
cache_scope: None,
meta: None,
};
let extras = Projection::between(
&Value::Array(prompts.to_vec()),
&serde_json::to_value(&result)?["prompts"],
);
Ok((result, extras))
}
pub(super) fn get(
description: Option<String>,
messages: &[Value],
) -> Result<(GetPromptResult, Projection), serde_json::Error> {
let mut typed = Vec::with_capacity(messages.len());
for message in messages {
let mut message = visible(message, &["role", "content"])?;
if message["role"] == "system" {
message["role"] = Value::String("user".into());
}
let content = message.get_mut("content").ok_or_else(invalid)?;
// Opaque annotations and newly known SDK extensions must not add validation to Crank.
let fields: &[&str] = match content["type"].as_str() {
Some("text") => &["type", "text", "_meta"],
Some("image" | "audio") => &["type", "data", "mimeType", "_meta"],
Some("resource") => &["type", "resource", "_meta"],
Some("resource_link") => &[
"type",
"uri",
"name",
"title",
"description",
"mimeType",
"size",
"_meta",
],
_ => return Err(invalid()),
};
*content = visible(content, fields)?;
if let Some(resource) = content.get_mut("resource") {
*resource = visible(resource, &["uri", "mimeType", "text", "blob", "_meta"])?;
}
typed.push(serde_json::from_value(message)?);
}
let mut result = GetPromptResult::new(typed);
result.description = description;
result.result_type = None;
let extras = Projection::between(
&Value::Array(messages.to_vec()),
&serde_json::to_value(&result)?["messages"],
);
Ok((result, extras))
}
pub(super) fn serialize(
result: impl Serialize,
extras: Projection,
field: &str,
) -> Result<Value, serde_json::Error> {
let mut result = serde_json::to_value(result)?;
extras.restore(result.get_mut(field).ok_or_else(invalid)?)?;
Ok(result)
}
@@ -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<usize>,
}
impl ResourceScope {
fn new(context: ServiceContext<'_>, revision: &str, limit: Option<usize>) -> 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<AppState>,
reply: Arc<Mutex<Option<ReplyExtras>>>,
#[cfg(test)]
domain: Option<Arc<tests::Domain>>,
}
fn internal() -> ErrorData {
ErrorData::internal_error("resource handler unavailable", None)
}
impl ResourceHandler {
fn new(state: &Arc<AppState>) -> 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<Value>, Option<String>), 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<ReplyExtras> {
self.reply.lock().ok()?.take()
}
fn scope(context: &RequestContext<RoleServer>) -> Result<ResourceScope, ErrorData> {
context
.extensions
.get::<ResourceScope>()
.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<ListResourcesResult, ErrorData> {
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<ReadResourceResponse, ErrorData> {
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<Value>, Option<String>), ResourceTemplatesListError>,
revision: &str,
) -> Result<ListResourceTemplatesResult, ErrorData> {
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<PaginatedRequestParams>,
context: RequestContext<RoleServer>,
) -> Result<ListResourcesResult, ErrorData> {
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<RoleServer>,
) -> Result<ReadResourceResponse, ErrorData> {
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<PaginatedRequestParams>,
context: RequestContext<RoleServer>,
) -> Result<ListResourceTemplatesResult, ErrorData> {
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<RequestContext<RoleServer>, 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::<RoleServer>::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<ListResourcesResult, ErrorData>,
) -> 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<ReadResourceResponse, ErrorData>,
) -> 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<ListResourceTemplatesResult, ErrorData>,
) -> Result<(Vec<Value>, Option<String>), 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<AppState>,
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<AppState>,
context: ServiceContext<'_>,
revision: &str,
command: ResourcesListCommand,
) -> Result<(Vec<Value>, Option<String>), 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;
@@ -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<Map<String, Value>>,
identities: Vec<Map<String, Value>>,
}
fn invalid() -> serde_json::Error {
<serde_json::Error as serde::de::Error>::custom("invalid resource projection")
}
impl Projection {
fn project<T: DeserializeOwned>(
raw: &[Value],
fields: &[&str],
) -> Result<(Vec<T>, 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<String>,
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<String>,
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<Value, serde_json::Error> {
let mut result = serde_json::to_value(result)?;
extras.restore(result.get_mut(field).ok_or_else(invalid)?)?;
Ok(result)
}
@@ -0,0 +1,85 @@
//! Lossless catalog extras only; represented SDK fields remain authoritative.
use rmcp::{ErrorData, model::*};
use serde_json::{Map, Value};
pub(super) type Extras = Vec<Map<String, Value>>;
pub(super) enum Outcome {
List {
result: ListToolsResult,
extras: Extras,
},
Call(CallToolResult),
Error(ErrorData),
}
pub(super) fn internal() -> ErrorData {
ErrorData::internal_error("internal server error", None)
}
pub(super) fn list(
tools: Vec<Value>,
next_cursor: Option<String>,
) -> Result<(ListToolsResult, Extras), ErrorData> {
let mut extras = Vec::with_capacity(tools.len());
let mut typed = Vec::with_capacity(tools.len());
for tool in tools {
let mut raw = tool.as_object().cloned().ok_or_else(internal)?;
let mut extra = Map::new();
for key in raw.keys().cloned().collect::<Vec<_>>() {
if !matches!(
key.as_str(),
"name" | "title" | "description" | "inputSchema" | "outputSchema" | "_meta"
) || raw[&key].is_null()
{
extra.insert(key.clone(), raw.remove(&key).expect("existing field"));
}
}
typed.push(serde_json::from_value(Value::Object(raw)).map_err(|_| internal())?);
extras.push(extra);
}
Ok((
ListToolsResult {
tools: typed,
next_cursor,
..Default::default()
},
extras,
))
}
pub(super) fn consume_list(result: Result<ListToolsResult, ErrorData>, extras: Extras) -> Outcome {
match result {
Ok(result) => Outcome::List { result, extras },
Err(error) => Outcome::Error(error),
}
}
pub(super) fn serialize_list(
mut result: ListToolsResult,
extras: Extras,
version: &str,
) -> Result<Value, serde_json::Error> {
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)?;
for (tool, extras) in result["tools"]
.as_array_mut()
.expect("SDK tools array")
.iter_mut()
.zip(extras)
{
let tool = tool.as_object_mut().expect("SDK Tool object");
for (key, value) in extras {
tool.entry(key).or_insert(value);
}
}
#[cfg(test)]
super::dispatch_observer::sdk_tools_list_result_serialized();
Ok(result)
}
pub(super) fn consume_call(result: Result<CallToolResponse, ErrorData>) -> Outcome {
match result {
Ok(CallToolResponse::Complete(result)) => Outcome::Call(result),
Ok(_) => Outcome::Error(internal()),
Err(error) => Outcome::Error(error),
}
}
@@ -0,0 +1,237 @@
//! Request-owned Tools trait execution. The caller retains admission and lifecycle ownership.
use super::{AppState, lifecycle::ToolCallLifecycle, rmcp_tools_projection as projection};
use crate::{
auth::VerifiedMachineCredential,
protocol::{self, *},
};
use crank_core::{CorrelationContext, ExecutionLocale};
pub(super) use projection::Outcome;
use rmcp::{ErrorData, RoleServer, ServerHandler, model::*, service::RequestContext};
use serde_json::Value;
use std::sync::{Arc, Mutex};
#[derive(Clone)]
struct Scope {
workspace: String,
agent: String,
credential: VerifiedMachineCredential,
correlation: CorrelationContext,
continuation: ContinuationSupport,
locale: ExecutionLocale,
limit: Option<usize>,
confirmation: Option<String>,
lifecycle: Option<ToolCallLifecycle>,
}
impl Scope {
fn context(&self) -> ServiceContext<'_> {
ServiceContext {
workspace_slug: &self.workspace,
agent_slug: &self.agent,
credential: &self.credential,
correlation: &self.correlation,
continuation: self.continuation,
locale: self.locale,
}
}
}
#[derive(Clone)]
struct Handler {
state: Arc<AppState>,
extras: Arc<Mutex<projection::Extras>>,
#[cfg(test)]
domain: Option<Arc<tests::Domain>>,
}
impl Handler {
fn new(state: &Arc<AppState>) -> Self {
Self {
state: state.clone(),
extras: Arc::new(Mutex::new(Vec::new())),
#[cfg(test)]
domain: None,
}
}
async fn execute(&self, scope: &Scope, command: ToolsCommand) -> ToolsOutcome {
#[cfg(test)]
if let Some(domain) = &self.domain {
return domain.execute(scope, command).await;
}
protocol::handle_tools_command(
&self.state,
scope.context(),
command,
scope.lifecycle.clone(),
)
.await
}
fn scope(context: &RequestContext<RoleServer>) -> Result<Scope, ErrorData> {
context
.extensions
.get::<Scope>()
.cloned()
.ok_or_else(projection::internal)
}
fn take_extras(&self) -> projection::Extras {
self.extras
.lock()
.expect("request-local extras")
.drain(..)
.collect()
}
}
impl ServerHandler for Handler {
async fn list_tools(
&self,
request: Option<PaginatedRequestParams>,
context: RequestContext<RoleServer>,
) -> Result<ListToolsResult, ErrorData> {
let scope = Self::scope(&context)?;
let outcome = self
.execute(
&scope,
ToolsCommand::List(ToolsListCommand {
cursor: request.unwrap_or_default().cursor,
limit: scope.limit,
}),
)
.await;
let result = match outcome {
ToolsOutcome::List { tools, next_cursor } => projection::list(tools, next_cursor)
.and_then(|(result, extras)| {
*self.extras.lock().map_err(|_| projection::internal())? = extras;
Ok(result)
}),
ToolsOutcome::InvalidParams(detail) => Err(ErrorData::invalid_params(detail, None)),
_ => Err(projection::internal()),
};
#[cfg(test)]
super::dispatch_observer::sdk_tools_list_handler_completed();
result
}
async fn call_tool(
&self,
request: CallToolRequestParams,
context: RequestContext<RoleServer>,
) -> Result<CallToolResponse, ErrorData> {
let scope = Self::scope(&context)?;
let outcome = self
.execute(
&scope,
ToolsCommand::Call(ToolCallCommand {
tool_name: request.name.into_owned(),
arguments: Value::Object(request.arguments.unwrap_or_default()),
confirmation_token: scope.confirmation.clone(),
}),
)
.await;
let result = match outcome {
ToolsOutcome::Call(
ToolCallOutcome::Completed(output) | ToolCallOutcome::ApprovalPending(output),
) => Ok(super::response::sdk_success_tool_result(output).into()),
ToolsOutcome::Call(ToolCallOutcome::Error(error)) => {
Ok(super::response::sdk_error_tool_result(error).into())
}
ToolsOutcome::Call(ToolCallOutcome::ApprovalUnavailable(error)) => {
Ok(super::response::sdk_error_tool_result(
crate::tool_error::control_tool_error_contract(
error,
scope.correlation.request_id().as_str(),
scope.correlation.trace_id().as_str(),
scope.locale,
),
)
.into())
}
ToolsOutcome::Call(ToolCallOutcome::InvalidParams(detail))
| ToolsOutcome::InvalidParams(detail) => Err(ErrorData::invalid_params(detail, None)),
_ => Err(projection::internal()),
};
#[cfg(test)]
super::dispatch_observer::sdk_tools_call_handler_completed();
result
}
}
// Context seed only: close the inert transport before running domain code. No Peer callbacks.
async fn request_context(
handler: &Handler,
scope: Scope,
) -> Result<RequestContext<RoleServer>, ErrorData> {
let ping = serde_json::from_value(serde_json::json!({"jsonrpc":"2.0","id":1,"method":"ping"}))
.map_err(|_| projection::internal())?;
let (transport, receiver) = rmcp::transport::OneshotTransport::<RoleServer>::new(ping);
let info = InitializeRequestParams::new(
ClientCapabilities::default(),
Implementation::new("crank-tools-context", "1"),
)
.with_protocol_version(ProtocolVersion::V_2025_11_25);
let mut running = rmcp::service::serve_directly(handler.clone(), transport, Some(info));
let peer = running.peer().clone();
running.close().await.map_err(|_| projection::internal())?;
drop(receiver);
let mut context = RequestContext::new(RequestId::Number(1), peer);
context.extensions.insert(scope);
Ok(context)
}
pub(super) async fn handle(
state: &Arc<AppState>,
context: ServiceContext<'_>,
command: ToolsCommand,
lifecycle: Option<ToolCallLifecycle>,
) -> Outcome {
let (limit, confirmation) = match &command {
ToolsCommand::List(list) => (list.limit, None),
ToolsCommand::Call(call) => (None, call.confirmation_token.clone()),
};
let scope = Scope {
workspace: context.workspace_slug.to_owned(),
agent: context.agent_slug.to_owned(),
credential: context.credential.clone(),
correlation: context.correlation.clone(),
continuation: context.continuation,
locale: context.locale,
limit,
confirmation,
lifecycle,
};
let handler = Handler::new(state);
let context = match request_context(&handler, scope).await {
Ok(context) => context,
Err(error) => return Outcome::Error(error),
};
#[cfg(test)]
super::dispatch_observer::sdk_tools_dispatch_enter();
match command {
ToolsCommand::List(list) => {
let result = ServerHandler::list_tools(
&handler,
Some(PaginatedRequestParams::default().with_cursor(list.cursor)),
context,
)
.await;
let outcome = projection::consume_list(result, handler.take_extras());
#[cfg(test)]
super::dispatch_observer::sdk_tools_list_handler_consumed();
outcome
}
ToolsCommand::Call(call) => {
let Value::Object(arguments) = call.arguments else {
return Outcome::Error(ErrorData::invalid_params(
"tool arguments must be an object",
None,
));
};
let result = ServerHandler::call_tool(
&handler,
CallToolRequestParams::new(call.tool_name).with_arguments(arguments),
context,
)
.await;
let outcome = projection::consume_call(result);
#[cfg(test)]
super::dispatch_observer::sdk_tools_call_handler_consumed();
outcome
}
}
}
#[cfg(test)]
#[path = "../rmcp_tools_handler_tests.rs"]
mod tests;
@@ -27,7 +27,7 @@ impl DispatchEnvelope {
}
}
/// Call only after `validate_jsonrpc_envelope`; responses keep their existing non-SDK path.
/// Call only after `validate_jsonrpc_envelope`; responses use the separate response SDK classifier.
/// Params and extensions stay in the raw message, not in this routing-only projection.
pub(crate) fn decode_dispatch_envelope(
message: &Value,
@@ -135,7 +135,7 @@ mod tests {
}
#[test]
fn incoming_success_and_error_responses_are_not_migrated() {
fn incoming_success_and_error_responses_do_not_enter_method_dispatch() {
for message in [
json!({"jsonrpc": "2.0", "id": 1, "result": {}}),
json!({"jsonrpc": "2.0", "id": "id", "error": {"code": -1, "message": "error"}}),
@@ -1,14 +1,10 @@
//! Typed negotiation results; admission and session lifecycle remain in the HTTP adapter.
use rmcp::model::{
CacheScope, DiscoverResult, Implementation, InitializeRequestParams, InitializeResult,
PingRequest, ProtocolVersion, ServerCapabilities, ServerResult,
};
use rmcp::model::InitializeRequestParams;
#[cfg(test)]
use rmcp::model::{InitializeResult, ServerCapabilities};
use serde_json::Value;
use super::advertised_server_capabilities;
use crate::jsonrpc::SUPPORTED_PROTOCOL_VERSIONS;
pub(crate) fn initialize_params(
params: &Value,
) -> Result<InitializeRequestParams, serde_json::Error> {
@@ -20,16 +16,13 @@ pub(crate) fn initialize_params(
}))
}
fn protocol_version(revision: &str) -> ProtocolVersion {
serde_json::from_value(Value::String(revision.to_owned()))
.expect("served protocol revisions are strings")
}
#[cfg(test)]
fn capabilities(advertised: &Value) -> ServerCapabilities {
serde_json::from_value(advertised.clone())
.expect("registry capability fragments match SDK capability shapes")
}
#[cfg(test)]
fn restore_registry_extensions(result: &mut Value, advertised: Value) {
let capabilities = result["capabilities"]
.as_object_mut()
@@ -55,59 +48,6 @@ pub(crate) fn initialized_notification(message: &Value) -> rmcp::model::ClientNo
notification.into()
}
pub(crate) fn ping_result(message: &Value, revision: &str) -> Value {
// Ping params were ignored after admission; do not add SDK constraints to extensions.
let request: PingRequest = serde_json::from_value(serde_json::json!({
"method": message["method"]
}))
.expect("registry dispatched a validated ping request");
#[cfg(test)]
crate::app::dispatch_observer::sdk_ping_request_consumed(&request);
let result = match rmcp::model::ClientRequest::from(request) {
rmcp::model::ClientRequest::PingRequest(_) => ServerResult::empty(()),
_ => unreachable!("typed ping can only dispatch ping"),
};
let mut result = serde_json::to_value(result).expect("SDK ping result is serializable");
#[cfg(test)]
crate::app::dispatch_observer::sdk_ping_result_serialized();
// Crank keeps the admitted/session revision in addition to the SDK's empty ping result.
result["protocolVersion"] = Value::String(revision.to_owned());
result
}
pub(crate) fn initialize_result(revision: &str, name: &str, version: &str) -> Value {
let advertised = advertised_server_capabilities(revision);
let result = InitializeResult::new(capabilities(&advertised))
.with_protocol_version(protocol_version(revision))
.with_server_info(Implementation::new(name, version));
let mut result = serde_json::to_value(result)
.expect("SDK initialize result with registry capabilities is serializable");
#[cfg(test)]
crate::app::dispatch_observer::sdk_initialize_result_serialized();
restore_registry_extensions(&mut result, advertised);
result
}
pub(crate) fn discover_result(revision: &str, name: &str, version: &str) -> Value {
let advertised = advertised_server_capabilities(revision);
let result = DiscoverResult::new(
SUPPORTED_PROTOCOL_VERSIONS
.iter()
.map(|revision| protocol_version(revision))
.collect(),
capabilities(&advertised),
)
.with_server_info(Implementation::new(name, version))
.with_ttl_ms(0)
.with_cache_scope(CacheScope::Private);
let mut result = serde_json::to_value(result)
.expect("SDK discovery result with registry capabilities is serializable");
#[cfg(test)]
crate::app::dispatch_observer::sdk_discover_result_serialized();
restore_registry_extensions(&mut result, advertised);
result
}
#[cfg(test)]
mod tests {
use super::*;
+3 -48
View File
@@ -32,6 +32,7 @@ mod logging;
mod prompts;
mod registry;
mod resources;
mod response_sdk;
mod signals;
pub(crate) use dispatch_sdk::decode_dispatch_envelope;
@@ -44,9 +45,7 @@ pub(crate) use completion::{
CompletionArgument, CompletionCommand, CompletionOutcome, CompletionReference,
handle_completion_command,
};
pub(crate) use lifecycle_sdk::{
discover_result, initialize_params, initialize_result, initialized_notification, ping_result,
};
pub(crate) use lifecycle_sdk::{initialize_params, initialized_notification};
pub(crate) use logging::{
CarriedScope, EVENT_FAILED, EVENT_LEVEL_APPLIED, EVENT_REJECTED, EVENT_SERVED, INVALID_LEVEL,
LogLevel, LogLevelStore, LoggingOutcome, SetLevelCommand, carry_scope, handle_logging_command,
@@ -91,50 +90,6 @@ fn is_valid_request_id(id: &Value) -> bool {
id.is_string() || id.is_number()
}
/// The pinned error object: `Error { code: number; message: string; data?: unknown }`.
fn is_valid_error_object(error: Option<&Value>) -> bool {
let Some(Value::Object(error)) = error else {
return false;
};
error.get("code").is_some_and(Value::is_number)
&& error.get("message").is_some_and(Value::is_string)
}
/// Classify a wire response (a message without `method`).
///
/// Pinned shapes are exclusive: a success response carries `result: Result` (an object) and a required
/// `id: RequestId`, an error response carries `error: Error` and may omit the id (a present id must
/// still be a `RequestId`). Both together, neither, a foreign id, a non-object `result` or a malformed
/// error object are all invalid requests rather than an acknowledgement.
///
/// The `result` value is required to be an object because the pinned `JSONRPCResultResponse` types it as
/// `Result`; the modern `resultType` member is deliberately **not** required here, because an incoming
/// response may come from a client implementing an earlier revision.
fn classify_wire_response(object: &serde_json::Map<String, Value>) -> Option<EnvelopeKind> {
match (object.contains_key("result"), object.contains_key("error")) {
(true, false) => {
if !matches!(object.get("result"), Some(Value::Object(_))) {
return None;
}
object
.get("id")
.filter(|id| is_valid_request_id(id))
.map(|_| EnvelopeKind::Response)
}
(false, true) => {
if !is_valid_error_object(object.get("error")) {
return None;
}
match object.get("id") {
None => Some(EnvelopeKind::Response),
Some(id) if is_valid_request_id(id) => Some(EnvelopeKind::Response),
Some(_) => None,
}
}
_ => None,
}
}
/// Pinned modern wire projection of a success result.
///
/// `JSONRPCResultResponse.result` is a `Result`, and this revision requires the `resultType` member
@@ -260,7 +215,7 @@ pub(crate) fn validate_jsonrpc_envelope(message: &Value) -> Result<EnvelopeKind,
}
}
Some(_) => Err(rejected(invalid_request_response())),
None => match classify_wire_response(object) {
None => match response_sdk::classify_response(message) {
Some(kind) => Ok(kind),
None => Err(rejected(invalid_request_response())),
},
@@ -0,0 +1,223 @@
//! SDK classification of inbound responses, without narrowing the admitted wire numbers.
use rmcp::model::{JsonRpcError, JsonRpcResponse};
use serde_json::{Value, json};
use super::EnvelopeKind;
enum ResponseEnvelope {
Success(JsonRpcResponse<Value>),
Error(JsonRpcError),
}
/// Only the no-method branch of the envelope guard calls this helper.
pub(super) fn classify_response(message: &Value) -> Option<EnvelopeKind> {
match decode_response(message)? {
ResponseEnvelope::Success(JsonRpcResponse { result, .. }) => {
// The generic SDK result must still satisfy the pinned object-only contract.
if !result.is_object() {
return None;
}
#[cfg(test)]
crate::app::dispatch_observer::sdk_inbound_response_consumed();
Some(EnvelopeKind::Response)
}
ResponseEnvelope::Error(JsonRpcError { .. }) => {
#[cfg(test)]
crate::app::dispatch_observer::sdk_inbound_error_consumed();
Some(EnvelopeKind::Response)
}
}
}
fn decode_response(message: &Value) -> Option<ResponseEnvelope> {
let object = message.as_object()?;
if object.get("jsonrpc")?.as_str()? != "2.0" || object.contains_key("method") {
return None;
}
let id = object.get("id");
if id.is_some_and(|id| !id.is_string() && !id.is_number()) {
return None;
}
let mut projection = json!({"jsonrpc": "2.0"});
if let Some(id) = id {
// SDK ids are string/i64; this surrogate stays in the classification-only clone.
projection["id"] = if id.is_number() && id.as_i64().is_none() {
json!(0)
} else {
id.clone()
};
}
match (object.get("result"), object.get("error")) {
(Some(result), None) if result.is_object() && id.is_some() => {
projection["result"] = result.clone();
let response = serde_json::from_value::<JsonRpcResponse<Value>>(projection).ok()?;
#[cfg(test)]
crate::app::dispatch_observer::sdk_inbound_response_decoded();
Some(ResponseEnvelope::Success(response))
}
(None, Some(error)) if error.is_object() => {
let code = error.get("code")?;
if !code.is_number() || !error.get("message")?.is_string() {
return None;
}
projection["error"] = error.clone();
// SDK codes are i32; validate the original number before projecting only that field.
if code
.as_i64()
.and_then(|code| i32::try_from(code).ok())
.is_none()
{
projection["error"]["code"] = json!(0);
}
let error = serde_json::from_value::<JsonRpcError>(projection).ok()?;
#[cfg(test)]
crate::app::dispatch_observer::sdk_inbound_error_decoded();
Some(ResponseEnvelope::Error(error))
}
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn accepts_response_shapes_without_constraining_params_or_extensions() {
for message in [
json!({"jsonrpc": "2.0", "id": "", "result": {}}),
json!({"jsonrpc": "2.0", "id": 1, "result": {"resultType": false},
"params": false, "extension": [null, 1]}),
json!({"jsonrpc": "2.0", "error": {"code": -1, "message": ""}}),
json!({"jsonrpc": "2.0", "id": "id", "error": {
"code": -1, "message": "error", "data": [null, {"nested": true}]
}, "params": [], "extension": false}),
] {
let original = message.to_string();
assert_eq!(classify_response(&message), Some(EnvelopeKind::Response));
assert_eq!(message.to_string(), original);
}
}
#[test]
fn rejects_invalid_shapes_before_sdk_projection() {
for message in [
Value::Null,
json!([]),
json!({"id": 1, "result": {}}),
json!({"jsonrpc": "1.0", "id": 1, "result": {}}),
json!({"jsonrpc": "2.0"}),
json!({"jsonrpc": "2.0", "result": {}}),
json!({"jsonrpc": "2.0", "id": 1, "result": {}, "error": null}),
json!({"jsonrpc": "2.0", "id": 1, "result": null}),
json!({"jsonrpc": "2.0", "id": 1, "result": []}),
json!({"jsonrpc": "2.0", "id": 1, "result": true}),
json!({"jsonrpc": "2.0", "error": null}),
json!({"jsonrpc": "2.0", "error": []}),
json!({"jsonrpc": "2.0", "error": {"message": "error"}}),
json!({"jsonrpc": "2.0", "error": {"code": "-1", "message": "error"}}),
json!({"jsonrpc": "2.0", "error": {"code": null, "message": "error"}}),
json!({"jsonrpc": "2.0", "error": {"code": true, "message": "error"}}),
json!({"jsonrpc": "2.0", "error": {"code": -1}}),
json!({"jsonrpc": "2.0", "error": {"code": -1, "message": false}}),
json!({"jsonrpc": "2.0", "method": null, "id": 1, "result": {}}),
json!({"jsonrpc": "2.0", "method": "request", "id": 1, "result": {}}),
] {
assert_eq!(classify_response(&message), None, "{message}");
}
for id in [Value::Null, json!(true), json!([]), json!({})] {
for payload in [
json!({"result": {}}),
json!({"error": {"code": -1, "message": "e"}}),
] {
let mut message = payload;
message["jsonrpc"] = json!("2.0");
message["id"] = id.clone();
assert_eq!(classify_response(&message), None, "{message}");
}
}
}
#[test]
fn numeric_projection_preserves_raw_json_and_executes_typed_variants() {
let numbers = [
json!(i64::MIN),
json!(i64::MAX),
json!(u64::MAX),
json!(i32::MIN),
json!(i32::MAX),
json!(2147483648_i64),
json!(-2147483649_i64),
json!(1.25),
json!(1.0),
json!(-0.0),
json!(f64::MAX),
];
for number in numbers {
let sdk_id = if number.as_i64().is_some() {
number.clone()
} else {
json!(0)
};
let sdk_code = if number
.as_i64()
.and_then(|n| i32::try_from(n).ok())
.is_some()
{
number.clone()
} else {
json!(0)
};
for error in [false, true] {
let mut message = json!({"jsonrpc": "2.0", "id": number});
if error {
message["error"] = json!({"code": number, "message": "e", "data": number});
} else {
message["result"] = json!({"nested": [number, null]});
}
let original = message.to_string();
match decode_response(&message).expect("numeric wire shape decodes") {
ResponseEnvelope::Success(response) => {
assert!(!error);
assert_eq!(serde_json::to_value(response.id).unwrap(), sdk_id);
assert_eq!(response.result, message["result"]);
}
ResponseEnvelope::Error(response) => {
assert!(error);
assert_eq!(serde_json::to_value(response.id).unwrap(), sdk_id);
assert_eq!(serde_json::to_value(response.error.code).unwrap(), sdk_code);
assert_eq!(response.error.data.as_ref(), Some(&number));
}
}
assert_eq!(classify_response(&message), Some(EnvelopeKind::Response));
assert_eq!(message.to_string(), original);
}
}
}
#[test]
fn typed_error_keeps_optional_id_and_arbitrary_data() {
for data in [
Value::Null,
json!(true),
json!(1.0),
json!("text"),
json!([]),
json!({}),
] {
let message =
json!({"jsonrpc": "2.0", "error": {"code": -1, "message": "e", "data": data}});
let ResponseEnvelope::Error(error) = decode_response(&message).unwrap() else {
panic!("error must retain its SDK variant");
};
assert_eq!(error.id, None);
// SDK Option<Value> maps explicit null to None; classification never rewrites the wire.
assert_eq!(
error.error.data,
if data.is_null() { None } else { Some(data) }
);
assert_eq!(classify_response(&message), Some(EnvelopeKind::Response));
}
}
}
@@ -0,0 +1,30 @@
//! Completion actual ServerHandler execution/consumption observer oracle.
use super::{CounterSet, observe};
use std::sync::Arc;
pub(super) fn counts(c: &CounterSet) -> [usize; 2] {
[
c.sdk_completion_handler_completed(),
c.sdk_completion_handler_consumed(),
]
}
pub(super) fn delta(c: &CounterSet, before: [usize; 2]) -> ([usize; 2], [usize; 2]) {
let after = counts(c);
(std::array::from_fn(|i| after[i] - before[i]), [1, 1])
}
#[tokio::test]
async fn rmcp_completion_handler_observer_positive_control() {
use super::{sdk_completion_handler_completed, sdk_completion_handler_consumed};
let counters = Arc::new(CounterSet::default());
sdk_completion_handler_completed();
sdk_completion_handler_consumed();
assert_eq!(counts(&counters), [0, 0], "out-of-scope markers are no-ops");
observe(counters.clone(), async {
sdk_completion_handler_completed();
sdk_completion_handler_consumed();
})
.await;
assert_eq!(counts(&counters), [1, 1]);
}
@@ -0,0 +1,195 @@
//! Real trait execution, lossless request context, typed result consumption and drop ownership.
use super::*;
use serde_json::json;
use std::sync::{
Mutex,
atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst},
};
#[derive(Default)]
pub(super) struct Domain {
outcome: Mutex<Option<CompletionOutcome>>,
calls: AtomicUsize,
pending: bool,
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 complete(&self, command: CompletionCommand) -> CompletionOutcome {
self.calls.fetch_add(1, SeqCst);
assert!(
matches!(command.reference, CompletionReference::Resource { uri } if uri == "crank://bound/{region}")
);
assert_eq!(command.argument.name, "region");
assert_eq!(command.argument.value, "e");
assert_eq!(command.context.unwrap().arguments.unwrap(), args());
let _guard = DropWitness(&self.dropped);
if self.pending {
std::future::pending::<()>().await;
}
self.finished.store(true, SeqCst);
self.outcome
.lock()
.unwrap()
.take()
.expect("single domain execution")
}
}
fn args() -> Map<String, Value> {
json!({"number":42,"bool":true,"null":null,"array":["x"],"object":{"a":1}})
.as_object()
.unwrap()
.clone()
}
fn scope(revision: &str) -> Scope {
Scope {
workspace: "workspace".into(),
agent: "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("key".into()),
},
correlation: CorrelationContext::generate(),
continuation: protocol::ContinuationSupport::from_supported(false),
locale: ExecutionLocale::En,
revision: revision.into(),
context: Some(args()),
}
}
fn params() -> CompleteRequestParams {
CompleteRequestParams::new(
Reference::for_resource("crank://bound/{region}"),
ArgumentInfo::new("region", "e"),
)
}
async fn state() -> Arc<AppState> {
crank_test_support::postgres_schema_url_for_task("completion_handler_local", "t_7458fe3b")
.await;
super::super::rmcp_tools_tests::test_state().await
}
fn handler(state: &Arc<AppState>, outcome: CompletionOutcome, pending: bool) -> CompletionHandler {
CompletionHandler {
state: state.clone(),
domain: Some(Arc::new(Domain {
outcome: Mutex::new(Some(outcome)),
pending,
..Default::default()
})),
}
}
async fn context(h: &CompletionHandler, revision: &str) -> RequestContext<RoleServer> {
let c = request_context(h, scope(revision)).await.unwrap();
assert!(c.peer.is_transport_closed());
assert_eq!(
h.domain.as_ref().unwrap().calls.load(SeqCst),
0,
"bootstrap must not execute domain"
);
let s = CompletionHandler::scope(&c).unwrap();
assert_eq!(s.workspace, "workspace");
assert_eq!(s.agent, "agent");
assert_eq!(s.revision, revision);
assert_eq!(s.credential.platform_api_key_id.unwrap().as_str(), "key");
c
}
#[tokio::test]
async fn rmcp_completion_trait_result_is_consumed_and_domain_runs_once() {
let state = state().await;
for revision in ["2025-11-25", "2026-07-28"] {
let h = handler(
&state,
CompletionOutcome::Completed {
values: vec!["eu".into()],
total: Some(1),
has_more: false,
},
false,
);
let c = context(&h, revision).await;
let mut result = ServerHandler::complete(&h, params(), c).await.unwrap();
assert_eq!(result.completion.values, ["eu"]);
result.completion.values = vec!["typed".into()];
result.completion.total = None;
result.completion.has_more = Some(true);
match restore(Ok(result)) {
CompletionOutcome::Completed {
values,
total,
has_more,
} => {
assert_eq!(values, ["typed"]);
assert_eq!(total, None);
assert!(has_more);
}
_ => panic!("typed result not consumed"),
}
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
let h = handler(
&state,
CompletionOutcome::Completed {
values: vec![],
total: None,
has_more: false,
},
false,
);
let c = context(&h, revision).await;
let result = ServerHandler::complete(&h, params(), c).await.unwrap();
assert!(result.completion.values.is_empty());
assert_eq!(result.completion.total, None);
}
}
#[tokio::test]
async fn rmcp_completion_dropping_trait_future_drops_pending_domain() {
let state = state().await;
for revision in ["2025-11-25", "2026-07-28"] {
let h = handler(&state, CompletionOutcome::CatalogUnavailable, true);
let c = context(&h, revision).await;
let domain = h.domain.as_ref().unwrap();
let mut future = Box::pin(ServerHandler::complete(&h, params(), c));
assert!(futures_util::poll!(&mut future).is_pending());
assert_eq!(domain.calls.load(SeqCst), 1);
assert!(!domain.dropped.load(SeqCst));
drop(future);
assert!(domain.dropped.load(SeqCst));
tokio::task::yield_now().await;
assert!(!domain.finished.load(SeqCst));
assert_eq!(domain.calls.load(SeqCst), 1);
}
}
#[tokio::test]
async fn rmcp_completion_trait_errors_remain_safe() {
let state = state().await;
for outcome in [
CompletionOutcome::InvalidParams("invalid completion/complete parameters"),
CompletionOutcome::NotAvailable,
CompletionOutcome::CatalogUnavailable,
] {
let h = handler(&state, outcome, false);
let c = context(&h, "2026-07-28").await;
let result = ServerHandler::complete(&h, params(), c).await;
assert!(result.is_err());
let error = result.as_ref().unwrap_err();
assert!(!error.to_string().contains("crank://bound"));
match error.code {
ErrorCode::INVALID_PARAMS => assert!(matches!(
restore(result),
CompletionOutcome::InvalidParams(_) | CompletionOutcome::NotAvailable
)),
ErrorCode::INTERNAL_ERROR => assert!(matches!(
restore(result),
CompletionOutcome::CatalogUnavailable
)),
_ => panic!("unexpected error"),
}
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
}
}
@@ -6,6 +6,7 @@ use serde_json::{Value, json};
use std::{sync::Arc, time::Duration};
#[path = "rmcp_completion_test_support.rs"]
mod fixtures;
use super::rmcp_completion_handler_runtime_tests as handler;
use fixtures::{BOUNDED_URI, Endpoint, LARGE_URI, URI};
fn observe_body(response: Response, counters: Arc<CounterSet>) -> Response {
@@ -89,8 +90,10 @@ async fn success(
session: Option<&str>,
p: Value,
sse: bool,
require_handler: bool,
) -> (Value, [usize; 2]) {
let before = counts(&h.counters);
let handler_before = handler::counts(&h.counters);
let body = wire(
h.post(revision, session, &request(revision, p), sse).await,
sse,
@@ -107,12 +110,19 @@ async fn success(
assert!(result.get(key).is_none(), "{body}");
}
let after = counts(&h.counters);
let handler_delta = handler::delta(&h.counters, handler_before);
if require_handler {
assert_eq!(
handler_delta.0, handler_delta.1,
"actual completion handler execution/consumption: {handler_delta:?}"
);
}
(
result["completion"].clone(),
std::array::from_fn(|i| after[i] - before[i]),
)
}
async fn control(revision: &str) -> Vec<[usize; 2]> {
async fn control(revision: &str, require_handler: bool) -> Vec<[usize; 2]> {
let h = Endpoint::started().await;
let session = h.session(revision).await;
let session = session.as_deref();
@@ -149,7 +159,7 @@ async fn control(revision: &str) -> Vec<[usize; 2]> {
json!({"values":[],"total":0}),
),
] {
let (completion, delta) = success(&h, revision, session, p, sse).await;
let (completion, delta) = success(&h, revision, session, p, sse, require_handler).await;
assert_eq!(completion, expected);
deltas.push(delta);
}
@@ -160,6 +170,7 @@ async fn control(revision: &str) -> Vec<[usize; 2]> {
session,
params(resource(uri), "region", "item"),
sse,
require_handler,
)
.await;
assert_eq!(
@@ -179,7 +190,8 @@ async fn control(revision: &str) -> Vec<[usize; 2]> {
}
let mut with_context = params(prompt("greeting"), "tone", "w");
with_context["context"] = json!({"arguments":{"name":"Ada","tone":"dry"}});
let (completion, delta) = success(&h, revision, session, with_context, sse).await;
let (completion, delta) =
success(&h, revision, session, with_context, sse, require_handler).await;
assert_eq!(completion, json!({"values":["warm"],"total":1}));
deltas.push(delta);
let mut unavailable = None;
@@ -284,15 +296,15 @@ async fn control(revision: &str) -> Vec<[usize; 2]> {
}
#[tokio::test]
async fn rmcp_completion_wire_legacy() {
control(LEGACY_REVISION).await;
control(LEGACY_REVISION, false).await;
}
#[tokio::test]
async fn rmcp_completion_wire_modern() {
control(MODERN_REVISION).await;
control(MODERN_REVISION, false).await;
}
#[tokio::test]
async fn rmcp_completion_sdk_legacy() {
let deltas = control(LEGACY_REVISION).await;
let deltas = control(LEGACY_REVISION, true).await;
assert!(
deltas.iter().all(|d| *d == [1, 1]),
"SDK typed dispatch/result missing after successful HTTP: {deltas:?}"
@@ -300,7 +312,7 @@ async fn rmcp_completion_sdk_legacy() {
}
#[tokio::test]
async fn rmcp_completion_sdk_modern() {
let deltas = control(MODERN_REVISION).await;
let deltas = control(MODERN_REVISION, true).await;
assert!(
deltas.iter().all(|d| *d == [1, 1]),
"SDK typed dispatch/result missing after successful HTTP: {deltas:?}"
@@ -395,7 +395,7 @@ async fn rmcp_initialize_input_observer_positive_control() {
super::sdk_initialize_input_consumed(&params);
assert_eq!(c.sdk_initialize_input(), 1);
assert_eq!(
c.sdk_initialize_result(),
c.sdk_initialize_handler_consumed(),
0,
"input and output are independent"
);
@@ -7,7 +7,10 @@ use std::{sync::Arc, time::Duration};
use super::rmcp_progress_cancel_runtime_tests::fixtures::Endpoint;
fn sdk_counts(c: &CounterSet) -> [usize; 2] {
[c.sdk_initialize_result(), c.sdk_discover_result()]
[
c.sdk_initialize_handler_consumed(),
c.sdk_discover_handler_consumed(),
]
}
fn capabilities() -> Value {
@@ -197,19 +200,19 @@ async fn rmcp_lifecycle_negotiation_observer_positive_control() {
let c = Arc::new(CounterSet::default());
observe(c.clone(), async {
super::admission_enter();
super::sdk_initialize_result_serialized();
super::sdk_initialize_handler_consumed();
assert_eq!(
sdk_counts(&c),
[1, 0],
"initialize and discovery are separate markers"
);
super::sdk_discover_result_serialized();
super::sdk_discover_handler_consumed();
})
.await;
assert_eq!(sdk_counts(&c), [1, 1]);
assert_eq!(c.snapshot(), super::Snapshot::new(1, 0, 0, 0));
super::sdk_initialize_result_serialized();
super::sdk_discover_result_serialized();
super::sdk_initialize_handler_consumed();
super::sdk_discover_handler_consumed();
assert_eq!(sdk_counts(&c), [1, 1], "out-of-scope markers are no-ops");
}
@@ -0,0 +1,139 @@
//! Behavioral RED for real negotiation/ping handler execution and result consumption.
use super::rmcp_progress_cancel_runtime_tests::fixtures::Endpoint;
use super::{CounterSet, observe, support::*};
use serde_json::{Value, json};
use std::{sync::Arc, time::Duration};
async fn request(
h: &Endpoint,
revision: &str,
payload: Value,
accept: &str,
session: Option<&str>,
) -> reqwest::Response {
h.request(revision, session, &h.key, accept, payload)
.header("x-request-id", "negotiation-handler-atdd")
.header(
"traceparent",
"00-11111111111111111111111111111111-2222222222222222-01",
)
.send()
.await
.unwrap()
}
async fn terminal(response: reqwest::Response, sse: bool) -> Value {
assert_eq!(response.status(), 200);
let raw = tokio::time::timeout(Duration::from_secs(6), response.text())
.await
.unwrap()
.unwrap();
if sse {
let frames: Vec<Value> = raw
.lines()
.filter_map(|line| line.strip_prefix("data:"))
.map(|line| serde_json::from_str(line.trim()).unwrap())
.collect();
assert_eq!(frames.len(), 1, "single terminal response frame");
frames.into_iter().next().unwrap()
} else {
serde_json::from_str(&raw).unwrap()
}
}
fn handler_counts(c: &CounterSet) -> [usize; 6] {
[
c.sdk_initialize_handler_completed(),
c.sdk_initialize_handler_consumed(),
c.sdk_discover_handler_completed(),
c.sdk_discover_handler_consumed(),
c.sdk_ping_handler_completed(),
c.sdk_ping_handler_consumed(),
]
}
fn delta(after: [usize; 6], before: [usize; 6]) -> [usize; 6] {
std::array::from_fn(|index| after[index] - before[index])
}
#[tokio::test]
async fn rmcp_negotiation_handler_http_executes_and_consumes_initialize_discover_and_ping() {
crank_test_support::postgres_schema_url_for_task("negotiation_handler_owner", "t_219756db")
.await;
let h = Endpoint::started().await;
let session = h.session(LEGACY_REVISION).await;
let before_all = handler_counts(&h.counters);
for (revision, method, session) in [
(LEGACY_REVISION, "initialize", None),
(MODERN_REVISION, "server/discover", None),
] {
let mut payload = if method == "initialize" {
legacy_initialize(1)
} else {
json!({"jsonrpc":"2.0","id":1,"method":method,"params":{"_meta":modern_meta()}})
};
for accept in ["application/json", "text/event-stream, application/json"] {
if method == "initialize" {
payload["id"] = json!(if accept.starts_with("text/event") {
2
} else {
1
});
}
let response = request(&h, revision, payload.clone(), accept, session).await;
let body = terminal(response, accept.starts_with("text/event")).await;
assert_eq!(body["jsonrpc"], "2.0");
}
}
for revision in [LEGACY_REVISION, MODERN_REVISION] {
for accept in ["application/json", "text/event-stream, application/json"] {
let payload = json!({"jsonrpc":"2.0","id":"ping","method":"ping","params":{"_meta":if revision == MODERN_REVISION { modern_meta() } else { json!({"future":true}) }}});
let response = request(
&h,
revision,
payload,
accept,
if revision == LEGACY_REVISION {
session.as_deref()
} else {
None
},
)
.await;
let body = terminal(response, accept.starts_with("text/event")).await;
assert_eq!(body["id"], "ping");
assert!(body.get("error").is_none());
if revision == LEGACY_REVISION {
assert_eq!(body["result"]["protocolVersion"], LEGACY_REVISION);
}
}
}
let after = handler_counts(&h.counters);
assert_eq!(
delta(after, before_all),
[2, 2, 2, 2, 4, 4],
"successful initialize/discover/ping HTTP responses must complete in and consume their SDK handler results"
);
}
#[tokio::test]
async fn rmcp_negotiation_handler_observer_positive_control() {
let c = Arc::new(CounterSet::default());
observe(c.clone(), async {
super::sdk_initialize_handler_completed();
super::sdk_initialize_handler_consumed();
super::sdk_discover_handler_completed();
super::sdk_discover_handler_consumed();
super::sdk_ping_handler_completed();
super::sdk_ping_handler_consumed();
assert_eq!(handler_counts(&c), [1; 6]);
})
.await;
assert_eq!(handler_counts(&c), [1; 6]);
super::sdk_initialize_handler_completed();
assert_eq!(
handler_counts(&c),
[1; 6],
"markers outside observer scope are inert"
);
}
@@ -0,0 +1,209 @@
//! The production adapters consume actual trait results and own their pending work.
use super::*;
#[tokio::test]
async fn rmcp_negotiation_handler_qa_discover_uses_requested_revision_capabilities() {
use crate::protocol::{
CAPABILITY_DESCRIPTORS, CapabilityId, CapabilityRegistry, METHOD_DESCRIPTORS,
};
use std::sync::Arc;
let mut outcomes = Vec::new();
for revisions in [&["2026-07-28"][..], &["2025-11-25"][..]] {
let mut descriptors = CAPABILITY_DESCRIPTORS.to_vec();
descriptors
.iter_mut()
.find(|d| d.id == CapabilityId::Tools)
.unwrap()
.revisions = revisions;
let registration =
Arc::new(CapabilityRegistry::new(&descriptors, METHOD_DESCRIPTORS).unwrap());
crate::app::dispatch_observer::observe_with_registration(registration, async {
let expected = advertised_server_capabilities("2026-07-28");
let actual = discover("2026-07-28").await.unwrap();
outcomes.push((
expected["tools"].clone(),
actual["capabilities"]["tools"].clone(),
));
})
.await;
}
assert_eq!(
outcomes,
vec![
(json!({"listChanged":true}), json!({"listChanged":true})),
(Value::Null, Value::Null)
],
"modern-only tools must be advertised; legacy-only tools must not leak into modern discovery"
);
}
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
#[derive(Default)]
struct Control {
calls: AtomicUsize,
dropped: AtomicBool,
finished: AtomicBool,
fail: bool,
pending: bool,
}
struct Witness<'a>(&'a AtomicBool);
impl Drop for Witness<'_> {
fn drop(&mut self) {
self.0.store(true, SeqCst);
}
}
fn error() -> ErrorData {
ErrorData::new(
ErrorCode(-32042),
"typed negotiation failure",
Some(json!({"proof":42})),
)
}
impl Control {
async fn enter(&self, context: &RequestContext<RoleServer>) -> Result<(), ErrorData> {
assert!(
context.peer.is_transport_closed(),
"bootstrap closes before handler"
);
self.calls.fetch_add(1, SeqCst);
let _witness = Witness(&self.dropped);
if self.pending {
std::future::pending::<()>().await;
}
self.finished.store(true, SeqCst);
if self.fail { Err(error()) } else { Ok(()) }
}
}
impl ServerHandler for Control {
async fn initialize(
&self,
request: InitializeRequestParams,
context: RequestContext<RoleServer>,
) -> Result<InitializeResult, ErrorData> {
self.enter(&context).await?;
let mut result = ServerHandler::initialize(&NegotiationHandler, request, context).await?;
result.server_info = Implementation::new("typed-initialize", "42");
result.capabilities.tools = None;
Ok(result)
}
async fn discover(
&self,
context: RequestContext<RoleServer>,
) -> Result<DiscoverResult, ErrorData> {
self.enter(&context).await?;
let mut result = ServerHandler::discover(&NegotiationHandler, context).await?;
result = result.with_server_info(Implementation::new("typed-discover", "42"));
result.capabilities.tools = None;
Ok(result)
}
async fn ping(&self, context: RequestContext<RoleServer>) -> Result<(), ErrorData> {
self.enter(&context).await
}
}
#[tokio::test]
async fn rmcp_negotiation_handler_mutated_typed_success_is_consumed() {
let h = Control::default();
let init = initialize_with(&h, "2025-11-25").await.unwrap();
assert_eq!(init["serverInfo"]["name"], "typed-initialize");
assert!(init["capabilities"].get("tools").is_none());
let discover = discover_with(&h, "2026-07-28").await.unwrap();
assert_eq!(
discover["_meta"]["io.modelcontextprotocol/serverInfo"]["name"],
"typed-discover"
);
assert!(discover["capabilities"].get("tools").is_none());
ping_with(&h).await.unwrap();
assert_eq!(h.calls.load(SeqCst), 3, "no bootstrap invocation");
}
#[tokio::test]
async fn rmcp_negotiation_handler_typed_errors_are_not_success() {
let h = Control {
fail: true,
..Default::default()
};
for actual in [
initialize_with(&h, "2025-11-25").await.unwrap_err(),
discover_with(&h, "2026-07-28").await.unwrap_err(),
ping_with(&h).await.unwrap_err(),
] {
assert_eq!(actual, error());
for mode in [
crate::transport::ResponseMode::Json,
crate::transport::ResponseMode::Sse,
] {
let response = super::super::dispatch::sdk_error_response(
&json!({"id":"typed-error"}),
mode,
"2025-11-25",
actual.clone(),
);
assert_eq!(response.status(), 200);
assert!(response.headers().get("mcp-session-id").is_none());
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.unwrap();
let raw = std::str::from_utf8(&bytes).unwrap();
let body: Value = match mode {
crate::transport::ResponseMode::Json => serde_json::from_str(raw).unwrap(),
crate::transport::ResponseMode::Sse => serde_json::from_str(
raw.lines()
.find_map(|l| l.strip_prefix("data:"))
.unwrap()
.trim(),
)
.unwrap(),
};
assert_eq!(
body,
json!({"jsonrpc":"2.0","id":"typed-error","error":{"code":-32042,"message":"typed negotiation failure","data":{"proof":42}}})
);
}
}
assert_eq!(h.calls.load(SeqCst), 3);
assert!(initialize("not-supported").await.is_err());
assert_eq!(
NegotiationHandler
.supported_protocol_versions()
.iter()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
SUPPORTED_PROTOCOL_VERSIONS
);
}
#[tokio::test]
async fn rmcp_negotiation_handler_drop_cancels_request_owned_work() {
for method in 0..3 {
let h = Control {
pending: true,
..Default::default()
};
let mut future = Box::pin(async {
match method {
0 => {
initialize_with(&h, "2025-11-25").await?;
}
1 => {
discover_with(&h, "2026-07-28").await?;
}
_ => {
ping_with(&h).await?;
}
}
Ok::<_, ErrorData>(())
});
tokio::select! {
result = &mut future => panic!("pending handler completed: {result:?}"),
_ = async { while h.calls.load(SeqCst) == 0 { tokio::task::yield_now().await; } } => {}
}
assert!(!h.dropped.load(SeqCst));
drop(future);
assert!(h.dropped.load(SeqCst));
tokio::task::yield_now().await;
assert!(!h.finished.load(SeqCst));
assert_eq!(h.calls.load(SeqCst), 1);
}
}
@@ -75,7 +75,10 @@ async fn success_control(revision: &str) -> Vec<(usize, usize)> {
] {
let counters = h.counters.snapshot();
let ops = h.sessions.snapshot();
let before = (h.counters.sdk_ping_request(), h.counters.sdk_ping_result());
let before = (
h.counters.sdk_ping_handler_completed(),
h.counters.sdk_ping_handler_consumed(),
);
let response = correlated(h.request(
revision,
session.as_deref(),
@@ -118,8 +121,8 @@ async fn success_control(revision: &str) -> Vec<(usize, usize)> {
},
);
sdk.push((
h.counters.sdk_ping_request() - before.0,
h.counters.sdk_ping_result() - before.1,
h.counters.sdk_ping_handler_completed() - before.0,
h.counters.sdk_ping_handler_consumed() - before.1,
));
eprintln!(
"existing GREEN ping revision={revision} accept={accept} extended={extended}; SDK delta={:?}",
@@ -176,9 +179,20 @@ async fn ping_guards_never_enter_sdk() {
assert!(wire.get("result").is_none());
}
assert_eq!(
(h.counters.sdk_ping_request(), h.counters.sdk_ping_result()),
(
h.counters.sdk_ping_handler_completed(),
h.counters.sdk_ping_handler_consumed()
),
(0, 0)
);
assert_eq!(
(
h.counters.sdk_ping_handler_completed(),
h.counters.sdk_ping_handler_consumed()
),
(0, 0),
"pre-handler guard rejection must not execute or consume the SDK ping handler"
);
eprintln!("existing GREEN pre-seam guard revision={revision}; SDK=(0,0)");
}
}
@@ -186,24 +200,37 @@ async fn ping_guards_never_enter_sdk() {
#[tokio::test]
async fn ping_observer_positive_control() {
let c = Arc::new(CounterSet::default());
let request: rmcp::model::PingRequest =
serde_json::from_value(json!({"method":"ping"})).unwrap();
observe(c.clone(), async {
super::sdk_ping_request_consumed(&request);
assert_eq!((c.sdk_ping_request(), c.sdk_ping_result()), (1, 0));
super::sdk_ping_result_serialized();
assert_eq!((c.sdk_ping_request(), c.sdk_ping_result()), (1, 1));
super::sdk_ping_handler_completed();
assert_eq!(
(
c.sdk_ping_handler_completed(),
c.sdk_ping_handler_consumed()
),
(1, 0)
);
super::sdk_ping_handler_consumed();
assert_eq!(
(
c.sdk_ping_handler_completed(),
c.sdk_ping_handler_consumed()
),
(1, 1)
);
})
.await;
super::sdk_ping_request_consumed(&request);
super::sdk_ping_result_serialized();
super::sdk_ping_handler_completed();
super::sdk_ping_handler_consumed();
observe(Arc::new(CounterSet::default()), async {
super::sdk_ping_request_consumed(&request);
super::sdk_ping_result_serialized();
super::sdk_ping_handler_completed();
super::sdk_ping_handler_consumed();
})
.await;
assert_eq!(
(c.sdk_ping_request(), c.sdk_ping_result()),
(
c.sdk_ping_handler_completed(),
c.sdk_ping_handler_consumed()
),
(1, 1),
"scope isolation and out-of-scope no-op"
);
@@ -0,0 +1,71 @@
//! Handler completion/consumption is independent of the existing DTO wire oracle.
use super::{CounterSet, observe, rmcp_prompts_runtime_tests::control, support::*};
use std::sync::Arc;
pub(super) fn counts(c: &CounterSet) -> [usize; 4] {
[
c.sdk_prompts_list_handler_completed(),
c.sdk_prompts_get_handler_completed(),
c.sdk_prompts_list_handler_consumed(),
c.sdk_prompts_get_handler_consumed(),
]
}
pub(super) fn delta(c: &CounterSet, before: [usize; 4], method: &str) -> ([usize; 4], [usize; 4]) {
let after = counts(c);
let expected = match method {
"prompts/list" => [1, 0, 1, 0],
"prompts/get" => [0, 1, 0, 1],
_ => panic!("not a Prompts method: {method}"),
};
(std::array::from_fn(|i| after[i] - before[i]), expected)
}
#[tokio::test]
async fn rmcp_prompts_handler_legacy() {
control(LEGACY_REVISION, true).await;
}
#[tokio::test]
async fn rmcp_prompts_handler_modern() {
control(MODERN_REVISION, true).await;
}
#[tokio::test]
async fn rmcp_prompts_handler_observer_positive_control() {
use super::{
sdk_prompts_get_handler_completed, sdk_prompts_get_handler_consumed,
sdk_prompts_list_handler_completed, sdk_prompts_list_handler_consumed,
};
let a = Arc::new(CounterSet::default());
let b = Arc::new(CounterSet::default());
sdk_prompts_list_handler_completed();
sdk_prompts_get_handler_completed();
sdk_prompts_list_handler_consumed();
sdk_prompts_get_handler_consumed();
assert_eq!(counts(&a), [0; 4], "no-scope markers must be no-ops");
let snapshot = a.snapshot();
tokio::join!(
observe(a.clone(), async {
sdk_prompts_list_handler_completed();
tokio::task::yield_now().await;
sdk_prompts_get_handler_completed();
sdk_prompts_list_handler_consumed();
sdk_prompts_get_handler_consumed();
}),
observe(b.clone(), async {
sdk_prompts_get_handler_completed();
tokio::task::yield_now().await;
sdk_prompts_get_handler_consumed();
}),
);
assert_eq!(counts(&a), [1; 4]);
assert_eq!(counts(&b), [0, 1, 0, 1]);
assert_eq!(a.snapshot(), snapshot);
assert_eq!(b.snapshot(), CounterSet::default().snapshot());
for c in [&a, &b] {
assert_eq!(c.sdk_prompts_dispatch(), 0);
assert_eq!(c.sdk_prompts_list_result(), 0);
assert_eq!(c.sdk_prompts_get_result(), 0);
}
}
@@ -0,0 +1,392 @@
//! Synthetic replies exercise real trait results, restoration and structured cancellation.
use super::*;
use serde_json::json;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
#[derive(Default)]
pub(super) struct Domain {
outcome: Mutex<Option<PromptsOutcome>>,
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 prompts(&self, command: PromptsCommand) -> PromptsOutcome {
self.calls.fetch_add(1, SeqCst);
match command {
PromptsCommand::List(list) => {
assert_eq!(list.limit, Some(7));
assert_eq!(list.cursor.as_deref(), Some("opaque"));
}
PromptsCommand::Get(get) => {
assert_eq!(get.name, "bound-prompt");
assert_eq!(
get.arguments,
Some(
json!({"number":42,"enabled":true,"nested":[null]})
.as_object()
.unwrap()
.clone()
)
);
}
}
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")
}
}
fn scope(revision: &str) -> PromptScope {
PromptScope {
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<AppState> {
crank_test_support::postgres_schema_url_for_task("prompts_handler_local", "t_2d797361").await;
super::super::rmcp_tools_tests::test_state().await
}
fn handler(state: &Arc<AppState>, outcome: PromptsOutcome) -> PromptHandler {
let mut handler = PromptHandler::new(state);
handler.domain = Some(Arc::new(Domain {
outcome: Mutex::new(Some(outcome)),
..Default::default()
}));
handler
}
fn page() -> Option<PaginatedRequestParams> {
Some(PaginatedRequestParams::default().with_cursor(Some("opaque".into())))
}
fn get() -> GetPromptRequestParams {
let mut request = GetPromptRequestParams::new("bound-prompt");
request.arguments = Some(
json!({"number":42,"enabled":true,"nested":[null]})
.as_object()
.unwrap()
.clone(),
);
request
}
async fn context(handler: &PromptHandler, revision: &str) -> RequestContext<RoleServer> {
let context = request_context(handler, scope(revision)).await.unwrap();
assert!(context.peer.is_transport_closed());
assert_eq!(
Arc::strong_count(&handler.reply),
1,
"seed service released handler"
);
assert_eq!(handler.domain.as_ref().unwrap().calls.load(SeqCst), 0);
let actual = PromptHandler::scope(&context).unwrap();
assert_eq!(actual.workspace_slug, "fresh-workspace");
assert_eq!(actual.agent_slug, "fresh-agent");
assert_eq!(
actual
.credential
.platform_api_key_id
.as_ref()
.map(|id| id.as_str()),
Some("fresh-key")
);
assert_eq!(actual.revision, revision);
context
}
fn assert_list(outcome: PromptsOutcome, raw: Vec<Value>, cursor: Option<&str>) {
match outcome {
PromptsOutcome::Listed {
prompts,
next_cursor,
} => {
assert_eq!(prompts, raw);
assert_eq!(next_cursor.as_deref(), cursor);
}
_ => panic!("list restore failed"),
}
}
fn assert_get(outcome: PromptsOutcome, raw: Vec<Value>, expected: Option<&str>) {
match outcome {
PromptsOutcome::Got {
description,
messages,
} => {
assert_eq!(messages, raw);
assert_eq!(description.as_deref(), expected);
}
_ => panic!("get restore failed"),
}
}
#[tokio::test]
async fn rmcp_prompts_trait_lossless_and_actual_typed_mutations_consumed() {
let state = state().await;
for revision in ["2025-11-25", "2026-07-28"] {
let raw = vec![
json!({"name":"a","description":null,"icons":{"not":"SDK array"},"annotations":false,"x":[null,{"nested":true}],"arguments":[{"name":"n","required":null,"description":null,"type":"integer","default":42,"enum":[1,42],"x":null}]}),
json!({"name":"b","arguments":null}),
json!({"name":"c"}),
];
let h = handler(
&state,
PromptsOutcome::Listed {
prompts: raw.clone(),
next_cursor: Some("next".into()),
},
);
let c = context(&h, revision).await;
let mut result = ServerHandler::list_prompts(&h, page(), c).await.unwrap();
result.prompts[0].title = Some("typed-title".into());
result.prompts[0].arguments.as_mut().unwrap()[0].title = Some("typed-argument".into());
result.next_cursor = Some("typed-cursor".into());
let mut expected = raw;
expected[0]["title"] = json!("typed-title");
expected[0]["arguments"][0]["title"] = json!("typed-argument");
assert_list(restore_list(&h, Ok(result)), expected, Some("typed-cursor"));
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
let text = serde_json::to_string_pretty(&json!({"exact":[null,true]})).unwrap();
let raw = vec![
json!({"role":"system","content":{"type":"text","text":text,"annotations":[null,42],"x":null},"x":{"nested":true}}),
json!({"role":"user","content":{"type":"image","data":"AAEC/w==","mimeType":"image/png","annotations":false,"x":[1,null]}}),
json!({"role":"assistant","content":{"type":"audio","data":"AAEC/w==","mimeType":"audio/wav"}}),
json!({"role":"user","content":{"type":"resource","resource":{"uri":"crank://text","text":"exact\nbytes","mimeType":null,"x":[null]},"annotations":{"arbitrary":true}}}),
json!({"role":"user","content":{"type":"resource","resource":{"uri":"crank://blob","blob":"AAEC/w==","x":false},"x":null}}),
json!({"role":"user","content":{"type":"resource_link","uri":"crank://link","name":"link","description":null,"icons":false,"annotations":42,"x":{"a":null}}}),
];
let h = handler(
&state,
PromptsOutcome::Got {
description: None,
messages: raw.clone(),
},
);
let c = context(&h, revision).await;
let GetPromptResponse::Complete(mut result) =
ServerHandler::get_prompt(&h, get(), c).await.unwrap()
else {
panic!("expected complete prompt")
};
result.description = Some("typed-description".into());
// Content is mutated through the SDK result, not the original domain JSON.
let mut message = serde_json::to_value(&result.messages[0]).unwrap();
message["content"]["text"] = json!("typed-text");
result.messages[0] = serde_json::from_value(message).unwrap();
let mut expected = raw;
expected[0]["content"]["text"] = json!("typed-text");
assert_get(
restore_get(&h, Ok(result.into())),
expected,
Some("typed-description"),
);
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
let h = handler(
&state,
PromptsOutcome::Got {
description: None,
messages: vec![],
},
);
let c = context(&h, revision).await;
let result = ServerHandler::get_prompt(&h, get(), c).await;
assert_get(restore_get(&h, result), vec![], None);
}
}
#[tokio::test]
async fn rmcp_prompts_trait_errors_fail_closed_without_reexecution() {
let state = state().await;
for is_list in [true, false] {
for outcome in [
PromptsOutcome::InvalidParams("exact-detail".into()),
PromptsOutcome::NotAvailable,
PromptsOutcome::ArgumentsRejected {
reason: "wrong_type",
argument: Some("number".into()),
},
PromptsOutcome::ArgumentsRejected {
reason: "missing",
argument: None,
},
PromptsOutcome::DependencyUnavailable { position: 13 },
PromptsOutcome::CatalogUnavailable,
] {
let expected = std::mem::discriminant(&outcome);
let h = handler(&state, outcome);
let c = context(&h, "2026-07-28").await;
let actual = if is_list {
let result = ServerHandler::list_prompts(&h, page(), c).await;
assert!(result.is_err());
restore_list(&h, result)
} else {
let result = ServerHandler::get_prompt(&h, get(), c).await;
assert!(result.is_err());
restore_get(&h, result)
};
assert_eq!(std::mem::discriminant(&actual), expected);
match actual {
PromptsOutcome::InvalidParams(detail) => assert_eq!(detail, "exact-detail"),
PromptsOutcome::ArgumentsRejected { reason, argument } => {
assert_eq!(
reason,
if argument.is_some() {
"wrong_type"
} else {
"missing"
}
);
if let Some(argument) = argument {
assert_eq!(argument, "number");
}
}
PromptsOutcome::DependencyUnavailable { position } => assert_eq!(position, 13),
_ => {}
}
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
}
}
let h = handler(
&state,
PromptsOutcome::Listed {
prompts: vec![json!({"description":"missing name"})],
next_cursor: None,
},
);
let c = context(&h, "2026-07-28").await;
let result = ServerHandler::list_prompts(&h, page(), c).await;
assert!(result.is_err());
assert!(matches!(
restore_list(&h, result),
PromptsOutcome::CatalogUnavailable
));
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
for message in [
json!({"role":"invalid","content":{"type":"text","text":"x"}}),
json!({"role":"user","content":{"type":"text"}}),
] {
let h = handler(
&state,
PromptsOutcome::Got {
description: None,
messages: vec![message],
},
);
let c = context(&h, "2026-07-28").await;
let result = ServerHandler::get_prompt(&h, get(), c).await;
assert!(result.is_err());
assert!(matches!(
restore_get(&h, result),
PromptsOutcome::CatalogUnavailable
));
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
}
for change in 0..3 {
let h = handler(
&state,
PromptsOutcome::Listed {
prompts: vec![json!({"name":"a","x":1}), json!({"name":"b","x":2})],
next_cursor: None,
},
);
let mut c = context(&h, "2026-07-28").await;
c.extensions = Default::default();
assert!(ServerHandler::list_prompts(&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_prompts(&h, page(), c).await.unwrap();
let result = match change {
0 => {
result.prompts.clear();
Ok(result)
}
1 => {
result.prompts.swap(0, 1);
Ok(result)
}
_ => Err(internal()),
};
assert!(matches!(
restore_list(&h, result),
PromptsOutcome::CatalogUnavailable
));
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
}
let h = handler(
&state,
PromptsOutcome::Got {
description: None,
messages: vec![],
},
);
let c = context(&h, "2026-07-28").await;
let result = ServerHandler::list_prompts(&h, page(), c).await;
assert!(result.is_err());
assert!(matches!(
restore_list(&h, result),
PromptsOutcome::CatalogUnavailable
));
assert!(matches!(
restore_get(&h, Err(internal())),
PromptsOutcome::CatalogUnavailable
));
}
#[tokio::test]
async fn rmcp_prompts_parent_drop_cancels_domain_and_bootstrap_is_closed() {
let state = state().await;
for is_list in [true, false] {
let mut h = PromptHandler::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(async {
if is_list {
let result = ServerHandler::list_prompts(&h, page(), c).await;
restore_list(&h, result)
} else {
let result = ServerHandler::get_prompt(&h, get(), c).await;
restore_get(&h, result)
}
});
tokio::select! { _ = &mut parent => panic!("domain should wait"), _ = domain.started.notified() => {} }
assert!(!domain.dropped.load(SeqCst));
drop(parent);
assert!(
domain.dropped.load(SeqCst),
"domain future dropped synchronously with parent"
);
domain.release.notify_one();
tokio::task::yield_now().await;
assert!(!domain.finished.load(SeqCst), "no detached continuation");
assert!(h.take().is_none());
assert_eq!(domain.calls.load(SeqCst), 1);
assert_eq!(Arc::strong_count(&domain), 2);
}
}
@@ -6,6 +6,7 @@ use serde_json::{Value, json};
use std::{sync::Arc, time::Duration};
#[path = "rmcp_prompts_test_support.rs"]
mod fixtures;
use super::rmcp_prompts_handler_runtime_tests as handler;
use fixtures::Endpoint;
fn observe_body(response: Response, counters: Arc<CounterSet>) -> Response {
@@ -111,11 +112,15 @@ async fn success(
std::array::from_fn(|i| after[i] - before[i]),
)
}
async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
pub(super) async fn control(
revision: &str,
require_handler: bool,
) -> Vec<([usize; 3], [usize; 3])> {
let 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();
let mut first_cursor = None;
// Both revisions' JSON contract, plus modern terminal SSE through the same normal app.
let modes: &[bool] = if revision == MODERN_REVISION {
@@ -130,7 +135,9 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
if let Some(ref cursor) = cursor {
params["cursor"] = json!(cursor);
}
let before = handler::counts(&h.counters);
let (result, delta) = success(&h, revision, session, "prompts/list", params, sse).await;
handlers.push(handler::delta(&h.counters, before, "prompts/list"));
let prompts = result["prompts"].as_array().unwrap();
assert_eq!(prompts.len(), 1, "{result}");
assert_eq!(
@@ -174,6 +181,7 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
] {
let mut previous = None;
for _ in 0..2 {
let before = handler::counts(&h.counters);
let (result, delta) = success(
&h,
revision,
@@ -183,6 +191,7 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
sse,
)
.await;
handlers.push(handler::delta(&h.counters, before, "prompts/get"));
assert_eq!(result["description"], format!("Published {name}"));
assert_eq!(
result["messages"],
@@ -232,7 +241,9 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
"prompts/get",
json!({"name":"greeting","arguments":arguments}),
);
let before = handler::counts(&h.counters);
let body = wire(h.post(revision, session, &req, sse).await, &req["id"], sse).await;
handlers.push(handler::delta(&h.counters, before, "prompts/get"));
assert_eq!(body["error"]["code"], -32602, "{body}");
assert_eq!(body["error"]["data"]["reason"], reason, "{body}");
assert_eq!(body["error"]["data"]["argument"], argument);
@@ -255,7 +266,9 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
"prm_a",
] {
let req = request(revision, "prompts/get", json!({"name":name}));
let before = handler::counts(&h.counters);
let body = wire(h.post(revision, session, &req, sse).await, &req["id"], sse).await;
handlers.push(handler::delta(&h.counters, before, "prompts/get"));
assert_eq!(body["error"]["code"], -32602, "{body}");
assert_eq!(
body["error"]["message"],
@@ -269,7 +282,8 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
}
}
for params in [json!({"cursor":"invalid"}), json!({"limit":"invalid"})] {
let req = request(revision, "prompts/list", params);
let before = handler::counts(&h.counters);
let req = request(revision, "prompts/list", params.clone());
let body = wire(
h.post(revision, session, &req, false).await,
&req["id"],
@@ -277,6 +291,15 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
)
.await;
assert_eq!(body["error"]["code"], -32602, "{body}");
if params.get("cursor").is_some() {
handlers.push(handler::delta(&h.counters, before, "prompts/list"));
} else {
assert_eq!(
handler::counts(&h.counters),
before,
"parsing rejects must not enter handlers"
);
}
}
let other = if revision == MODERN_REVISION {
LEGACY_REVISION
@@ -345,6 +368,27 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
),
"{binding:?}"
);
sqlx::query(
"update platform_api_keys set scopes_json = '[]'::jsonb where id = 'pk_dispatch_observer'",
)
.execute(h.registry.pool())
.await
.unwrap();
for (method, params) in [
("prompts/list", json!({})),
("prompts/get", json!({"name":"greeting"})),
] {
let before = handler::counts(&h.counters);
let req = request(revision, method, params);
assert_eq!(h.post(revision, session, &req, false).await.status(), 403);
assert_eq!(
handler::counts(&h.counters),
before,
"scope rejects must precede handlers"
);
}
sqlx::query("update platform_api_keys set scopes_json = '[\"read\",\"write\"]'::jsonb where id = 'pk_dispatch_observer'")
.execute(h.registry.pool()).await.unwrap();
h.registry
.revoke_platform_api_key(
&workspace_id(),
@@ -360,29 +404,41 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
json!({"name":"greeting","arguments":{"name":"Ada"}}),
),
] {
let before = handler::counts(&h.counters);
assert_eq!(
h.post(revision, session, &request(revision, method, params), false)
.await
.status(),
401
);
assert_eq!(
handler::counts(&h.counters),
before,
"revocation must precede handlers"
);
}
eprintln!(
"existing GREEN Prompts wire {revision}: populated pagination, typed metadata/values, exact immutable rendering, archive, structured refusals/non-disclosure, correlation/ID/cache, revoked401; SDK actual/expected={deltas:?}"
);
if require_handler {
assert!(
handlers.iter().all(|(actual, expected)| actual == expected),
"SDK Prompts handler completion/consumption missing after successful HTTP wire/error/guard checks: {handlers:?}"
);
}
deltas
}
#[tokio::test]
async fn rmcp_prompts_wire_legacy() {
control(LEGACY_REVISION).await;
control(LEGACY_REVISION, false).await;
}
#[tokio::test]
async fn rmcp_prompts_wire_modern() {
control(MODERN_REVISION).await;
control(MODERN_REVISION, false).await;
}
#[tokio::test]
async fn rmcp_prompts_sdk_legacy() {
let deltas = control(LEGACY_REVISION).await;
let deltas = control(LEGACY_REVISION, false).await;
assert!(
deltas.iter().all(|(a, e)| a == e),
"SDK typed dispatch/result missing after successful HTTP: {deltas:?}"
@@ -390,7 +446,7 @@ async fn rmcp_prompts_sdk_legacy() {
}
#[tokio::test]
async fn rmcp_prompts_sdk_modern() {
let deltas = control(MODERN_REVISION).await;
let deltas = control(MODERN_REVISION, false).await;
assert!(
deltas.iter().all(|(a, e)| a == e),
"SDK typed dispatch/result missing after successful HTTP: {deltas:?}"
@@ -39,7 +39,7 @@ impl Drop for Endpoint {
}
impl Endpoint {
pub async fn started() -> Self {
crank_test_support::postgres_schema_url_for_task("prompts_owner", "t_160a763a").await;
crank_test_support::postgres_schema_url_for_task("prompts_handler", "t_7afaaafe").await;
let registry = test_registry().await;
let mut archived_at = test_time();
for (id, name, publish) in [
@@ -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);
}
}
@@ -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<Value>, Option<String>), ResourceTemplatesListError>;
#[derive(Default)]
pub(super) struct Domain {
outcome: Mutex<Option<ResourcesOutcome>>,
templates: Mutex<Option<TemplateReply>>,
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<Value>, Option<String>), 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<AppState> {
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<AppState>, 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<PaginatedRequestParams> {
Some(PaginatedRequestParams::default().with_cursor(Some("opaque".into())))
}
async fn context(handler: &ResourceHandler, revision: &str) -> RequestContext<RoleServer> {
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);
}
@@ -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<CounterSet>) -> 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:?}"
@@ -0,0 +1,352 @@
//! #107 inbound responses: wire compatibility and independent SDK execution oracles.
use super::rmcp_progress_cancel_runtime_tests::fixtures::Endpoint;
use super::{CounterSet, Snapshot, observe, support::*};
use serde_json::{Value, json};
use std::sync::{Arc, atomic::Ordering};
async fn endpoint() -> Endpoint {
crank_test_support::postgres_schema_url_for_task("response_owner", "t_d427ee76").await;
Endpoint::started().await
}
fn sdk(c: &CounterSet) -> [usize; 4] {
[
c.sdk_inbound_response_decoded(),
c.sdk_inbound_error_decoded(),
c.sdk_inbound_response_consumed(),
c.sdk_inbound_error_consumed(),
]
}
fn request(
h: &Endpoint,
revision: &str,
session: Option<&str>,
accept: &str,
raw: &str,
) -> reqwest::RequestBuilder {
// Reuse the HTTP fixture without its request-only modern method/name headers.
let mut req = h
.request(LEGACY_REVISION, session, &h.key, accept, json!({}))
.header("x-request-id", "response-atdd")
.body(raw.to_owned())
.build()
.unwrap();
req.headers_mut()
.insert("MCP-Protocol-Version", revision.parse().unwrap());
reqwest::RequestBuilder::from_parts(reqwest::Client::new(), req)
}
async fn ack(response: reqwest::Response) {
assert_eq!(response.status(), 202);
assert!(response.headers().get("content-type").is_none());
assert!(response.headers().get("MCP-Session-Id").is_none());
assert!(response.bytes().await.unwrap().is_empty());
}
async fn no_effects(h: &Endpoint, ops: SessionOps, entries: Snapshot) {
assert_eq!(
h.sessions.snapshot(),
ops,
"response ACK must not access sessions"
);
let after = h.counters.snapshot();
assert_eq!(
(after.era_modern, after.era_legacy, after.tools_service),
(
entries.era_modern,
entries.era_legacy,
entries.tools_service
)
);
assert_eq!(h.started.load(Ordering::SeqCst), 0);
assert!(
h.history("response-atdd").await.is_empty(),
"no domain invocation"
);
}
async fn success_control(error: bool) -> Vec<[usize; 4]> {
let h = endpoint().await;
let mut deltas = vec![];
let numbers = [
"-9223372036854775808",
"9223372036854775807",
"18446744073709551615",
"3.25",
"1.0",
"-0.0",
"1.7976931348623157e308",
"-1.7976931348623157e308",
"5e-324",
];
let mut ids = vec!["\"reply/Ю\""];
ids.extend(numbers);
for revision in [LEGACY_REVISION, MODERN_REVISION] {
for accept in ["application/json", "text/event-stream, application/json"] {
for session in [None, Some("nonexistent-response-session")] {
for (index, id) in ids.iter().enumerate() {
let messages = if error {
let code = numbers[index % numbers.len()];
let data = [
"null",
"true",
"3.25",
"\"text\"",
"[]",
"{}",
"[null,true,{\"nested\":1}]",
][index % 7];
vec![
format!(
r#"{{"jsonrpc":"2.0","id":{id},"error":{{"code":{code},"message":"failed","data":{data}}},"params":false,"extension":[]}}"#
),
format!(
r#"{{"jsonrpc":"2.0","error":{{"code":{code},"message":"failed"}},"params":{{"_meta":false}}}}"#
),
]
} else {
vec![format!(
r#"{{"jsonrpc":"2.0","id":{id},"result":{{"arbitrary":[null,true,3]}},"params":false,"extension":[]}}"#
)]
};
for raw in messages {
let before = sdk(&h.counters);
let ops = h.sessions.snapshot();
let entries = h.counters.snapshot();
ack(request(&h, revision, session, accept, &raw)
.send()
.await
.unwrap())
.await;
no_effects(&h, ops, entries).await;
let after = sdk(&h.counters);
deltas.push(std::array::from_fn(|i| after[i] - before[i]));
}
}
}
}
}
eprintln!("existing wire GREEN error={error}; SDK deltas={deltas:?}");
deltas
}
#[tokio::test]
async fn wire_success_and_error_ack_without_session_or_modern_metadata() {
success_control(false).await;
success_control(true).await;
}
#[tokio::test]
async fn sdk_success_response_decoded_and_consumed_after_http_ack() {
let deltas = success_control(false).await;
assert!(
deltas.iter().all(|d| *d == [1, 0, 1, 0]),
"real SDK success decode/typed variant consumption required; actual={deltas:?}"
);
}
#[tokio::test]
async fn sdk_error_response_decoded_and_consumed_after_http_ack() {
let deltas = success_control(true).await;
assert!(
deltas.iter().all(|d| *d == [0, 1, 0, 1]),
"real SDK error decode/typed variant consumption required; actual={deltas:?}"
);
}
#[tokio::test]
async fn malformed_responses_reject_before_sdk_or_effects() {
let h = endpoint().await;
let mut cases = vec![
json!({}),
json!({"jsonrpc":"2.0","id":1}),
json!({"jsonrpc":"2.0","id":1,"result":{},"error":{"code":1,"message":"x"}}),
json!({"jsonrpc":"2.0","result":{}}),
json!({"id":1,"result":{}}),
json!({"jsonrpc":2,"id":1,"result":{}}),
json!({"jsonrpc":"2.0","id":1,"result":3}),
json!({"jsonrpc":"2.0","error":{}}),
json!({"jsonrpc":"2.0","error":{"code":1,"message":3}}),
];
for value in [Value::Null, json!(true), json!([]), json!({}), json!("bad")] {
for field in ["jsonrpc", "result", "id"] {
if (field == "result" && value.is_object()) || (field == "id" && value.is_string()) {
continue;
}
let mut m = json!({"jsonrpc":"2.0","id":1,"result":{}});
m[field] = value.clone();
cases.push(m);
}
for field in ["error", "code", "message", "id"] {
if (field == "error" && value.is_object())
|| (field == "message" && value.is_string())
|| (field == "id" && value.is_string())
{
continue;
}
let mut m = json!({"jsonrpc":"2.0","id":1,"error":{"code":1,"message":"x"}});
if ["code", "message"].contains(&field) {
m["error"][field] = value.clone();
} else {
m[field] = value.clone();
}
cases.push(m);
}
}
for missing in ["code", "message"] {
let mut m = json!({"jsonrpc":"2.0","error":{"code":1,"message":"x"}});
m["error"].as_object_mut().unwrap().remove(missing);
cases.push(m);
}
for revision in [LEGACY_REVISION, MODERN_REVISION] {
for m in &cases {
let before = sdk(&h.counters);
let ops = h.sessions.snapshot();
let entries = h.counters.snapshot();
let response = request(&h, revision, None, "application/json", &m.to_string())
.send()
.await
.unwrap();
assert_eq!(response.status(), 400, "{m}");
let wire: Value = response.json().await.unwrap();
assert_eq!(wire["error"]["code"], -32600, "{m}: {wire}");
assert_eq!(wire["id"], Value::Null);
assert!(wire.get("result").is_none());
assert_eq!(sdk(&h.counters), before);
no_effects(&h, ops, entries).await;
}
}
}
#[tokio::test]
async fn admission_guards_precede_response_ack_and_sdk() {
let h = endpoint().await;
for revision in [LEGACY_REVISION, MODERN_REVISION] {
for raw in [
r#"{"jsonrpc":"2.0","id":1,"result":{}}"#,
r#"{"jsonrpc":"2.0","error":{"code":1,"message":"x"}}"#,
] {
for guard in ["origin", "accept", "ambiguous"] {
let ops = h.sessions.snapshot();
let entries = h.counters.snapshot();
let before = sdk(&h.counters);
let mut req = request(&h, revision, None, "application/json", raw)
.build()
.unwrap();
let expected = match guard {
"origin" => {
req.headers_mut()
.insert("origin", "https://evil.example".parse().unwrap());
403
}
"accept" => {
req.headers_mut()
.insert("accept", "text/plain".parse().unwrap());
406
}
_ => {
req.headers_mut()
.append("MCP-Session-Id", "one".parse().unwrap());
req.headers_mut()
.append("MCP-Session-Id", "two".parse().unwrap());
400
}
};
let response = reqwest::Client::new().execute(req).await.unwrap();
assert_eq!(response.status().as_u16(), expected, "{guard}");
let _ = response.bytes().await.unwrap();
assert_eq!(sdk(&h.counters), before);
no_effects(&h, ops, entries).await;
}
}
}
}
#[tokio::test]
async fn authentication_and_revocation_precede_response_ack() {
let h = endpoint().await;
let mut statuses = vec![];
for revoked in [false, true] {
if revoked {
h.registry
.revoke_platform_api_key(
&workspace_id(),
&crank_core::PlatformApiKeyId::new("pk_dispatch_observer"),
&time::OffsetDateTime::now_utc(),
)
.await
.unwrap();
}
for revision in [LEGACY_REVISION, MODERN_REVISION] {
for raw in [
r#"{"jsonrpc":"2.0","id":1,"result":{}}"#,
r#"{"jsonrpc":"2.0","error":{"code":1,"message":"x"}}"#,
] {
let before = sdk(&h.counters);
let ops = h.sessions.snapshot();
let entries = h.counters.snapshot();
let mut req = request(&h, revision, None, "application/json", raw)
.build()
.unwrap();
if !revoked {
req.headers_mut().remove("authorization");
}
let response = reqwest::Client::new().execute(req).await.unwrap();
statuses.push(response.status().as_u16());
let _ = response.bytes().await.unwrap();
assert_eq!(sdk(&h.counters), before);
no_effects(&h, ops, entries).await;
}
}
}
assert_eq!(
statuses,
vec![401; 8],
"missing/revoked credentials must reject before ACK and SDK"
);
}
#[tokio::test]
async fn method_bearing_messages_keep_priority_over_response_fields() {
let h = endpoint().await;
for revision in [LEGACY_REVISION, MODERN_REVISION] {
let session = h.session(revision).await;
for notification in [false, true] {
let mut m = json!({"jsonrpc":"2.0","method":"ping","id":7,"result":false,"error":[],"extension":null});
if notification {
m.as_object_mut().unwrap().remove("id");
}
if revision == MODERN_REVISION {
m["params"] = json!({"_meta":modern_meta()});
}
let before = sdk(&h.counters);
let response = h
.request(revision, session.as_deref(), &h.key, "application/json", m)
.send()
.await
.unwrap();
if notification {
ack(response).await;
} else {
assert_eq!(response.status(), 200);
let wire: Value = response.json().await.unwrap();
assert_eq!(wire["id"], 7);
assert!(wire["result"].is_object());
assert!(wire.get("error").is_none());
}
assert_eq!(sdk(&h.counters), before, "not an inbound response");
}
}
}
#[tokio::test]
async fn observer_positive_control_is_task_scoped_and_independent() {
let a = Arc::new(CounterSet::default());
let b = Arc::new(CounterSet::default());
super::sdk_inbound_response_decoded();
super::sdk_inbound_error_decoded();
super::sdk_inbound_response_consumed();
super::sdk_inbound_error_consumed();
assert_eq!(sdk(&a), [0; 4]);
tokio::join!(
observe(a.clone(), async {
super::sdk_inbound_response_decoded();
super::sdk_inbound_error_consumed();
}),
observe(b.clone(), async {
super::sdk_inbound_error_decoded();
super::sdk_inbound_response_consumed();
})
);
assert_eq!(sdk(&a), [1, 0, 0, 1]);
assert_eq!(sdk(&b), [0, 1, 1, 0]);
assert_eq!(a.snapshot(), Snapshot::new(0, 0, 0, 0));
}
@@ -365,6 +365,45 @@ async fn rmcp_runtime_sdk_dispatch_legacy() {
);
}
async fn handler_execution_control(revision: &str) {
let h = Endpoint::started().await;
let session = h.session(revision).await;
let session = session.as_deref();
h.list(revision, session, TOOL_NAME).await;
h.call(
revision,
session,
TOOL_NAME,
&format!("{revision}@handler.test"),
)
.await;
assert_eq!(
h.calls.load(Ordering::SeqCst),
1,
"one domain call expected"
);
assert_eq!(
[
h.counters.sdk_tools_list_handler_completed(),
h.counters.sdk_tools_list_handler_consumed(),
h.counters.sdk_tools_call_handler_completed(),
h.counters.sdk_tools_call_handler_consumed(),
],
[1, 1, 1, 1],
"real build_app HTTP tools/list and tools/call must execute and consume SDK handler results ({revision})"
);
}
#[tokio::test]
async fn rmcp_tools_handler_http_modern() {
handler_execution_control(MODERN_REVISION).await;
}
#[tokio::test]
async fn rmcp_tools_handler_http_legacy() {
handler_execution_control(LEGACY_REVISION).await;
}
#[tokio::test]
async fn rmcp_runtime_observer_is_request_scoped() {
let counters = Arc::new(CounterSet::default());
@@ -0,0 +1,325 @@
//! Real trait-result consumption controls and request-owned cancellation.
use super::*;
use serde_json::json;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
#[derive(Default)]
pub(super) struct Domain {
outcome: Mutex<Option<ToolsOutcome>>,
calls: AtomicUsize,
pending: bool,
started: tokio::sync::Notify,
dropped: AtomicBool,
}
struct Witness<'a>(&'a AtomicBool);
impl Drop for Witness<'_> {
fn drop(&mut self) {
self.0.store(true, SeqCst);
}
}
impl Domain {
pub(super) async fn execute(&self, scope: &Scope, command: ToolsCommand) -> ToolsOutcome {
self.calls.fetch_add(1, SeqCst);
assert_eq!(scope.workspace, "workspace");
assert_eq!(scope.agent, "agent");
assert_eq!(
scope
.credential
.platform_api_key_id
.as_ref()
.unwrap()
.as_str(),
"key"
);
assert_eq!(scope.locale, ExecutionLocale::En);
match command {
ToolsCommand::List(list) => {
assert_eq!(list.cursor.as_deref(), Some("cursor"));
assert_eq!(list.limit, Some(7));
}
ToolsCommand::Call(call) => {
assert_eq!(call.tool_name, "bound");
assert_eq!(call.arguments, json!({"number":42,"nested":[null]}));
assert_eq!(call.confirmation_token.as_deref(), Some("confirmation"));
assert!(scope.lifecycle.is_some());
}
}
let _witness = Witness(&self.dropped);
self.started.notify_one();
if self.pending {
std::future::pending::<()>().await;
}
self.outcome
.lock()
.unwrap()
.take()
.expect("one domain call")
}
}
fn scope() -> Scope {
Scope {
workspace: "workspace".into(),
agent: "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("key".into()),
},
correlation: CorrelationContext::generate(),
continuation: ContinuationSupport::ElicitationUnsupported,
locale: ExecutionLocale::En,
limit: Some(7),
confirmation: Some("confirmation".into()),
lifecycle: Some(ToolCallLifecycle::new(None).0),
}
}
async fn state() -> Arc<AppState> {
crank_test_support::postgres_schema_url_for_task("tools_handler_local", "t_75a3342f").await;
super::super::rmcp_tools_tests::test_state().await
}
fn handler(state: &Arc<AppState>, outcome: ToolsOutcome) -> Handler {
let mut h = Handler::new(state);
h.domain = Some(Arc::new(Domain {
outcome: Mutex::new(Some(outcome)),
..Default::default()
}));
h
}
async fn context(h: &Handler) -> RequestContext<RoleServer> {
let context = request_context(h, scope()).await.unwrap();
assert!(context.peer.is_transport_closed());
assert_eq!(Arc::strong_count(&h.extras), 1);
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 0);
context
}
fn call() -> CallToolRequestParams {
CallToolRequestParams::new("bound").with_arguments(
json!({"number":42,"nested":[null]})
.as_object()
.unwrap()
.clone(),
)
}
fn payload(outcome: Outcome, version: &str) -> Value {
match super::super::response::sdk_tools_payload(&json!({"id":17}), version, outcome) {
super::super::response::ToolCommandPayload::Ok(value) => value,
_ => panic!("expected wire payload"),
}
}
#[tokio::test]
async fn rmcp_tools_handler_list_typed_mutation_and_lossless_catalog() {
let state = state().await;
for version in ["2025-11-25", "2026-07-28"] {
let raw = json!({"name":"original","inputSchema":{"type":"object"},"description":null,
"annotations":{"readOnlyHint":true,"x-extra":[null]},"icons":null,"x-tool":{}});
let h = handler(
&state,
ToolsOutcome::List {
tools: vec![raw.clone()],
next_cursor: Some("next".into()),
},
);
let mut result = ServerHandler::list_tools(
&h,
Some(PaginatedRequestParams::default().with_cursor(Some("cursor".into()))),
context(&h).await,
)
.await
.unwrap();
result.tools[0].name = "mutated".into();
result.tools[0].description = Some("typed description".into());
result.next_cursor = Some("changed".into());
let wire = payload(
projection::consume_list(Ok(result), h.take_extras()),
version,
);
let mut expected = raw;
expected["name"] = json!("mutated");
expected["description"] = json!("typed description");
assert_eq!(wire["result"]["tools"], json!([expected]));
assert_eq!(wire["result"]["nextCursor"], "changed");
assert_eq!(
wire["result"].get("resultType").is_some(),
version == "2026-07-28"
);
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
}
}
#[tokio::test]
async fn rmcp_tools_handler_call_typed_content_structured_and_is_error_mutations() {
let state = state().await;
for version in ["2025-11-25", "2026-07-28"] {
for original in [
ToolCallOutcome::Completed(Value::Null),
ToolCallOutcome::ApprovalPending(json!({"approval":true})),
] {
let h = handler(&state, ToolsOutcome::Call(original));
let result = ServerHandler::call_tool(&h, call(), context(&h).await)
.await
.unwrap();
let CallToolResponse::Complete(mut result) = result else {
panic!("complete result");
};
result.content = vec![ContentBlock::text("typed content")];
result.structured_content = Some(json!({"typed":42}));
result.is_error = Some(true);
let wire = payload(projection::consume_call(Ok(result.into())), version);
assert_eq!(
wire["result"]["content"],
json!([{"type":"text","text":"typed content"}])
);
assert_eq!(wire["result"]["structuredContent"], json!({"typed":42}));
assert_eq!(wire["result"]["isError"], true);
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
}
}
}
#[tokio::test]
async fn rmcp_tools_handler_typed_list_and_call_errors_are_consumed() {
let state = state().await;
for version in ["2025-11-25", "2026-07-28"] {
let h = handler(&state, ToolsOutcome::InvalidParams("original list".into()));
let result = ServerHandler::list_tools(
&h,
Some(PaginatedRequestParams::default().with_cursor(Some("cursor".into()))),
context(&h).await,
)
.await;
let mut error = result.unwrap_err();
error.message = "mutated list".into();
error.data = Some(json!({"typed":true}));
let wire = payload(
projection::consume_list(Err(error), h.take_extras()),
version,
);
assert_eq!(wire["error"]["message"], "mutated list");
assert_eq!(wire["error"]["data"], json!({"typed":true}));
let h = handler(
&state,
ToolsOutcome::Call(ToolCallOutcome::InvalidParams("original call".into())),
);
let mut error = ServerHandler::call_tool(&h, call(), context(&h).await)
.await
.unwrap_err();
error.code = ErrorCode(-32001);
error.message = "mutated call".into();
error.data = Some(json!({"typed":42}));
let wire = payload(projection::consume_call(Err(error)), version);
assert_eq!(wire["error"]["code"], -32001);
assert_eq!(wire["error"]["message"], "mutated call");
assert_eq!(wire["error"]["data"], json!({"typed":42}));
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
}
}
#[tokio::test]
async fn rmcp_tools_handler_domain_outcomes_keep_wire_semantics() {
use crate::tool_error::{McpControlError, control_tool_error_contract};
let state = state().await;
for version in ["2025-11-25", "2026-07-28"] {
for kind in 0..6 {
let outcome = || match kind {
0 => ToolCallOutcome::Completed(Value::Null),
1 => ToolCallOutcome::ApprovalPending(json!({"approval":"pending"})),
2 => ToolCallOutcome::ApprovalUnavailable(
McpControlError::ApprovalElicitationNotSupported,
),
3 => ToolCallOutcome::Error(control_tool_error_contract(
McpControlError::CatalogRevisionChanged,
"request",
"trace",
ExecutionLocale::En,
)),
4 => ToolCallOutcome::InvalidParams("invalid argument".into()),
_ => ToolCallOutcome::InternalFailure,
};
let h = handler(&state, ToolsOutcome::Call(outcome()));
let ctx = context(&h).await;
let correlation = Handler::scope(&ctx).unwrap().correlation;
let result = ServerHandler::call_tool(&h, call(), ctx).await;
let actual = payload(projection::consume_call(result), version);
let expected = super::super::response::tool_command_payload(
&json!({"id":17}),
version,
&correlation,
ToolsOutcome::Call(outcome()),
);
match expected {
super::super::response::ToolCommandPayload::Ok(expected) => {
assert_eq!(actual, expected)
}
super::super::response::ToolCommandPayload::Internal(_) => {
assert_eq!(actual["error"]["code"], -32603);
assert_eq!(actual["error"]["message"], "internal server error");
}
}
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
}
for raw in [
json!({"name":"tool","inputSchema":{},"description":null,"_meta":null,"annotations":{},"icons":[]}),
json!({"name":"tool","inputSchema":{},"annotations":{"x-annotation":null},"icons":null,"x-tool":[null,{}]}),
] {
let h = handler(
&state,
ToolsOutcome::List {
tools: vec![raw.clone()],
next_cursor: Some(String::new()),
},
);
let result = ServerHandler::list_tools(
&h,
Some(PaginatedRequestParams::default().with_cursor(Some("cursor".into()))),
context(&h).await,
)
.await;
let wire = payload(projection::consume_list(result, h.take_extras()), version);
assert_eq!(wire["result"]["tools"], json!([raw]));
assert_eq!(wire["result"]["nextCursor"], "");
}
}
}
#[tokio::test]
async fn rmcp_tools_handler_pending_domain_dropped_with_parent_and_identity_is_local() {
let state = state().await;
for list in [false, true] {
let mut h = Handler::new(&state);
h.domain = Some(Arc::new(Domain {
pending: true,
..Default::default()
}));
let ctx = context(&h).await;
let other = request_context(
&h,
Scope {
agent: "other-agent".into(),
..scope()
},
)
.await
.unwrap();
assert_eq!(Handler::scope(&ctx).unwrap().agent, "agent");
assert_eq!(Handler::scope(&other).unwrap().agent, "other-agent");
let parent = async {
if list {
let _ = ServerHandler::list_tools(
&h,
Some(PaginatedRequestParams::default().with_cursor(Some("cursor".into()))),
ctx,
)
.await;
} else {
let _ = ServerHandler::call_tool(&h, call(), ctx).await;
}
};
let domain = h.domain.as_ref().unwrap();
{
let parent = parent;
tokio::pin!(parent);
tokio::select! { _ = domain.started.notified() => {}, _ = &mut parent => panic!("pending domain completed") }
assert!(!domain.dropped.load(SeqCst));
}
assert!(domain.dropped.load(SeqCst));
assert_eq!(domain.calls.load(SeqCst), 1);
}
}
+10
View File
@@ -51,10 +51,20 @@ Negotiation-results-срез #107 на базе rc.26/rmcp3.9.0 заменяет
Ping-срез #107 на базе rc.28/rmcp3.9.0 подключает обе штатные HTTP ветки к общему `protocol/lifecycle_sdk.rs::ping_result`: проекция уже допущенного метода декодируется в `PingRequest`, его SDK request variant выбирает `ServerResult::empty(())`, а сериализованный SDK результат поступает в прежний JSON/SSE terminal. Удалены два handwritten ping result builder; Crank добавляет прежний `protocolVersion` из legacy session либо modern identity, а modern result projection сохраняется. Игнорируемые params/extensions не получают новых SDK ограничений. Legacy initialized-session guard остаётся перед helper; modern ping не обращается к sessions. Runtime ATDD отдельно подтверждает SDK request/result execution и прежние wire/status/headers/id/correlation обеих revisions; affected regressions проверяют session/admission/method/revocation guards. Generic dispatch, session storage/TTL/reconnect, admission/auth и transport остаются прежними; полный #107, feature qualification и production deployment не завершены.
Negotiation-handler-срез #107 поверх rc.36/rmcp3.9.0 заменяет описанные выше DTO-only negotiation/ping helpers на прямые await настоящих `ServerHandler::initialize/discover/ping` в request-owned `app/rmcp_negotiation.rs`. Реальные consumers — legacy initialize/ping и modern discover/ping штатного `build_app` JSON/SSE; typed Result/ErrorData определяет ответ, а legacy session создаётся только после успешного initialize. Bootstrap инертен и закрывается до handler; pending trait future принадлежит запросу и прекращается при drop. Allowlist/порядок revisions, registry capabilities, identity, discovery cache hints, ignored inputs и прежние durable guards сохранены; projection восстанавливает только непредставимые SDK registry extensions и era-specific wire omissions. HTTP completed/consumed oracle обеих revisions дополнен typed-result mutation/error и drop controls; прежние wire/session/admission/revocation проверки сохраняются. DTO-only production builders удалены, initialized notification остаётся прежним typed переходом. Это не перенос SDK HTTP transport/SessionManager, callbacks или полного lifecycle: #107 остаётся open/partial, bootstrap performance и full/load/external-client qualification не завершены; #108/4.7/production не запускаются.
Initialized-срез #107 на базе rc.29/rmcp3.9.0 подключает штатный legacy HTTP handshake к `InitializedNotification` и `ClientNotification`: после registry/admission проекция метода декодируется SDK, а matched initialized variant после прежних session/scope guards разрешает существующий durable `mark_initialized`. Игнорируемые params/extensions, 202 с пустым телом, JSON/SSE и modern no-session поведение сохранены; SDK SessionManager не используется. Runtime-тесты отдельно наблюдают decoding и consumption, проверяют PostgreSQL reconnect и отказ store на чтении/записи. Это только lifecycle-срез, не завершение #107.
Envelope-dispatch-срез #107 на базе rc.30/rmcp3.9.0 подключает обе действующие HTTP ветки `app/dispatch.rs` и `app/legacy_dispatch.rs` к общему `protocol/dispatch_sdk.rs`: после прежних admission/auth guards минимальная проекция декодируется в настоящие `JsonRpcRequest<Value>`/`JsonRpcNotification<Value>`. SDK payload method выбирает прежний `registry::dispatch_decision`, SDK variant определяет request/notification routing вместо повторных raw-JSON predicates. Второй таблицы методов нет; registry остаётся policy gate revisions/capabilities/registered kind. Modern notification ACK по-прежнему предшествует request-only Mcp-Method/Mcp-Name checks и не обращается к sessions/domain. Params и ignored extensions/result/error остаются вне routing projection; SDK-incompatible числовые ID получают только внутренний surrogate, исходные ID/числовая форма остаются в raw message для wire/correlation/cancellation ownership. Для выбранного registry Ping handler typed projection использует canonical ping, сохраняя registered alias semantics. Runtime HTTP ATDD отдельно проверяет SDK decode/consumption и прежний JSON/SSE wire; affected registry/admission, durable initialized/reconnect, progress/cancel и auth guards проверяются без замены storage/transport. Это перенос только generic request/notification envelope routing: domain/generic handler execution, inbound response/error envelopes и их shape validation, session storage/TTL/reconnect, transport и feature qualification остаются вне среза. Полный #107 остаётся open; #108/4.7 и production switch не запускаются.
Inbound-response-срез #107 на базе rc.31/rmcp3.9.0 подключает no-method ветку общего envelope guard к `protocol/response_sdk.rs`: реальные `JsonRpcResponse<Value>`/`JsonRpcError` определяют response classification и ранний HTTP202 ACK штатного `build_app` POST обеих revisions. Сохранены object-only result без обязательного resultType, exclusivity result/error, optional error id, произвольные data/params/extensions и любые JSON number id/code; только SDK-несовместимые числа получают внутренние surrogates после проверки исходного wire-предиката, raw message не меняется. Заменён handwritten response classifier/error-object parser. Обнаруженный ATDD обход credentials ранним ACK устранён свежей read-авторизацией no-method сообщений до SDK decode; порядок method-bearing запросов не меняется. Origin/Accept/ambiguous carrier checks предшествуют decode/ACK, ACK остаётся до era/session resolution без session/domain вызовов. HTTP wire и SDK decoded/consumed oracles проверяются отдельно. Domain/generic handler execution, session storage/TTL/reconnect, transport и feature qualification остаются вне среза; полный #107 остаётся open, #108/4.7/production не запускаются.
Prompts handler-срез #107 на базе rc.33 заменяет прежний DTO-only shim настоящими `ServerHandler::list_prompts/get_prompt` в `app/rmcp_prompts.rs`. Уже подключённый потребитель — `build_app` → обе HTTP dispatch-ветки → `rmcp_dispatch::handle_prompts_command`. Overrides напрямую await-ят прежний domain service ровно один раз; caller потребляет actual typed SDK Result, а request-local projection восстанавливает только непредставимые поля/omissions. Инертный ping-bootstrap закрывается до domain execution; domain future остаётся в parent HTTP future и отменяется при drop. Closed Peer не поддерживает callbacks. HTTP handler completed/consumed ATDD обеих revisions и trait-result mutation/drop regressions подтверждают реальное исполнение, прежние wire/access/error boundaries и lossless content; affected Prompts integration проверяет pinned static/dynamic Resource composition и dependency errors. Domain/auth/storage/session/transport не меняются. Это не завершение #107, feature qualification или разрешение #108/4.7/production.
Completion handler-срез #107 на базе rc.34 заменяет DTO-only completion shim настоящим `ServerHandler::complete` в `app/rmcp_completion.rs`. Подключённый потребитель — обе штатные HTTP dispatch-ветки через `rmcp_dispatch::handle_completion_command`. Override напрямую await-ит прежний domain service один раз; caller потребляет возвращённый SDK `CompleteResult`/`ErrorData`, сохраняя прежнюю JSON/SSE проекцию. Исходный JSON context передаётся request-local без сужения до SDK string map. Инертный ping-bootstrap закрывается до domain execution; drop parent future отменяет незавершённый domain future, закрытый Peer не поддерживает callbacks. Отдельные HTTP handler-completed/caller-consumed oracles и trait mutation/drop/error regressions проверяют этот переход, а wire controls сохраняют refs, published/archive binding, bounded/empty/omitted totals, safe errors и revocation. Domain/auth/storage/session/transport/capabilities не меняются. Полный #107, нагрузочная квалификация, #108/4.7 и production не завершены и не запускаются.
Tools handler-срез #107 на базе rc.35 заменяет DTO-only Tools shim настоящими `ServerHandler::list_tools/call_tool` в `app/rmcp_tools_runtime.rs`. Подключённый потребитель — `build_app` → modern/legacy list dispatch и `lifecycle::call_future` → `rmcp_dispatch::handle_tools_command`. Overrides напрямую await-ят прежний shared service один раз; HTTP JSON/SSE consumers сериализуют actual SDK `ListToolsResult`/`CallToolResult`/`ErrorData`, сохраняя локально только непредставимые catalog extras. Request-local context переносит identity/locale/limit/confirmation и существующий lifecycle без повторной in-flight регистрации. Инертный ping-bootstrap закрыт до domain execution, closed Peer не используется для callbacks; progress/cancel/deadline остаются у прежнего lifecycle, drop parent отменяет domain future. HTTP handler-completed/caller-consumed oracles обеих revisions и typed mutation/error/single-call/drop controls отделены от existing wire GREEN. Affected проверки сохраняют pagination, Search/proxy binding, published catalog, access/revocation и approval semantics. Domain/auth/storage/session/transport/capabilities не меняются. Это не завершение #107, не нагрузочная/feature qualification и не разрешение #108/4.7/production.
Проверяемый результат:
- Через SDK проходят действующие Tools, Resources, Prompts, completion, уведомления и подписки в применимых revisions, а также progress/cancel и существующая logging policy.