Compare commits
26
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
8f494679b8 | ||
|
|
0755e6e8e8 | ||
|
|
d01bdf019c | ||
|
|
22637861c3 | ||
|
|
7aab666aaa | ||
|
|
fd76aaf676 | ||
|
|
986cd78b96 | ||
|
|
bcdf57074b | ||
|
|
b39e4a3470 | ||
|
|
3b30aad28e | ||
|
|
5611e81579 | ||
|
|
b769a2ed2e | ||
|
|
0139eeaac6 | ||
|
|
5cce1b09df | ||
|
|
5b0af84d5a | ||
|
|
9b3e0248d1 | ||
|
|
163b519979 | ||
|
|
65144fd8c6 | ||
|
|
66bb135398 | ||
|
|
0de1e94df4 | ||
|
|
7a1fc0d761 | ||
|
|
156a849087 | ||
|
|
a4cf5ed8cf | ||
|
|
326f209bc5 | ||
|
|
c32e24b268 | ||
|
|
ca126004af |
No files matched your search
@@ -34,17 +34,30 @@ 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_logging;
|
||||
mod rmcp_negotiation;
|
||||
mod rmcp_notifications;
|
||||
#[cfg(test)]
|
||||
mod rmcp_progress_cancel;
|
||||
mod rmcp_prompts;
|
||||
mod rmcp_prompts_projection;
|
||||
mod rmcp_resources;
|
||||
mod rmcp_resources_projection;
|
||||
#[cfg(test)]
|
||||
mod rmcp_session_tests;
|
||||
mod rmcp_subscriptions;
|
||||
mod rmcp_subscriptions_output;
|
||||
#[cfg(test)]
|
||||
mod rmcp_tools;
|
||||
mod rmcp_tools_projection;
|
||||
mod rmcp_tools_runtime;
|
||||
#[cfg(test)]
|
||||
#[path = "rmcp_tools_tests.rs"]
|
||||
mod rmcp_tools_tests;
|
||||
|
||||
@@ -12,16 +12,13 @@ use super::rmcp_dispatch::{
|
||||
};
|
||||
use crate::{
|
||||
auth::VerifiedMachineCredential,
|
||||
jsonrpc::{
|
||||
is_notification, jsonrpc_error, jsonrpc_result, method_name, negotiated_protocol_version,
|
||||
params, request_id,
|
||||
},
|
||||
jsonrpc::{jsonrpc_error, jsonrpc_result, negotiated_protocol_version, params, request_id},
|
||||
protocol::{
|
||||
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,
|
||||
@@ -41,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
|
||||
@@ -81,7 +76,20 @@ pub(super) async fn handle_modern_request(
|
||||
// matrix row 18). The envelope, identity and mixed-carrier checks — and authentication — have
|
||||
// already run at this point, so this early return cannot admit a malformed identity or a session
|
||||
// conflict, and the notification is never dispatched.
|
||||
if is_notification(message) {
|
||||
let envelope = match crate::protocol::decode_dispatch_envelope(message) {
|
||||
Ok(Some(envelope)) => envelope,
|
||||
_ => {
|
||||
return internal_jsonrpc_error(
|
||||
message,
|
||||
"admitted dispatch envelope could not be decoded",
|
||||
);
|
||||
}
|
||||
};
|
||||
let method = envelope.method();
|
||||
let notification = envelope.is_notification();
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_dispatch_envelope_consumed();
|
||||
if notification {
|
||||
return crate::protocol::modern_notification_response();
|
||||
}
|
||||
|
||||
@@ -89,45 +97,55 @@ pub(super) async fn handle_modern_request(
|
||||
Ok(declared_method) => declared_method,
|
||||
Err(response) => return *response,
|
||||
};
|
||||
if declared_method != method_name(message) {
|
||||
if declared_method != method {
|
||||
return crate::protocol::modern_header_mismatch_response(message);
|
||||
}
|
||||
|
||||
// R5/F5: the same registration-backed dispatch as the legacy adapter. The handler is decided by
|
||||
// the owning registration (not by a literal method list inside this adapter), and a method whose
|
||||
// capability is not eligible in this revision is never served here.
|
||||
let dispatch =
|
||||
crate::protocol::dispatch_decision(method_name(message).unwrap_or_default(), version);
|
||||
let dispatch = crate::protocol::dispatch_decision(method.unwrap_or_default(), version);
|
||||
match dispatch {
|
||||
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,
|
||||
json!({ "protocolVersion": 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,
|
||||
..
|
||||
@@ -161,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,
|
||||
@@ -406,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,
|
||||
)
|
||||
@@ -703,8 +691,8 @@ pub(super) async fn handle_modern_request(
|
||||
);
|
||||
}
|
||||
};
|
||||
let accepted = match filter.notifications.accepted() {
|
||||
crate::protocol::FilterOutcome::Accepted(accepted) => accepted,
|
||||
match filter.notifications.accepted() {
|
||||
crate::protocol::FilterOutcome::Accepted(_) => {}
|
||||
crate::protocol::FilterOutcome::Invalid(detail) => {
|
||||
return transport_response(
|
||||
StatusCode::OK,
|
||||
@@ -731,18 +719,19 @@ pub(super) async fn handle_modern_request(
|
||||
else {
|
||||
return StatusCode::TOO_MANY_REQUESTS.into_response();
|
||||
};
|
||||
let acknowledged = crate::protocol::acknowledged_frame(&subscription_id, accepted);
|
||||
let receiver = crate::protocol::spawn_signal_watch(
|
||||
let (acknowledged, receiver) = match super::rmcp_subscriptions::start(
|
||||
Arc::clone(state),
|
||||
crate::protocol::Watch {
|
||||
workspace_slug: path.workspace_slug.clone(),
|
||||
agent_slug: path.agent_slug.clone(),
|
||||
signals: accepted,
|
||||
wire: crate::protocol::Wire::Modern(subscription_id),
|
||||
legacy_stream: None,
|
||||
deadline: None,
|
||||
},
|
||||
);
|
||||
path.workspace_slug.clone(),
|
||||
path.agent_slug.clone(),
|
||||
subscription_id,
|
||||
filter.notifications.into_sdk(),
|
||||
super::rmcp_subscriptions::project_meta(message),
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(stream) => stream,
|
||||
Err(error) => return sdk_error_response(message, response_mode, version, error),
|
||||
};
|
||||
let stream = crate::protocol::frames_stream(vec![acknowledged], receiver, permit);
|
||||
|
||||
sse_response(StatusCode::OK, stream, None, Some(version))
|
||||
@@ -753,6 +742,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>(
|
||||
@@ -812,6 +814,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
|
||||
@@ -837,10 +843,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),
|
||||
@@ -851,6 +854,7 @@ pub(super) async fn handle_initialized_notification(
|
||||
state: Arc<AppState>,
|
||||
path: &AgentRoutePath,
|
||||
headers: &HeaderMap,
|
||||
notification: rmcp::model::ClientNotification,
|
||||
) -> Response {
|
||||
match session_id_from_headers(headers) {
|
||||
Ok(Some(session_id)) => match state.sessions.get(&session_id).await {
|
||||
@@ -858,15 +862,18 @@ pub(super) async fn handle_initialized_notification(
|
||||
if session.workspace_slug == path.workspace_slug
|
||||
&& session.agent_slug == path.agent_slug =>
|
||||
{
|
||||
match state
|
||||
.sessions
|
||||
.mark_initialized(&session_id, OffsetDateTime::now_utc())
|
||||
let rmcp::model::ClientNotification::InitializedNotification(initialized) =
|
||||
notification
|
||||
else {
|
||||
unreachable!("initialized handler requires the SDK initialized variant")
|
||||
};
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_initialized_notification_consumed(&initialized);
|
||||
#[cfg(not(test))]
|
||||
let _ = initialized;
|
||||
super::rmcp_notifications::initialized(state, session_id)
|
||||
.await
|
||||
{
|
||||
Ok(true) => StatusCode::ACCEPTED.into_response(),
|
||||
Ok(false) => StatusCode::NOT_FOUND.into_response(),
|
||||
Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
|
||||
}
|
||||
.into_response()
|
||||
}
|
||||
Ok(Some(_)) => StatusCode::NOT_FOUND.into_response(),
|
||||
Ok(None) => StatusCode::NOT_FOUND.into_response(),
|
||||
|
||||
@@ -54,39 +54,183 @@ 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,
|
||||
sdk_logging_handler_completed: AtomicUsize,
|
||||
sdk_logging_handler_consumed: AtomicUsize,
|
||||
sdk_progress_notification: AtomicUsize,
|
||||
sdk_cancelled_params: AtomicUsize,
|
||||
sdk_subscriptions_listen: AtomicUsize,
|
||||
sdk_subscriptions_acknowledged: AtomicUsize,
|
||||
sdk_signal_notification: AtomicUsize,
|
||||
sdk_subscription_listen_entered: AtomicUsize,
|
||||
sdk_subscription_handler_completed: AtomicUsize,
|
||||
sdk_subscription_handler_consumed: AtomicUsize,
|
||||
sdk_subscription_notification_consumed: AtomicUsize,
|
||||
sdk_subscription_owner_completed: AtomicUsize,
|
||||
sdk_jsonrpc_response: AtomicUsize,
|
||||
sdk_jsonrpc_error: 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_initialized_handler_completed: AtomicUsize,
|
||||
sdk_initialized_handler_consumed: AtomicUsize,
|
||||
sdk_cancelled_handler_completed: AtomicUsize,
|
||||
sdk_cancelled_handler_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)
|
||||
}
|
||||
pub(crate) fn sdk_dispatch_consumed(&self) -> usize {
|
||||
self.sdk_dispatch_consumed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_initialized_decoded(&self) -> usize {
|
||||
self.sdk_initialized_decoded.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_initialized_consumed(&self) -> usize {
|
||||
self.sdk_initialized_consumed.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_initialized_handler_completed(&self) -> usize {
|
||||
self.sdk_initialized_handler_completed
|
||||
.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_initialized_handler_consumed(&self) -> usize {
|
||||
self.sdk_initialized_handler_consumed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_cancelled_handler_completed(&self) -> usize {
|
||||
self.sdk_cancelled_handler_completed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_cancelled_handler_consumed(&self) -> usize {
|
||||
self.sdk_cancelled_handler_consumed.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)
|
||||
@@ -100,6 +244,25 @@ impl CounterSet {
|
||||
pub(crate) fn sdk_subscriptions_acknowledged(&self) -> usize {
|
||||
self.sdk_subscriptions_acknowledged.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_subscription_listen_entered(&self) -> usize {
|
||||
self.sdk_subscription_listen_entered.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_subscription_handler_completed(&self) -> usize {
|
||||
self.sdk_subscription_handler_completed
|
||||
.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_subscription_handler_consumed(&self) -> usize {
|
||||
self.sdk_subscription_handler_consumed
|
||||
.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_subscription_notification_consumed(&self) -> usize {
|
||||
self.sdk_subscription_notification_consumed
|
||||
.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_subscription_owner_completed(&self) -> usize {
|
||||
self.sdk_subscription_owner_completed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_signal_notification(&self) -> usize {
|
||||
self.sdk_signal_notification.load(Ordering::SeqCst)
|
||||
}
|
||||
@@ -123,6 +286,14 @@ impl CounterSet {
|
||||
self.sdk_logging_notification.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_logging_handler_completed(&self) -> usize {
|
||||
self.sdk_logging_handler_completed.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_logging_handler_consumed(&self) -> usize {
|
||||
self.sdk_logging_handler_consumed.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_completion_dispatch(&self) -> usize {
|
||||
self.sdk_completion_dispatch.load(Ordering::SeqCst)
|
||||
}
|
||||
@@ -130,6 +301,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)
|
||||
}
|
||||
@@ -269,6 +446,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);
|
||||
@@ -293,6 +512,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);
|
||||
@@ -322,10 +564,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);
|
||||
@@ -341,9 +597,23 @@ pub(crate) fn sdk_logging_notification_serialized() {
|
||||
increment(|counters| &counters.sdk_logging_notification);
|
||||
}
|
||||
|
||||
/// Mark after the real logging handler has completed its awaited operation and built its result.
|
||||
pub(crate) fn sdk_logging_handler_completed() {
|
||||
increment(|counters| &counters.sdk_logging_handler_completed);
|
||||
}
|
||||
|
||||
/// Mark only after the caller consumes the actual SDK handler Result.
|
||||
pub(crate) fn sdk_logging_handler_consumed() {
|
||||
increment(|counters| &counters.sdk_logging_handler_consumed);
|
||||
}
|
||||
|
||||
#[path = "../rmcp_logging_runtime_tests.rs"]
|
||||
mod rmcp_logging_runtime_tests;
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "../rmcp_logging_handler_runtime_tests.rs"]
|
||||
mod rmcp_logging_handler_runtime_tests;
|
||||
|
||||
/// Mark only after successfully serializing real SDK ProgressNotificationParam params.
|
||||
pub(crate) fn sdk_progress_notification_serialized() {
|
||||
increment(|counters| &counters.sdk_progress_notification);
|
||||
@@ -369,6 +639,28 @@ pub(crate) fn sdk_subscriptions_acknowledged_serialized() {
|
||||
increment(|counters| &counters.sdk_subscriptions_acknowledged);
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_subscription_listen_entered() {
|
||||
increment(|c| &c.sdk_subscription_listen_entered);
|
||||
}
|
||||
pub(crate) fn sdk_subscription_handler_completed() {
|
||||
increment(|c| &c.sdk_subscription_handler_completed);
|
||||
}
|
||||
pub(crate) fn sdk_subscription_handler_consumed() {
|
||||
increment(|c| &c.sdk_subscription_handler_consumed);
|
||||
}
|
||||
pub(crate) fn sdk_subscription_notification_consumed() {
|
||||
increment(|c| &c.sdk_subscription_notification_consumed);
|
||||
}
|
||||
pub(crate) fn sdk_subscription_owner_completed() {
|
||||
increment(|c| &c.sdk_subscription_owner_completed);
|
||||
}
|
||||
|
||||
#[path = "../rmcp_signals_test_support.rs"]
|
||||
mod signals_test_support;
|
||||
|
||||
#[path = "../rmcp_subscription_handler_runtime_tests.rs"]
|
||||
mod rmcp_subscription_handler_runtime_tests;
|
||||
|
||||
pub(crate) fn sdk_signal_notification_serialized() {
|
||||
increment(|counters| &counters.sdk_signal_notification);
|
||||
}
|
||||
@@ -389,19 +681,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);
|
||||
@@ -410,6 +715,79 @@ pub(crate) fn sdk_initialize_input_consumed(_params: &rmcp::model::InitializeReq
|
||||
#[path = "../rmcp_initialize_input_runtime_tests.rs"]
|
||||
mod rmcp_initialize_input_runtime_tests;
|
||||
|
||||
#[path = "../rmcp_ping_runtime_tests.rs"]
|
||||
mod rmcp_ping_runtime_tests;
|
||||
|
||||
/// Mark immediately after typed method-projection decode, not variant consumption.
|
||||
pub(crate) fn sdk_initialized_notification_decoded(
|
||||
_notification: &rmcp::model::InitializedNotification,
|
||||
) {
|
||||
increment(|counters| &counters.sdk_initialized_decoded);
|
||||
}
|
||||
|
||||
/// Mark inside the matched SDK variant, after guards and immediately before session mutation.
|
||||
pub(crate) fn sdk_initialized_notification_consumed(
|
||||
_notification: &rmcp::model::InitializedNotification,
|
||||
) {
|
||||
increment(|counters| &counters.sdk_initialized_consumed);
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_initialized_handler_completed() {
|
||||
increment(|c| &c.sdk_initialized_handler_completed);
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_initialized_handler_consumed() {
|
||||
increment(|c| &c.sdk_initialized_handler_consumed);
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_cancelled_handler_completed() {
|
||||
increment(|c| &c.sdk_cancelled_handler_completed);
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_cancelled_handler_consumed() {
|
||||
increment(|c| &c.sdk_cancelled_handler_consumed);
|
||||
}
|
||||
|
||||
#[path = "../rmcp_initialized_runtime_tests.rs"]
|
||||
mod rmcp_initialized_runtime_tests;
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "../rmcp_notification_handler_runtime_tests.rs"]
|
||||
mod rmcp_notification_handler_runtime_tests;
|
||||
|
||||
/// Mark after successful SDK envelope decode, independently of routing consumption.
|
||||
pub(crate) fn sdk_dispatch_envelope_decoded() {
|
||||
increment(|counters| &counters.sdk_dispatch_decoded);
|
||||
}
|
||||
|
||||
/// Mark only when decoded method/kind selects the existing registry-backed route.
|
||||
pub(crate) fn sdk_dispatch_envelope_consumed() {
|
||||
increment(|counters| &counters.sdk_dispatch_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,
|
||||
@@ -30,16 +29,13 @@ use super::rmcp_dispatch::{
|
||||
use super::{AgentRoutePath, AppState};
|
||||
use crate::{
|
||||
auth::VerifiedMachineCredential,
|
||||
jsonrpc::{
|
||||
LEGACY_PROTOCOL_VERSION, is_notification, is_request, jsonrpc_error, jsonrpc_result,
|
||||
method_name, params, request_id,
|
||||
},
|
||||
jsonrpc::{LEGACY_PROTOCOL_VERSION, jsonrpc_error, jsonrpc_result, params, request_id},
|
||||
protocol::{
|
||||
CompletionCommand, CompletionOutcome, ContinuationSupport, DispatchDecision,
|
||||
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,
|
||||
CompletionCommand, CompletionOutcome, ContinuationSupport, DispatchDecision, INVALID_LEVEL,
|
||||
Kind, MethodHandler, PromptGetCommand, PromptsCommand, PromptsListCommand, PromptsOutcome,
|
||||
RequestIdentity, ResourceReadCommand, ResourcesCommand, ResourcesListCommand,
|
||||
ResourcesOutcome, ServiceContext, SetLevelCommand, ToolCallCommand, ToolsCommand,
|
||||
ToolsListCommand,
|
||||
},
|
||||
tool_error::execution_locale,
|
||||
transport::{ResponseMode, session_id_from_headers, transport_response},
|
||||
@@ -65,10 +61,20 @@ pub(super) async fn handle_legacy_request(
|
||||
// `protocol::registry` and is read through `dispatch_decision`, so a newly registered method
|
||||
// really reaches its handler and removing a descriptor removes the dispatch.
|
||||
let registration_revision = protocol_version.unwrap_or(LEGACY_PROTOCOL_VERSION);
|
||||
let dispatch = crate::protocol::dispatch_decision(
|
||||
method_name(message).unwrap_or_default(),
|
||||
registration_revision,
|
||||
);
|
||||
let envelope = match crate::protocol::decode_dispatch_envelope(message) {
|
||||
Ok(Some(envelope)) => envelope,
|
||||
_ => {
|
||||
return internal_jsonrpc_error(
|
||||
message,
|
||||
"admitted dispatch envelope could not be decoded",
|
||||
);
|
||||
}
|
||||
};
|
||||
let method = envelope.method();
|
||||
let dispatch =
|
||||
crate::protocol::dispatch_decision(method.unwrap_or_default(), registration_revision);
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_dispatch_envelope_consumed();
|
||||
match dispatch {
|
||||
// G2: the *registered kind* of the matched method, not the envelope shape, decides which
|
||||
// legacy lifecycle action runs. `initialize` is a request and `notifications/initialized` is a
|
||||
@@ -78,27 +84,42 @@ pub(super) async fn handle_legacy_request(
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::Lifecycle,
|
||||
kind: Kind::Method,
|
||||
} if is_request(message) => handle_initialize(state, path, message, response_mode).await,
|
||||
} if envelope.is_request() => handle_initialize(state, path, message, response_mode).await,
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::Lifecycle,
|
||||
kind: Kind::Notification,
|
||||
} if is_notification(message) => {
|
||||
handle_initialized_notification(state, path, headers).await
|
||||
} if envelope.is_notification() => {
|
||||
handle_initialized_notification(
|
||||
state,
|
||||
path,
|
||||
headers,
|
||||
crate::protocol::initialized_notification(message),
|
||||
)
|
||||
.await
|
||||
}
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::Ping,
|
||||
..
|
||||
} if is_request(message) => {
|
||||
} if envelope.is_request() => {
|
||||
let session = match require_initialized_session(&state, path, headers, message).await {
|
||||
Ok(session) => session,
|
||||
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),
|
||||
json!({ "protocolVersion": session.protocol_version }),
|
||||
json!({"protocolVersion": session.protocol_version}),
|
||||
),
|
||||
response_mode,
|
||||
None,
|
||||
@@ -108,7 +129,7 @@ pub(super) async fn handle_legacy_request(
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::ToolList,
|
||||
..
|
||||
} if is_request(message) => {
|
||||
} if envelope.is_request() => {
|
||||
let session = match require_initialized_session(&state, path, headers, message).await {
|
||||
Ok(session) => session,
|
||||
Err(response) => return response,
|
||||
@@ -143,41 +164,17 @@ 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,
|
||||
..
|
||||
} if is_request(message) => {
|
||||
} if envelope.is_request() => {
|
||||
let session = match require_initialized_session(&state, path, headers, message).await {
|
||||
Ok(session) => session,
|
||||
Err(response) => return response,
|
||||
@@ -235,13 +232,13 @@ pub(super) async fn handle_legacy_request(
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::Cancelled,
|
||||
kind: Kind::Notification,
|
||||
} if is_notification(message) => {
|
||||
} if envelope.is_notification() => {
|
||||
handle_cancelled_notification(&state, path, headers, message, credential).await
|
||||
}
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::ResourceList,
|
||||
..
|
||||
} if is_request(message) => {
|
||||
} if envelope.is_request() => {
|
||||
let session = match require_initialized_session(&state, path, headers, message).await {
|
||||
Ok(session) => session,
|
||||
Err(response) => return response,
|
||||
@@ -310,7 +307,7 @@ pub(super) async fn handle_legacy_request(
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::ResourceRead,
|
||||
..
|
||||
} if is_request(message) => {
|
||||
} if envelope.is_request() => {
|
||||
let session = match require_initialized_session(&state, path, headers, message).await {
|
||||
Ok(session) => session,
|
||||
Err(response) => return response,
|
||||
@@ -391,7 +388,7 @@ pub(super) async fn handle_legacy_request(
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::ResourceTemplateList,
|
||||
..
|
||||
} if is_request(message) => {
|
||||
} if envelope.is_request() => {
|
||||
let session = match require_initialized_session(&state, path, headers, message).await {
|
||||
Ok(session) => session,
|
||||
Err(response) => return response,
|
||||
@@ -415,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,
|
||||
)
|
||||
@@ -463,7 +466,7 @@ pub(super) async fn handle_legacy_request(
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::PromptList,
|
||||
..
|
||||
} if is_request(message) => {
|
||||
} if envelope.is_request() => {
|
||||
let session = match require_initialized_session(&state, path, headers, message).await {
|
||||
Ok(session) => session,
|
||||
Err(response) => return response,
|
||||
@@ -528,7 +531,7 @@ pub(super) async fn handle_legacy_request(
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::PromptGet,
|
||||
..
|
||||
} if is_request(message) => {
|
||||
} if envelope.is_request() => {
|
||||
let session = match require_initialized_session(&state, path, headers, message).await {
|
||||
Ok(session) => session,
|
||||
Err(response) => return response,
|
||||
@@ -626,7 +629,7 @@ pub(super) async fn handle_legacy_request(
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::Completion,
|
||||
..
|
||||
} if is_request(message) => {
|
||||
} if envelope.is_request() => {
|
||||
let session = match require_initialized_session(&state, path, headers, message).await {
|
||||
Ok(session) => session,
|
||||
Err(response) => return response,
|
||||
@@ -705,7 +708,7 @@ pub(super) async fn handle_legacy_request(
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::LoggingSetLevel,
|
||||
..
|
||||
} if is_request(message) => {
|
||||
} if envelope.is_request() => {
|
||||
let session = match require_initialized_session(&state, path, headers, message).await {
|
||||
Ok(session) => session,
|
||||
Err(response) => return response,
|
||||
@@ -724,37 +727,30 @@ pub(super) async fn handle_legacy_request(
|
||||
);
|
||||
}
|
||||
};
|
||||
match handle_logging_command(&state.logging_levels, &session.id, command) {
|
||||
LoggingOutcome::Applied(level) => {
|
||||
crate::protocol::set_active_level(Some(level));
|
||||
crate::protocol::note(
|
||||
crate::protocol::LogLevel::Notice,
|
||||
EVENT_LEVEL_APPLIED,
|
||||
"applied",
|
||||
);
|
||||
transport_response(
|
||||
StatusCode::OK,
|
||||
jsonrpc_result(request_id(message), json!({})),
|
||||
let request = match command.validate() {
|
||||
Ok(request) => request,
|
||||
Err(detail) => {
|
||||
return super::dispatch::sdk_error_response(
|
||||
message,
|
||||
response_mode,
|
||||
None,
|
||||
Some(&session.protocol_version),
|
||||
)
|
||||
&session.protocol_version,
|
||||
rmcp::ErrorData::invalid_params(detail, None),
|
||||
);
|
||||
}
|
||||
LoggingOutcome::InvalidParams(detail) => transport_response(
|
||||
StatusCode::OK,
|
||||
jsonrpc_error(request_id(message), -32602, detail),
|
||||
response_mode,
|
||||
None,
|
||||
Some(&session.protocol_version),
|
||||
),
|
||||
}
|
||||
};
|
||||
super::rmcp_logging::response(
|
||||
message,
|
||||
response_mode,
|
||||
&session.protocol_version,
|
||||
super::rmcp_logging::set_level(&state, &session.id, request).await,
|
||||
)
|
||||
}
|
||||
// A notification whose method the registration does not map to this adapter's handlers is
|
||||
// acknowledged without being dispatched, exactly as before.
|
||||
_ if is_notification(message) => StatusCode::ACCEPTED.into_response(),
|
||||
_ if envelope.is_notification() => StatusCode::ACCEPTED.into_response(),
|
||||
// Every remaining decision (unregistered, wrong era, or a handler this adapter does not
|
||||
// serve) is a method-level rejection: no handler, no service entry, no outbound call.
|
||||
_ => match method_name(message) {
|
||||
_ => match method {
|
||||
Some(method) => transport_response(
|
||||
StatusCode::OK,
|
||||
jsonrpc_error(
|
||||
@@ -799,25 +795,19 @@ async fn handle_cancelled_notification(
|
||||
message: &Value,
|
||||
credential: &VerifiedMachineCredential,
|
||||
) -> Response {
|
||||
let request_id = super::rmcp_progress_cancel::decode_cancelled_request_id(¶ms(message));
|
||||
let Some((typed, raw_number)) = super::rmcp_notifications::cancelled_params(¶ms(message))
|
||||
else {
|
||||
return StatusCode::ACCEPTED.into_response();
|
||||
};
|
||||
let session_id = session_id_from_headers(headers).ok().flatten();
|
||||
if let (Some(request_id), Some(session_id)) = (request_id, session_id) {
|
||||
let owned_by_session = match state.sessions.get(&session_id).await {
|
||||
Ok(Some(session)) => {
|
||||
session.workspace_slug == path.workspace_slug
|
||||
&& session.agent_slug == path.agent_slug
|
||||
}
|
||||
_ => false,
|
||||
};
|
||||
if owned_by_session {
|
||||
state.in_flight.cancel(
|
||||
&crate::app::lifecycle::InFlightScope {
|
||||
session_id,
|
||||
owner: in_flight_owner(credential),
|
||||
},
|
||||
&request_id,
|
||||
);
|
||||
}
|
||||
}
|
||||
super::rmcp_notifications::cancelled(
|
||||
Arc::clone(state),
|
||||
path.clone(),
|
||||
credential.clone(),
|
||||
session_id,
|
||||
typed,
|
||||
raw_number,
|
||||
)
|
||||
.await;
|
||||
StatusCode::ACCEPTED.into_response()
|
||||
}
|
||||
@@ -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),
|
||||
};
|
||||
|
||||
@@ -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,107 @@
|
||||
//! Request-owned SDK implementation of the legacy `logging/setLevel` handler.
|
||||
// The pinned legacy revision still requires this deprecated SDK method.
|
||||
#![allow(deprecated)]
|
||||
use super::AppState;
|
||||
use crate::protocol::{self, LogLevel};
|
||||
use rmcp::{ErrorData, RoleServer, ServerHandler, model::*, service::RequestContext};
|
||||
use std::sync::Arc;
|
||||
|
||||
#[derive(Clone)]
|
||||
struct LoggingHandler {
|
||||
store: Arc<protocol::LogLevelStore>,
|
||||
session_id: String,
|
||||
}
|
||||
|
||||
impl ServerHandler for LoggingHandler {
|
||||
async fn set_level(
|
||||
&self,
|
||||
request: SetLevelRequestParams,
|
||||
_context: RequestContext<RoleServer>,
|
||||
) -> Result<(), ErrorData> {
|
||||
#[allow(deprecated)]
|
||||
let level: LogLevel = request.level.into();
|
||||
self.store.set(&self.session_id, level);
|
||||
protocol::set_active_level(Some(level));
|
||||
protocol::note(LogLevel::Notice, protocol::EVENT_LEVEL_APPLIED, "applied");
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_logging_handler_completed();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
async fn request_context() -> Result<RequestContext<RoleServer>, ErrorData> {
|
||||
let ping: ClientJsonRpcMessage = serde_json::from_value(serde_json::json!({
|
||||
"jsonrpc":"2.0", "id":1, "method":"ping"
|
||||
}))
|
||||
.map_err(|_| ErrorData::internal_error("logging handler unavailable", None))?;
|
||||
let (transport, receiver) = rmcp::transport::OneshotTransport::<RoleServer>::new(ping);
|
||||
let info = InitializeRequestParams::new(
|
||||
ClientCapabilities::default(),
|
||||
Implementation::new("crank-logging-context", "1"),
|
||||
);
|
||||
#[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("logging handler unavailable", None))?;
|
||||
drop(receiver);
|
||||
Ok(RequestContext::new(RequestId::Number(1), peer))
|
||||
}
|
||||
|
||||
pub(super) async fn set_level(
|
||||
state: &Arc<AppState>,
|
||||
session_id: &str,
|
||||
request: SetLevelRequestParams,
|
||||
) -> Result<(), ErrorData> {
|
||||
let handler = LoggingHandler {
|
||||
store: Arc::clone(&state.logging_levels),
|
||||
session_id: session_id.to_owned(),
|
||||
};
|
||||
let context = request_context().await?;
|
||||
invoke(&handler, request, context).await
|
||||
}
|
||||
|
||||
async fn invoke(
|
||||
handler: &impl ServerHandler,
|
||||
request: SetLevelRequestParams,
|
||||
context: RequestContext<RoleServer>,
|
||||
) -> Result<(), ErrorData> {
|
||||
ServerHandler::set_level(handler, request, context).await
|
||||
}
|
||||
|
||||
pub(super) fn response(
|
||||
message: &serde_json::Value,
|
||||
mode: crate::transport::ResponseMode,
|
||||
revision: &str,
|
||||
result: Result<(), ErrorData>,
|
||||
) -> axum::response::Response {
|
||||
match result {
|
||||
Ok(()) => {
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_logging_handler_consumed();
|
||||
crate::transport::transport_response(
|
||||
axum::http::StatusCode::OK,
|
||||
crate::jsonrpc::jsonrpc_result(
|
||||
crate::jsonrpc::request_id(message),
|
||||
serde_json::json!({}),
|
||||
),
|
||||
mode,
|
||||
None,
|
||||
Some(revision),
|
||||
)
|
||||
}
|
||||
Err(error) => {
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_logging_handler_consumed();
|
||||
super::dispatch::sdk_error_response(message, mode, revision, error)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "../rmcp_logging_handler_tests.rs"]
|
||||
mod tests;
|
||||
@@ -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,237 @@
|
||||
//! Request-owned SDK execution for legacy notifications/initialized and notifications/cancelled.
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use axum::http::StatusCode;
|
||||
use rmcp::{RoleServer, ServerHandler, model::*, service::NotificationContext};
|
||||
use serde_json::{Map, Value};
|
||||
use tokio::sync::oneshot;
|
||||
|
||||
use super::{AgentRoutePath, AppState};
|
||||
use crate::auth::VerifiedMachineCredential;
|
||||
|
||||
struct OutcomeHandler {
|
||||
operation: Operation,
|
||||
outcome: Mutex<Option<StatusCode>>,
|
||||
}
|
||||
|
||||
enum Operation {
|
||||
Initialized {
|
||||
state: Arc<AppState>,
|
||||
session_id: String,
|
||||
},
|
||||
Cancelled {
|
||||
state: Arc<AppState>,
|
||||
path: AgentRoutePath,
|
||||
credential: VerifiedMachineCredential,
|
||||
session_id: Option<String>,
|
||||
request_id: Option<Value>,
|
||||
},
|
||||
}
|
||||
|
||||
impl OutcomeHandler {
|
||||
fn publish(&self, status: StatusCode) {
|
||||
if let Ok(mut outcome) = self.outcome.lock() {
|
||||
*outcome = Some(status);
|
||||
}
|
||||
}
|
||||
|
||||
fn take(&self) -> Option<StatusCode> {
|
||||
self.outcome.lock().ok()?.take()
|
||||
}
|
||||
}
|
||||
|
||||
impl ServerHandler for OutcomeHandler {
|
||||
async fn on_initialized(&self, _context: NotificationContext<RoleServer>) {
|
||||
if let Operation::Initialized { state, session_id } = &self.operation {
|
||||
let status = match state
|
||||
.sessions
|
||||
.mark_initialized(session_id, time::OffsetDateTime::now_utc())
|
||||
.await
|
||||
{
|
||||
Ok(true) => StatusCode::ACCEPTED,
|
||||
Ok(false) => StatusCode::NOT_FOUND,
|
||||
Err(_) => StatusCode::INTERNAL_SERVER_ERROR,
|
||||
};
|
||||
self.publish(status);
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_initialized_handler_completed();
|
||||
}
|
||||
}
|
||||
|
||||
async fn on_cancelled(
|
||||
&self,
|
||||
params: CancelledNotificationParam,
|
||||
_context: NotificationContext<RoleServer>,
|
||||
) {
|
||||
if let Operation::Cancelled {
|
||||
state,
|
||||
path,
|
||||
credential,
|
||||
session_id,
|
||||
request_id,
|
||||
} = &self.operation
|
||||
{
|
||||
let target = params.request_id.map(|id| {
|
||||
let typed = id.into_json_value();
|
||||
match (request_id, typed) {
|
||||
(Some(Value::Number(original)), Value::String(projected))
|
||||
if original.to_string() == projected =>
|
||||
{
|
||||
Value::Number(original.clone())
|
||||
}
|
||||
(_, typed) => typed,
|
||||
}
|
||||
});
|
||||
if let (Some(target), Some(session_id)) = (target, session_id.as_ref()) {
|
||||
let owned = match state.sessions.get(session_id).await {
|
||||
Ok(Some(session)) => {
|
||||
session.workspace_slug == path.workspace_slug
|
||||
&& session.agent_slug == path.agent_slug
|
||||
}
|
||||
_ => false,
|
||||
};
|
||||
if owned {
|
||||
state.in_flight.cancel(
|
||||
&crate::app::lifecycle::InFlightScope {
|
||||
session_id: session_id.clone(),
|
||||
owner: credential
|
||||
.platform_api_key_id
|
||||
.as_ref()
|
||||
.map_or_else(String::new, |id| id.as_str().to_owned()),
|
||||
},
|
||||
&target,
|
||||
);
|
||||
}
|
||||
}
|
||||
self.publish(StatusCode::ACCEPTED);
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_cancelled_handler_completed();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct Capture(Mutex<Option<oneshot::Sender<NotificationContext<RoleServer>>>>);
|
||||
|
||||
impl ServerHandler for Capture {
|
||||
async fn on_initialized(&self, context: NotificationContext<RoleServer>) {
|
||||
if let Ok(mut sender) = self.0.lock()
|
||||
&& let Some(sender) = sender.take()
|
||||
{
|
||||
let _ = sender.send(context);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn notification_context() -> Result<NotificationContext<RoleServer>, ()> {
|
||||
let message: ClientJsonRpcMessage = serde_json::from_value(serde_json::json!({
|
||||
"jsonrpc":"2.0", "method":"notifications/initialized"
|
||||
}))
|
||||
.map_err(|_| ())?;
|
||||
let (transport, receiver) = rmcp::transport::OneshotTransport::<RoleServer>::new(message);
|
||||
let (sender, captured) = oneshot::channel();
|
||||
let info = InitializeRequestParams::new(
|
||||
ClientCapabilities::default(),
|
||||
Implementation::new("crank-internal", "1"),
|
||||
);
|
||||
let mut running =
|
||||
rmcp::service::serve_directly(Capture(Mutex::new(Some(sender))), transport, Some(info));
|
||||
let context = captured.await;
|
||||
let closed = running.close().await.is_ok();
|
||||
drop(receiver);
|
||||
if !closed {
|
||||
return Err(());
|
||||
}
|
||||
context.map_err(|_| ())
|
||||
}
|
||||
|
||||
pub(super) async fn initialized(state: Arc<AppState>, session_id: String) -> StatusCode {
|
||||
let handler = OutcomeHandler {
|
||||
operation: Operation::Initialized { state, session_id },
|
||||
outcome: Mutex::new(None),
|
||||
};
|
||||
initialized_with(&handler, &handler, notification_context()).await
|
||||
}
|
||||
|
||||
async fn initialized_with(
|
||||
sdk: &impl ServerHandler,
|
||||
outcome: &OutcomeHandler,
|
||||
context: impl std::future::Future<Output = Result<NotificationContext<RoleServer>, ()>>,
|
||||
) -> StatusCode {
|
||||
let Ok(context) = context.await else {
|
||||
return StatusCode::INTERNAL_SERVER_ERROR;
|
||||
};
|
||||
ServerHandler::on_initialized(sdk, context).await;
|
||||
let status = outcome.take();
|
||||
#[cfg(test)]
|
||||
if status.is_some() {
|
||||
super::dispatch_observer::sdk_initialized_handler_consumed();
|
||||
}
|
||||
status.unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
|
||||
}
|
||||
|
||||
// Retain the SDK's typed interpretation and the exact original number used by its safe projection.
|
||||
pub(super) fn cancelled_params(
|
||||
value: &Value,
|
||||
) -> Option<(CancelledNotificationParam, Option<Value>)> {
|
||||
let original = value.get("requestId");
|
||||
let mut projected = Map::new();
|
||||
if let Some(id) = original {
|
||||
let safe = match id {
|
||||
Value::Number(number) if number.as_i64().is_none() => Value::String(number.to_string()),
|
||||
_ => id.clone(),
|
||||
};
|
||||
projected.insert("requestId".to_owned(), safe);
|
||||
}
|
||||
let typed = serde_json::from_value(Value::Object(projected)).ok()?;
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_cancelled_params_decoded();
|
||||
let raw_number = original.filter(|id| id.is_number()).cloned();
|
||||
Some((typed, raw_number))
|
||||
}
|
||||
|
||||
pub(super) async fn cancelled(
|
||||
state: Arc<AppState>,
|
||||
path: AgentRoutePath,
|
||||
credential: VerifiedMachineCredential,
|
||||
session_id: Option<String>,
|
||||
params: CancelledNotificationParam,
|
||||
raw_number: Option<Value>,
|
||||
) {
|
||||
let request_id = raw_number;
|
||||
let handler = OutcomeHandler {
|
||||
operation: Operation::Cancelled {
|
||||
state,
|
||||
path,
|
||||
credential,
|
||||
session_id,
|
||||
request_id,
|
||||
},
|
||||
outcome: Mutex::new(None),
|
||||
};
|
||||
cancelled_with(&handler, &handler, params, notification_context()).await;
|
||||
}
|
||||
|
||||
async fn cancelled_with(
|
||||
sdk: &impl ServerHandler,
|
||||
outcome: &OutcomeHandler,
|
||||
params: CancelledNotificationParam,
|
||||
context: impl std::future::Future<Output = Result<NotificationContext<RoleServer>, ()>>,
|
||||
) {
|
||||
let Ok(context) = context.await else {
|
||||
return;
|
||||
};
|
||||
// Cancellation is intentionally opaque: no outcome or bootstrap details reach the client.
|
||||
ServerHandler::on_cancelled(sdk, params, context).await;
|
||||
let status = outcome.take();
|
||||
if status.is_none() {
|
||||
tracing::warn!(name: "mcp.cancelled_handler.missing_outcome", "SDK cancellation handler did not publish an outcome");
|
||||
}
|
||||
#[cfg(test)]
|
||||
if status.is_some() {
|
||||
super::dispatch_observer::sdk_cancelled_handler_consumed();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "../rmcp_notification_handler_tests.rs"]
|
||||
mod tests;
|
||||
@@ -1,31 +1,11 @@
|
||||
//! Lossless projection of legacy cancellation targets through the pinned SDK.
|
||||
|
||||
use rmcp::model::CancelledNotificationParam;
|
||||
use serde_json::{Map, Value};
|
||||
//! Test compatibility entry for the production notification decoder.
|
||||
use serde_json::Value;
|
||||
|
||||
pub(super) fn decode_cancelled_request_id(params: &Value) -> Option<Value> {
|
||||
let mut projection = Map::new();
|
||||
let original_id = params.get("requestId");
|
||||
if let Some(id) = original_id {
|
||||
// SDK IDs use i64; the temporary string never reaches the in-flight lookup.
|
||||
let projected = match id {
|
||||
Value::Number(number) if number.as_i64().is_none() => Value::String(number.to_string()),
|
||||
_ => id.clone(),
|
||||
};
|
||||
projection.insert("requestId".to_owned(), projected);
|
||||
}
|
||||
// Only requestId names a target; reason, _meta and extensions retain their ignore semantics.
|
||||
let decoded =
|
||||
serde_json::from_value::<CancelledNotificationParam>(Value::Object(projection)).ok()?;
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_cancelled_params_decoded();
|
||||
let id = decoded.request_id?;
|
||||
Some(match original_id {
|
||||
Some(Value::Number(number)) => Value::Number(number.clone()),
|
||||
_ => id.into_json_value(),
|
||||
})
|
||||
let (typed, raw_number) = super::rmcp_notifications::cancelled_params(params)?;
|
||||
let id = typed.request_id?;
|
||||
Some(raw_number.unwrap_or_else(|| id.into_json_value()))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "rmcp_progress_cancel_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,243 @@
|
||||
//! Request-owned SDK subscription execution; the existing SSE receiver owns cancellation.
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use futures_util::{sink, stream};
|
||||
use rmcp::{
|
||||
ErrorData, RoleServer, ServerHandler, Service,
|
||||
model::*,
|
||||
service::{RequestContext, SubscriptionContext},
|
||||
};
|
||||
use serde_json::Value;
|
||||
use tokio::sync::mpsc;
|
||||
|
||||
use crate::protocol::signals::{self, CatalogFingerprint, ReadError, Reader, Watch};
|
||||
|
||||
type PreparedWatch = (Watch, Reader, Result<CatalogFingerprint, ReadError>);
|
||||
|
||||
struct Listener {
|
||||
capabilities: ServerCapabilities,
|
||||
watch: Mutex<Option<PreparedWatch>>,
|
||||
}
|
||||
|
||||
impl ServerHandler for Listener {
|
||||
fn supported_protocol_versions(&self) -> std::borrow::Cow<'static, [ProtocolVersion]> {
|
||||
std::borrow::Cow::Owned(
|
||||
crate::jsonrpc::SUPPORTED_PROTOCOL_VERSIONS
|
||||
.iter()
|
||||
.map(|revision| {
|
||||
serde_json::from_value(Value::String((*revision).to_owned()))
|
||||
.expect("registered revisions match SDK versions")
|
||||
})
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
|
||||
fn get_info(&self) -> ServerConfig {
|
||||
let mut info = ServerConfig::default();
|
||||
info.capabilities = self.capabilities.clone();
|
||||
info
|
||||
}
|
||||
|
||||
fn accepted_subscription_filter(&self, _: &SubscriptionFilter) -> Option<SubscriptionFilter> {
|
||||
Some(
|
||||
serde_json::from_value(serde_json::json!({
|
||||
"toolsListChanged": true, "resourcesListChanged": true, "promptsListChanged": true
|
||||
}))
|
||||
.expect("closed subscription candidate matches SDK"),
|
||||
)
|
||||
}
|
||||
|
||||
async fn listen(&self, context: SubscriptionContext) -> Result<(), ErrorData> {
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_subscription_listen_entered();
|
||||
let (mut watch, read, baseline) = self
|
||||
.watch
|
||||
.lock()
|
||||
.expect("request-local watch lock")
|
||||
.take()
|
||||
.ok_or_else(unavailable)?;
|
||||
let accepted = context.accepted();
|
||||
watch.signals = signals::Signals {
|
||||
tools: accepted.tools_list_changed == Some(true),
|
||||
resources: accepted.resources_list_changed == Some(true),
|
||||
prompts: accepted.prompts_list_changed == Some(true),
|
||||
};
|
||||
let result = signals::run_delivery(
|
||||
watch,
|
||||
signals::Delivery::Subscription(context.sink().clone()),
|
||||
read,
|
||||
baseline,
|
||||
)
|
||||
.await;
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_subscription_handler_completed();
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn project_meta(message: &Value) -> RequestMetaObject {
|
||||
use crate::jsonrpc::{
|
||||
META_CLIENT_CAPABILITIES_KEY, META_CLIENT_INFO_KEY, META_PROTOCOL_VERSION_KEY,
|
||||
};
|
||||
let raw = &message["params"]["_meta"];
|
||||
// Subscription delivery uses no client features; do not revalidate ignored capability extensions.
|
||||
let mut meta = serde_json::json!({
|
||||
META_PROTOCOL_VERSION_KEY: raw[META_PROTOCOL_VERSION_KEY],
|
||||
META_CLIENT_CAPABILITIES_KEY: {},
|
||||
});
|
||||
if let Some(info) = raw.get(META_CLIENT_INFO_KEY) {
|
||||
meta[META_CLIENT_INFO_KEY] =
|
||||
serde_json::json!({"name": info["name"], "version": info["version"]});
|
||||
}
|
||||
serde_json::from_value(meta).expect("admitted identity projection matches SDK metadata")
|
||||
}
|
||||
|
||||
fn unavailable() -> ErrorData {
|
||||
ErrorData::internal_error("subscription handler unavailable", None)
|
||||
}
|
||||
|
||||
pub(super) async fn start(
|
||||
state: Arc<super::AppState>,
|
||||
workspace_slug: String,
|
||||
agent_slug: String,
|
||||
original_id: Value,
|
||||
requested: SubscriptionFilter,
|
||||
meta: RequestMetaObject,
|
||||
) -> Result<(String, mpsc::Receiver<String>), ErrorData> {
|
||||
let watch = Watch {
|
||||
workspace_slug,
|
||||
agent_slug,
|
||||
signals: signals::Signals::ALL,
|
||||
wire: signals::Wire::Legacy,
|
||||
legacy_stream: None,
|
||||
deadline: None,
|
||||
};
|
||||
let mut read = signals::reader(state, &watch);
|
||||
// Keep the single baseline across ACK setup, including Retry/Gone semantics.
|
||||
let baseline = read().await;
|
||||
let capabilities = serde_json::from_value(crate::protocol::advertised_server_capabilities(
|
||||
crate::jsonrpc::MODERN_PROTOCOL_VERSION,
|
||||
))
|
||||
.expect("registered capabilities match SDK shapes");
|
||||
start_with(
|
||||
Listener {
|
||||
capabilities,
|
||||
watch: Mutex::new(Some((watch, read, baseline))),
|
||||
},
|
||||
requested,
|
||||
meta,
|
||||
original_id,
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
async fn start_with(
|
||||
handler: impl ServerHandler,
|
||||
requested: SubscriptionFilter,
|
||||
meta: RequestMetaObject,
|
||||
original_id: Value,
|
||||
) -> Result<(String, mpsc::Receiver<String>), ErrorData> {
|
||||
let (sender, mut receiver) = mpsc::channel(signals::SIGNAL_QUEUE_CAPACITY);
|
||||
let owner = own(handler, requested, meta, original_id, sender);
|
||||
#[cfg(test)]
|
||||
let observer = super::dispatch_observer::installed_observer();
|
||||
#[cfg(test)]
|
||||
let owner = async move {
|
||||
match observer {
|
||||
Some(observer) => super::dispatch_observer::observe(observer, owner).await,
|
||||
None => owner.await,
|
||||
}
|
||||
};
|
||||
let mut task = tokio::spawn(owner);
|
||||
// Dropping this future also drops receiver: the owner closes and joins the SDK pump.
|
||||
tokio::select! {
|
||||
biased;
|
||||
frame = receiver.recv() => match frame {
|
||||
Some(ack) => Ok((ack, receiver)),
|
||||
None => { task.await.map_err(|_| unavailable())??; Err(unavailable()) }
|
||||
},
|
||||
result = &mut task => {
|
||||
result.map_err(|_| unavailable())??;
|
||||
receiver.try_recv().map(|ack| (ack, receiver)).map_err(|_| unavailable())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "../rmcp_subscription_handler_tests.rs"]
|
||||
mod tests;
|
||||
|
||||
async fn own(
|
||||
handler: impl ServerHandler,
|
||||
requested: SubscriptionFilter,
|
||||
meta: RequestMetaObject,
|
||||
original_id: Value,
|
||||
sender: mpsc::Sender<String>,
|
||||
) -> Result<(), ErrorData> {
|
||||
struct Bootstrap;
|
||||
impl ServerHandler for Bootstrap {}
|
||||
let output_sender = sender.clone();
|
||||
#[cfg(test)]
|
||||
let observer = super::dispatch_observer::installed_observer();
|
||||
let output = sink::unfold(output_sender, move |sender, message| {
|
||||
let id = original_id.clone();
|
||||
#[cfg(test)]
|
||||
let observer = observer.clone();
|
||||
async move {
|
||||
let send = async { super::rmcp_subscriptions_output::send(&sender, &id, message) };
|
||||
#[cfg(test)]
|
||||
let send = async {
|
||||
match observer {
|
||||
Some(observer) => super::dispatch_observer::observe(observer, send).await,
|
||||
None => send.await,
|
||||
}
|
||||
};
|
||||
send.await?;
|
||||
Ok::<_, std::io::Error>(sender)
|
||||
}
|
||||
});
|
||||
let running = rmcp::service::serve_directly(
|
||||
Bootstrap,
|
||||
(Box::pin(output), stream::pending::<ClientJsonRpcMessage>()),
|
||||
None,
|
||||
);
|
||||
let mut context =
|
||||
RequestContext::<RoleServer>::new(RequestId::Number(1), running.peer().clone());
|
||||
context.meta = meta;
|
||||
let ct = context.ct.clone();
|
||||
let stop = running.cancellation_token();
|
||||
let pump = running.waiting();
|
||||
tokio::pin!(pump);
|
||||
let mut pump_done = false;
|
||||
let result = {
|
||||
let request = ClientRequest::SubscriptionsListenRequest(SubscriptionsListenRequest::new(
|
||||
SubscriptionsListenRequestParams::new(requested),
|
||||
));
|
||||
let operation = Service::handle_request(&handler, request, context);
|
||||
tokio::pin!(operation);
|
||||
tokio::select! {
|
||||
result = &mut operation => {
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_subscription_handler_consumed();
|
||||
match result {
|
||||
Ok(ServerResult::SubscriptionsListenResult(_)) => Ok(()),
|
||||
Ok(_) => Err(unavailable()),
|
||||
Err(error) => Err(error),
|
||||
}
|
||||
},
|
||||
_ = sender.closed() => Ok(()),
|
||||
_ = &mut pump => { pump_done = true; Err(unavailable()) },
|
||||
}
|
||||
};
|
||||
ct.cancel();
|
||||
stop.cancel();
|
||||
if !pump_done {
|
||||
pump.await.map_err(|_| unavailable())?;
|
||||
}
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_subscription_owner_completed();
|
||||
if result.is_err() {
|
||||
tracing::warn!(name: "mcp.subscription.ended", "subscription handler ended with an error");
|
||||
}
|
||||
result
|
||||
}
|
||||
@@ -0,0 +1,225 @@
|
||||
use std::io;
|
||||
|
||||
use rmcp::model::{ServerJsonRpcMessage, ServerNotification};
|
||||
use serde_json::Value;
|
||||
|
||||
const SUBSCRIPTION_ID: &str = "io.modelcontextprotocol/subscriptionId";
|
||||
const ACK: &str = "notifications/subscriptions/acknowledged";
|
||||
const RESOURCES: &str = "notifications/resources/list_changed";
|
||||
const PROMPTS: &str = "notifications/prompts/list_changed";
|
||||
const TOOLS: &str = "notifications/tools/list_changed";
|
||||
|
||||
pub(super) fn send(
|
||||
sender: &tokio::sync::mpsc::Sender<String>,
|
||||
original_id: &Value,
|
||||
message: ServerJsonRpcMessage,
|
||||
) -> Result<(), io::Error> {
|
||||
let ServerJsonRpcMessage::Notification(notification) = message else {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
"subscription output accepts notifications only",
|
||||
));
|
||||
};
|
||||
|
||||
let (method, is_ack) = match ¬ification.notification {
|
||||
ServerNotification::SubscriptionsAcknowledgedNotification(_) => (ACK, true),
|
||||
ServerNotification::ResourceListChangedNotification(_) => (RESOURCES, false),
|
||||
ServerNotification::PromptListChangedNotification(_) => (PROMPTS, false),
|
||||
ServerNotification::ToolListChangedNotification(_) => (TOOLS, false),
|
||||
_ => {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
"unsupported subscription notification",
|
||||
));
|
||||
}
|
||||
};
|
||||
|
||||
let mut encoded = serde_json::to_value(ServerJsonRpcMessage::Notification(notification))
|
||||
.map_err(io::Error::other)?;
|
||||
if encoded["method"] != method {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidData,
|
||||
"subscription notification method does not match its SDK variant",
|
||||
));
|
||||
}
|
||||
encoded["params"]["_meta"][SUBSCRIPTION_ID] = original_id.clone();
|
||||
let frame = serde_json::to_string(&encoded).map_err(io::Error::other)?;
|
||||
#[cfg(test)]
|
||||
if is_ack {
|
||||
crate::app::dispatch_observer::sdk_subscriptions_acknowledged_serialized();
|
||||
} else {
|
||||
crate::app::dispatch_observer::sdk_signal_notification_serialized();
|
||||
}
|
||||
|
||||
if is_ack {
|
||||
sender.try_send(frame).map_err(|error| match error {
|
||||
tokio::sync::mpsc::error::TrySendError::Full(_) => {
|
||||
io::Error::new(io::ErrorKind::WouldBlock, "subscription ACK queue is full")
|
||||
}
|
||||
tokio::sync::mpsc::error::TrySendError::Closed(_) => {
|
||||
io::Error::new(io::ErrorKind::BrokenPipe, "subscription output is closed")
|
||||
}
|
||||
})?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
match sender.try_send(frame) {
|
||||
Ok(()) | Err(tokio::sync::mpsc::error::TrySendError::Full(_)) => Ok(()),
|
||||
Err(tokio::sync::mpsc::error::TrySendError::Closed(_)) => Err(io::Error::new(
|
||||
io::ErrorKind::BrokenPipe,
|
||||
"subscription output is closed",
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod sdk_controls {
|
||||
use super::*;
|
||||
use futures_util::{sink, stream};
|
||||
use rmcp::{
|
||||
ErrorData, RoleServer, ServerHandler, Service,
|
||||
model::{ClientJsonRpcMessage, RequestId, RequestMetaObject, SubscriptionFilter},
|
||||
service::{RequestContext, SubscriptionContext},
|
||||
};
|
||||
use serde_json::json;
|
||||
use std::sync::{
|
||||
Arc,
|
||||
atomic::{AtomicUsize, Ordering},
|
||||
};
|
||||
use tokio::sync::mpsc;
|
||||
|
||||
struct Bootstrap;
|
||||
impl ServerHandler for Bootstrap {}
|
||||
|
||||
struct Listener {
|
||||
entered: Arc<AtomicUsize>,
|
||||
count: usize,
|
||||
fail: bool,
|
||||
}
|
||||
impl ServerHandler for Listener {
|
||||
fn get_info(&self) -> rmcp::model::ServerConfig {
|
||||
let mut info = rmcp::model::ServerConfig::default();
|
||||
info.capabilities =
|
||||
serde_json::from_value(json!({"tools":{"listChanged":true}})).unwrap();
|
||||
info
|
||||
}
|
||||
fn accepted_subscription_filter(
|
||||
&self,
|
||||
_: &SubscriptionFilter,
|
||||
) -> Option<SubscriptionFilter> {
|
||||
Some(
|
||||
serde_json::from_value(json!({"toolsListChanged":true,"promptsListChanged":true}))
|
||||
.unwrap(),
|
||||
)
|
||||
}
|
||||
async fn listen(&self, context: SubscriptionContext) -> Result<(), ErrorData> {
|
||||
self.entered.fetch_add(1, Ordering::SeqCst);
|
||||
assert_eq!(
|
||||
serde_json::to_value(context.accepted()).unwrap(),
|
||||
json!({"toolsListChanged":true})
|
||||
);
|
||||
assert!(context.sink().notify_prompt_list_changed().await.is_err());
|
||||
if self.fail {
|
||||
return Err(ErrorData::internal_error("listener rejected", None));
|
||||
}
|
||||
for _ in 0..self.count {
|
||||
context.sink().notify_tool_list_changed().await.unwrap();
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
async fn exercise(original_id: Value, count: usize, fail: bool, closed: bool) {
|
||||
let (sender, mut receiver) = mpsc::channel(4);
|
||||
let entered = Arc::new(AtomicUsize::new(0));
|
||||
let handler = Listener {
|
||||
entered: entered.clone(),
|
||||
count,
|
||||
fail,
|
||||
};
|
||||
let output_id = original_id.clone();
|
||||
let output = sink::unfold(sender, move |sender, message| {
|
||||
let id = output_id.clone();
|
||||
async move {
|
||||
send(&sender, &id, message)?;
|
||||
Ok::<_, io::Error>(sender)
|
||||
}
|
||||
});
|
||||
let mut running = rmcp::service::serve_directly(
|
||||
Bootstrap,
|
||||
(Box::pin(output), stream::pending::<ClientJsonRpcMessage>()),
|
||||
None,
|
||||
);
|
||||
let mut context =
|
||||
RequestContext::<RoleServer>::new(RequestId::Number(1), running.peer().clone());
|
||||
context.meta = RequestMetaObject::with_client_context(
|
||||
rmcp::model::ProtocolVersion::V_2026_07_28,
|
||||
rmcp::model::Implementation::new("output-test", "1"),
|
||||
rmcp::model::ClientCapabilities::default(),
|
||||
);
|
||||
let request = serde_json::from_value(json!({"method":"subscriptions/listen", "params":{"notifications":{"toolsListChanged":true,"promptsListChanged":true,"resourcesListChanged":true,"resourceSubscriptions":["crank://excluded"]}}})).unwrap();
|
||||
|
||||
if closed {
|
||||
drop(receiver);
|
||||
let result = Service::handle_request(&handler, request, context).await;
|
||||
assert!(result.is_err());
|
||||
assert_eq!(
|
||||
entered.load(Ordering::SeqCst),
|
||||
0,
|
||||
"ACK send failure must prevent listen"
|
||||
);
|
||||
} else {
|
||||
let result = tokio::time::timeout(
|
||||
std::time::Duration::from_secs(3),
|
||||
Service::handle_request(&handler, request, context),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(entered.load(Ordering::SeqCst), 1);
|
||||
let mut frames = Vec::new();
|
||||
while let Ok(frame) = receiver.try_recv() {
|
||||
frames.push(serde_json::from_str::<Value>(&frame).unwrap());
|
||||
}
|
||||
assert_eq!(frames[0]["method"], ACK);
|
||||
assert_eq!(
|
||||
frames[0]["params"]["notifications"],
|
||||
json!({"toolsListChanged":true})
|
||||
);
|
||||
assert_eq!(frames[0]["params"]["_meta"][SUBSCRIPTION_ID], original_id);
|
||||
assert_eq!(
|
||||
frames[0]["params"]["_meta"][SUBSCRIPTION_ID].to_string(),
|
||||
original_id.to_string()
|
||||
);
|
||||
assert_eq!(frames.len(), (count + 1).min(4));
|
||||
for frame in &frames[1..] {
|
||||
assert_eq!(frame["method"], TOOLS);
|
||||
assert_eq!(
|
||||
frame["params"]["_meta"][SUBSCRIPTION_ID].to_string(),
|
||||
original_id.to_string()
|
||||
);
|
||||
}
|
||||
if fail {
|
||||
assert_eq!(result.unwrap_err().message, "listener rejected");
|
||||
} else {
|
||||
assert!(matches!(
|
||||
result.unwrap(),
|
||||
rmcp::model::ServerResult::SubscriptionsListenResult(_)
|
||||
));
|
||||
}
|
||||
}
|
||||
let peer = running.peer().clone();
|
||||
running.close().await.unwrap();
|
||||
assert!(peer.is_transport_closed());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn actual_sdk_ack_notifications_filters_ids_outcomes_and_bounded_delivery() {
|
||||
for encoded in ["18446744073709551615", "1.234567890123456789e+25"] {
|
||||
exercise(serde_json::from_str(encoded).unwrap(), 1, false, false).await;
|
||||
}
|
||||
exercise(json!("burst"), 10, false, false).await;
|
||||
exercise(json!("no-op"), 0, false, false).await;
|
||||
exercise(json!("error"), 0, true, false).await;
|
||||
exercise(json!("closed"), 1, false, true).await;
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
@@ -0,0 +1,151 @@
|
||||
//! Generic SDK envelopes for routing after the authoritative Crank admission guard.
|
||||
|
||||
use rmcp::model::{JsonRpcNotification, JsonRpcRequest};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) enum DispatchEnvelope {
|
||||
Request(JsonRpcRequest<Value>),
|
||||
Notification(JsonRpcNotification<Value>),
|
||||
}
|
||||
|
||||
impl DispatchEnvelope {
|
||||
pub(crate) fn method(&self) -> Option<&str> {
|
||||
let payload = match self {
|
||||
Self::Request(envelope) => &envelope.request,
|
||||
Self::Notification(envelope) => &envelope.notification,
|
||||
};
|
||||
payload.get("method").and_then(Value::as_str)
|
||||
}
|
||||
|
||||
pub(crate) fn is_request(&self) -> bool {
|
||||
matches!(self, Self::Request(_))
|
||||
}
|
||||
|
||||
pub(crate) fn is_notification(&self) -> bool {
|
||||
matches!(self, Self::Notification(_))
|
||||
}
|
||||
}
|
||||
|
||||
/// 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,
|
||||
) -> Result<Option<DispatchEnvelope>, serde_json::Error> {
|
||||
let Some(method) = message.get("method") else {
|
||||
return Ok(None);
|
||||
};
|
||||
let mut projection = json!({"jsonrpc": message.get("jsonrpc"), "method": method});
|
||||
let envelope = if let Some(id) = message.get("id") {
|
||||
// SDK ids are string/i64; the surrogate must never leave this routing-only envelope.
|
||||
projection["id"] = if id.is_number() && id.as_i64().is_none() {
|
||||
json!(0)
|
||||
} else {
|
||||
id.clone()
|
||||
};
|
||||
DispatchEnvelope::Request(serde_json::from_value(projection)?)
|
||||
} else {
|
||||
DispatchEnvelope::Notification(serde_json::from_value(projection)?)
|
||||
};
|
||||
#[cfg(test)]
|
||||
crate::app::dispatch_observer::sdk_dispatch_envelope_decoded();
|
||||
Ok(Some(envelope))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn arbitrary_method_ignores_params_and_mixed_extra_fields() {
|
||||
for params in [
|
||||
None,
|
||||
Some(json!({})),
|
||||
Some(json!({
|
||||
"_meta": {"clientInfo": false}, "extension": [null, 3]
|
||||
})),
|
||||
] {
|
||||
let mut message = json!({
|
||||
"jsonrpc": "2.0", "id": "request", "method": "private/arbitrary",
|
||||
"result": false, "error": [1], "extension": {"anything": true}
|
||||
});
|
||||
if let Some(params) = params {
|
||||
message["params"] = params;
|
||||
}
|
||||
let original = message.clone();
|
||||
let envelope = decode_dispatch_envelope(&message)
|
||||
.expect("admitted request decodes")
|
||||
.expect("request envelope");
|
||||
assert_eq!(envelope.method(), Some("private/arbitrary"));
|
||||
assert!(envelope.is_request());
|
||||
assert!(!envelope.is_notification());
|
||||
let DispatchEnvelope::Request(request) = envelope else {
|
||||
panic!("request must retain its SDK variant");
|
||||
};
|
||||
assert_eq!(request.request, json!({"method": "private/arbitrary"}));
|
||||
assert_eq!(message, original);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn request_ids_preserve_raw_value_and_only_surrogate_sdk_incompatible_numbers() {
|
||||
for (id, sdk_id) in [
|
||||
(json!("string-id"), json!("string-id")),
|
||||
(json!(i64::MIN), json!(i64::MIN)),
|
||||
(json!(i64::MAX), json!(i64::MAX)),
|
||||
(json!(u64::MAX), json!(0)),
|
||||
(json!(1.25), json!(0)),
|
||||
(json!(1.0), json!(0)),
|
||||
] {
|
||||
let message = json!({"jsonrpc": "2.0", "id": id, "method": "arbitrary"});
|
||||
let original = message.clone();
|
||||
let DispatchEnvelope::Request(request) = decode_dispatch_envelope(&message)
|
||||
.expect("admitted id decodes")
|
||||
.expect("request envelope")
|
||||
else {
|
||||
panic!("id-bearing method must be a request");
|
||||
};
|
||||
assert_eq!(serde_json::to_value(request.id).expect("SDK id"), sdk_id);
|
||||
assert_eq!(message, original);
|
||||
assert_eq!(message.to_string(), original.to_string());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn notification_kind_is_independent_of_method_and_ignored_fields() {
|
||||
let message = json!({
|
||||
"jsonrpc": "2.0", "method": "private/arbitrary", "params": {},
|
||||
"result": {}, "error": {}, "extension": 42
|
||||
});
|
||||
let original = message.clone();
|
||||
let envelope = decode_dispatch_envelope(&message)
|
||||
.expect("notification decodes")
|
||||
.expect("notification envelope");
|
||||
assert_eq!(envelope.method(), Some("private/arbitrary"));
|
||||
assert!(!envelope.is_request());
|
||||
assert!(envelope.is_notification());
|
||||
let DispatchEnvelope::Notification(notification) = envelope else {
|
||||
panic!("notification must retain its SDK variant");
|
||||
};
|
||||
assert_eq!(
|
||||
notification.notification,
|
||||
json!({"method": "private/arbitrary"})
|
||||
);
|
||||
assert_eq!(message, original);
|
||||
}
|
||||
|
||||
#[test]
|
||||
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"}}),
|
||||
json!({"jsonrpc": "2.0", "error": {"code": -1, "message": "error"}}),
|
||||
] {
|
||||
assert!(
|
||||
decode_dispatch_envelope(&message)
|
||||
.expect("response bypass")
|
||||
.is_none()
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,14 +1,10 @@
|
||||
//! Typed negotiation results; admission and session lifecycle remain in the HTTP adapter.
|
||||
|
||||
use rmcp::model::{
|
||||
CacheScope, DiscoverResult, Implementation, InitializeRequestParams, InitializeResult,
|
||||
ProtocolVersion, ServerCapabilities,
|
||||
};
|
||||
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()
|
||||
@@ -45,37 +38,14 @@ fn restore_registry_extensions(result: &mut Value, advertised: Value) {
|
||||
}
|
||||
}
|
||||
|
||||
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");
|
||||
pub(crate) fn initialized_notification(message: &Value) -> rmcp::model::ClientNotification {
|
||||
// Admission already checked the envelope; ignored params must not acquire SDK constraints.
|
||||
let notification: rmcp::model::InitializedNotification =
|
||||
serde_json::from_value(serde_json::json!({"method": message["method"]}))
|
||||
.expect("registry dispatched a validated initialized notification");
|
||||
#[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
|
||||
crate::app::dispatch_observer::sdk_initialized_notification_decoded(¬ification);
|
||||
notification.into()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -186,7 +186,8 @@ impl SetLevelCommand {
|
||||
}
|
||||
}
|
||||
|
||||
/// A neutral outcome of the shared `logging/setLevel` service.
|
||||
/// Compatibility outcome for the original protocol unit tests; runtime uses the SDK handler.
|
||||
#[cfg(test)]
|
||||
pub(crate) enum LoggingOutcome {
|
||||
/// The level of this client context was accepted.
|
||||
Applied(LogLevel),
|
||||
@@ -394,6 +395,7 @@ impl LogLevelStore {
|
||||
///
|
||||
/// The command has already been parsed from the wire form, so this function only validates and
|
||||
/// records; it never reads the registry, the catalog or any stored value.
|
||||
#[cfg(test)]
|
||||
pub(crate) fn handle_logging_command(
|
||||
store: &LogLevelStore,
|
||||
session_id: &str,
|
||||
|
||||
@@ -26,12 +26,16 @@ use crate::transport::{json_response, protocol_version_from_headers, singleton_h
|
||||
|
||||
mod command;
|
||||
mod completion;
|
||||
mod dispatch_sdk;
|
||||
mod lifecycle_sdk;
|
||||
mod logging;
|
||||
mod prompts;
|
||||
mod registry;
|
||||
mod resources;
|
||||
mod signals;
|
||||
mod response_sdk;
|
||||
pub(crate) mod signals;
|
||||
|
||||
pub(crate) use dispatch_sdk::decode_dispatch_envelope;
|
||||
|
||||
pub(crate) use command::{
|
||||
ContinuationSupport, ServiceContext, ToolCallCommand, ToolCallOutcome, ToolsCommand,
|
||||
@@ -41,12 +45,11 @@ pub(crate) use completion::{
|
||||
CompletionArgument, CompletionCommand, CompletionOutcome, CompletionReference,
|
||||
handle_completion_command,
|
||||
};
|
||||
pub(crate) use lifecycle_sdk::{discover_result, initialize_params, initialize_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,
|
||||
in_carried_scope, modern_request_level, note, scoped as logging_scope, set_active_level,
|
||||
set_sse_acceptable, take_notifications,
|
||||
LogLevel, LogLevelStore, SetLevelCommand, carry_scope, in_carried_scope, modern_request_level,
|
||||
note, scoped as logging_scope, set_active_level, set_sse_acceptable, take_notifications,
|
||||
};
|
||||
pub(crate) use prompts::{
|
||||
PromptGetCommand, PromptsCommand, PromptsListCommand, PromptsOutcome, handle_prompts_command,
|
||||
@@ -57,7 +60,7 @@ pub(crate) use resources::{
|
||||
};
|
||||
pub(crate) use signals::{
|
||||
FilterOutcome, INVALID_LISTEN_FILTER, ListenParams, Signals, StreamRegistry, Watch, Wire,
|
||||
acknowledged_frame, frames_stream, spawn as spawn_signal_watch, subscription_id,
|
||||
frames_stream, spawn as spawn_signal_watch, subscription_id,
|
||||
};
|
||||
|
||||
/// Resolved era of an incoming POST request.
|
||||
@@ -86,50 +89,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
|
||||
@@ -255,7 +214,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));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -176,12 +176,18 @@ impl<'de> Deserialize<'de> for ListenParams {
|
||||
/// The bounded input contract of a `subscriptions/listen` filter.
|
||||
pub(crate) enum FilterOutcome {
|
||||
/// The list-change subset this server honours for the stream.
|
||||
// Compatibility projection retained for the existing filter controls; SDK owns runtime acceptance.
|
||||
#[cfg_attr(not(test), allow(dead_code))]
|
||||
Accepted(Signals),
|
||||
/// One safe detail: no URI, name or value the client sent is echoed back.
|
||||
Invalid(&'static str),
|
||||
}
|
||||
|
||||
impl ListenFilter {
|
||||
pub(crate) fn into_sdk(self) -> SubscriptionFilter {
|
||||
self.0
|
||||
}
|
||||
|
||||
/// Validate the bounded inputs and keep only the honoured types.
|
||||
///
|
||||
/// `resourceSubscriptions` is not implemented in the current scope, which is what the
|
||||
@@ -269,6 +275,7 @@ pub(crate) enum Wire {
|
||||
/// `2025-11-25`: a bare server notification without parameters.
|
||||
Legacy,
|
||||
/// `2026-07-28`: every message carries the subscription id of its `subscriptions/listen` request.
|
||||
#[cfg(test)]
|
||||
Modern(Value),
|
||||
}
|
||||
|
||||
@@ -285,6 +292,7 @@ impl Wire {
|
||||
}
|
||||
let subscription_id = match self {
|
||||
Wire::Legacy => None,
|
||||
#[cfg(test)]
|
||||
Wire::Modern(subscription_id) => Some(subscription_id),
|
||||
};
|
||||
frames.push(sdk::signal_frame(method, subscription_id));
|
||||
@@ -294,6 +302,7 @@ impl Wire {
|
||||
}
|
||||
|
||||
/// The first modern frame: the accepted subset, before any list-change notification of the stream.
|
||||
#[cfg(test)]
|
||||
pub(crate) fn acknowledged_frame(subscription_id: &Value, accepted: Signals) -> String {
|
||||
sdk::acknowledged_frame(subscription_id, accepted)
|
||||
}
|
||||
@@ -382,13 +391,17 @@ pub(crate) type Reader = Box<dyn FnMut() -> ReadFuture + Send>;
|
||||
///
|
||||
/// The first read is the baseline taken **before** the acknowledgment is written; it is never reset
|
||||
/// afterwards, so a publication between the baseline and the acknowledgment is still delivered.
|
||||
pub(crate) fn spawn(state: Arc<AppState>, watch: Watch) -> mpsc::Receiver<String> {
|
||||
pub(crate) fn reader(state: Arc<AppState>, watch: &Watch) -> Reader {
|
||||
let scope = (watch.workspace_slug.clone(), watch.agent_slug.clone());
|
||||
let reader: Reader = Box::new(move || {
|
||||
Box::new(move || {
|
||||
let state = Arc::clone(&state);
|
||||
let scope = scope.clone();
|
||||
Box::pin(async move { read(&state, &scope).await })
|
||||
});
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn spawn(state: Arc<AppState>, watch: Watch) -> mpsc::Receiver<String> {
|
||||
let reader = reader(state, &watch);
|
||||
let (sender, receiver) = mpsc::channel(SIGNAL_QUEUE_CAPACITY);
|
||||
#[cfg(not(test))]
|
||||
tokio::spawn(run(watch, sender, reader));
|
||||
@@ -408,10 +421,57 @@ pub(crate) fn spawn(state: Arc<AppState>, watch: Watch) -> mpsc::Receiver<String
|
||||
receiver
|
||||
}
|
||||
|
||||
pub(crate) enum Delivery {
|
||||
Frames(mpsc::Sender<String>),
|
||||
Subscription(rmcp::service::SubscriptionSink),
|
||||
}
|
||||
|
||||
impl Delivery {
|
||||
async fn send(&self, wire: &Wire, signals: Signals) -> Result<(), rmcp::ErrorData> {
|
||||
match self {
|
||||
Self::Frames(sender) => {
|
||||
for frame in wire.signal_frames(signals) {
|
||||
let _ = sender.try_send(frame);
|
||||
}
|
||||
}
|
||||
Self::Subscription(sink) => {
|
||||
if signals.resources {
|
||||
sink.notify_resource_list_changed()
|
||||
.await
|
||||
.map_err(send_error)?;
|
||||
}
|
||||
if signals.prompts {
|
||||
sink.notify_prompt_list_changed()
|
||||
.await
|
||||
.map_err(send_error)?;
|
||||
}
|
||||
if signals.tools {
|
||||
sink.notify_tool_list_changed().await.map_err(send_error)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn send_error(_: rmcp::service::SubscriptionSendError) -> rmcp::ErrorData {
|
||||
rmcp::ErrorData::internal_error("subscription output unavailable", None)
|
||||
}
|
||||
|
||||
async fn run(watch: Watch, sender: mpsc::Sender<String>, mut read: Reader) {
|
||||
let mut baseline = match read().await {
|
||||
let initial = read().await;
|
||||
let _ = run_delivery(watch, Delivery::Frames(sender), read, initial).await;
|
||||
}
|
||||
|
||||
pub(crate) async fn run_delivery(
|
||||
watch: Watch,
|
||||
delivery: Delivery,
|
||||
mut read: Reader,
|
||||
initial: Result<CatalogFingerprint, ReadError>,
|
||||
) -> Result<(), rmcp::ErrorData> {
|
||||
let mut baseline = match initial {
|
||||
Ok(fingerprint) => Some(fingerprint),
|
||||
Err(ReadError::Gone) => return,
|
||||
Err(ReadError::Gone) => return Ok(()),
|
||||
Err(ReadError::Retry) => {
|
||||
observe_failure();
|
||||
None
|
||||
@@ -419,36 +479,33 @@ async fn run(watch: Watch, sender: mpsc::Sender<String>, mut read: Reader) {
|
||||
};
|
||||
|
||||
loop {
|
||||
if !still_owned(&watch) || sender.is_closed() {
|
||||
return;
|
||||
if !still_owned(&watch)
|
||||
|| matches!(&delivery, Delivery::Frames(sender) if sender.is_closed())
|
||||
{
|
||||
return Ok(());
|
||||
}
|
||||
if watch
|
||||
.deadline
|
||||
.is_some_and(|deadline| Instant::now() >= deadline)
|
||||
{
|
||||
return;
|
||||
return Ok(());
|
||||
}
|
||||
tokio::time::sleep(POLL_INTERVAL).await;
|
||||
if !still_owned(&watch) {
|
||||
return;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
match read().await {
|
||||
Ok(fingerprint) => {
|
||||
if let Some(previous) = baseline.as_ref() {
|
||||
let changes = fingerprint.changes_since(previous).intersect(watch.signals);
|
||||
for frame in watch.wire.signal_frames(changes) {
|
||||
// A slow reader coalesces: the newest frame is dropped instead of blocking
|
||||
// the producer or growing a queue, and the client recovers through the
|
||||
// authoritative list methods.
|
||||
let _ = sender.try_send(frame);
|
||||
}
|
||||
delivery.send(&watch.wire, changes).await?;
|
||||
}
|
||||
baseline = Some(fingerprint);
|
||||
}
|
||||
// The Agent is no longer published: fail closed by ending the stream instead of serving a
|
||||
// catalog nobody may read any more.
|
||||
Err(ReadError::Gone) => return,
|
||||
Err(ReadError::Gone) => return Ok(()),
|
||||
// The committed catalog is untouched: the failure is observable and this tick is skipped.
|
||||
Err(_) => observe_failure(),
|
||||
}
|
||||
@@ -499,15 +556,39 @@ pub(crate) fn frames_stream<G: Send + 'static>(
|
||||
guard: G,
|
||||
) -> impl stream::Stream<Item = Result<Event, std::convert::Infallible>> {
|
||||
let pending: VecDeque<String> = first.into();
|
||||
#[cfg(test)]
|
||||
let observer = crate::app::dispatch_observer::installed_observer();
|
||||
stream::unfold(
|
||||
(pending, receiver, guard),
|
||||
|(mut pending, mut receiver, guard)| async move {
|
||||
loop {
|
||||
if let Some(frame) = pending.pop_front() {
|
||||
return Some((Ok(Event::default().data(frame)), (pending, receiver, guard)));
|
||||
move |(mut pending, mut receiver, guard)| {
|
||||
#[cfg(test)]
|
||||
let observer = observer.clone();
|
||||
async move {
|
||||
loop {
|
||||
if let Some(frame) = pending.pop_front() {
|
||||
#[cfg(test)]
|
||||
if let Ok(value) = serde_json::from_str::<Value>(&frame)
|
||||
&& value["params"]["_meta"].get(SUBSCRIPTION_ID_KEY).is_some()
|
||||
&& matches!(
|
||||
value["method"].as_str(),
|
||||
Some(
|
||||
RESOURCE_LIST_CHANGED | PROMPT_LIST_CHANGED | TOOL_LIST_CHANGED
|
||||
)
|
||||
)
|
||||
&& let Some(observer) = observer.as_ref()
|
||||
{
|
||||
crate::app::dispatch_observer::observe(Arc::clone(observer), async {
|
||||
crate::app::dispatch_observer::sdk_subscription_notification_consumed();
|
||||
}).await;
|
||||
}
|
||||
return Some((
|
||||
Ok(Event::default().data(frame)),
|
||||
(pending, receiver, guard),
|
||||
));
|
||||
}
|
||||
let frame = receiver.recv().await?;
|
||||
pending.push_back(frame);
|
||||
}
|
||||
let frame = receiver.recv().await?;
|
||||
pending.push_back(frame);
|
||||
}
|
||||
},
|
||||
)
|
||||
|
||||
@@ -2,12 +2,18 @@
|
||||
|
||||
use rmcp::model::{
|
||||
JsonRpcNotification, JsonRpcVersion2_0, NotificationMetaObject, PromptListChangedNotification,
|
||||
ResourceListChangedNotification, SubscriptionFilter, SubscriptionsAcknowledgedNotification,
|
||||
SubscriptionsAcknowledgedNotificationParams, ToolListChangedNotification,
|
||||
ResourceListChangedNotification, ToolListChangedNotification,
|
||||
};
|
||||
#[cfg(test)]
|
||||
use rmcp::model::{
|
||||
SubscriptionFilter, SubscriptionsAcknowledgedNotification,
|
||||
SubscriptionsAcknowledgedNotificationParams,
|
||||
};
|
||||
use serde_json::{Map, Value};
|
||||
|
||||
use super::{PROMPT_LIST_CHANGED, RESOURCE_LIST_CHANGED, Signals, TOOL_LIST_CHANGED};
|
||||
#[cfg(test)]
|
||||
use super::Signals;
|
||||
use super::{PROMPT_LIST_CHANGED, RESOURCE_LIST_CHANGED, TOOL_LIST_CHANGED};
|
||||
|
||||
fn subscription_meta(subscription_id: &Value) -> NotificationMetaObject {
|
||||
let mut meta = Map::new();
|
||||
@@ -60,6 +66,7 @@ pub(super) fn signal_frame(method: &str, subscription_id: Option<&Value>) -> Str
|
||||
frame
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(super) fn acknowledged_frame(subscription_id: &Value, accepted: Signals) -> String {
|
||||
let mut notifications = SubscriptionFilter::new();
|
||||
notifications.resources_list_changed = accepted.resources.then_some(true);
|
||||
|
||||
@@ -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:?}"
|
||||
|
||||
@@ -0,0 +1,330 @@
|
||||
//! #107 generic dispatch: existing wire GREEN precedes independent SDK RED assertions.
|
||||
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};
|
||||
#[path = "rmcp_dispatch_test_support.rs"]
|
||||
mod fixtures;
|
||||
use fixtures::*;
|
||||
|
||||
async fn success_control() -> Vec<[usize; 2]> {
|
||||
let h = endpoint().await;
|
||||
let mut deltas = vec![];
|
||||
for revision in [LEGACY_REVISION, MODERN_REVISION] {
|
||||
let session = prepared(&h, revision).await;
|
||||
for accept in ["application/json", "text/event-stream, application/json"] {
|
||||
for id in [
|
||||
json!("dispatch/Ю"),
|
||||
json!(18446744073709551615u64),
|
||||
json!(3.25),
|
||||
] {
|
||||
for method in ["tools/list", "ping"] {
|
||||
let mut message = payload(revision, method, id.clone());
|
||||
// Legacy params remain absent; modern identity metadata remains mandatory.
|
||||
message["extension"] = json!({"future":[null,true]});
|
||||
message["result"] = json!({"ignored":true});
|
||||
message["error"] = json!({"ignored":"not an error envelope"});
|
||||
let before = sdk(&h.counters);
|
||||
let ops = h.sessions.snapshot();
|
||||
let entries = h.counters.snapshot();
|
||||
let response = request(&h, revision, session.as_deref(), accept, message)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 200);
|
||||
assert_eq!(response.headers()["MCP-Protocol-Version"], revision);
|
||||
assert!(response.headers().get("MCP-Session-Id").is_none());
|
||||
let wire = body(response, accept.starts_with("text/event-stream")).await;
|
||||
assert_eq!(wire["jsonrpc"], "2.0");
|
||||
assert_eq!(wire["id"], id, "lossless response correlation");
|
||||
assert!(wire.get("error").is_none(), "{wire}");
|
||||
if method == "tools/list" {
|
||||
assert_eq!(wire["result"]["tools"][0]["name"], TOOL_NAME);
|
||||
assert_eq!(wire["result"]["tools"].as_array().unwrap().len(), 1);
|
||||
} else {
|
||||
let result = if revision == MODERN_REVISION {
|
||||
json!({"protocolVersion":revision,"resultType":"complete"})
|
||||
} else {
|
||||
json!({"protocolVersion":revision})
|
||||
};
|
||||
assert_eq!(wire, json!({"jsonrpc":"2.0","id":id,"result":result}));
|
||||
}
|
||||
if revision == MODERN_REVISION {
|
||||
assert_eq!(wire["result"]["resultType"], "complete");
|
||||
assert_eq!(h.sessions.snapshot(), ops, "no modern session access");
|
||||
}
|
||||
assert_deltas(
|
||||
method,
|
||||
entries,
|
||||
h.counters.snapshot(),
|
||||
Snapshot::new(
|
||||
1,
|
||||
usize::from(revision == MODERN_REVISION),
|
||||
usize::from(revision == LEGACY_REVISION),
|
||||
usize::from(method == "tools/list"),
|
||||
),
|
||||
);
|
||||
assert_eq!(h.started.load(Ordering::SeqCst), 0);
|
||||
let after = sdk(&h.counters);
|
||||
deltas.push([after[0] - before[0], after[1] - before[1]]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
eprintln!(
|
||||
"existing GREEN 24 HTTP requests after legacy handshake / modern discovery; SDK deltas={deltas:?}"
|
||||
);
|
||||
deltas
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn wire_positive_control_json_sse_ids_tolerance_and_routes() {
|
||||
success_control().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn sdk_envelope_decoded_on_successful_http() {
|
||||
let deltas = success_control().await;
|
||||
assert_eq!(
|
||||
deltas.iter().map(|d| d[0]).collect::<Vec<_>>(),
|
||||
vec![1; 24],
|
||||
"successful HTTP must decode a real SDK request envelope"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn sdk_envelope_consumed_for_registry_routing_on_successful_http() {
|
||||
let deltas = success_control().await;
|
||||
assert_eq!(
|
||||
deltas.iter().map(|d| d[1]).collect::<Vec<_>>(),
|
||||
vec![1; 24],
|
||||
"decoded SDK method/kind must drive registry routing, not decode-and-discard"
|
||||
);
|
||||
}
|
||||
|
||||
async fn notification_control() -> Vec<[usize; 2]> {
|
||||
let h = endpoint().await;
|
||||
let response = request(
|
||||
&h,
|
||||
LEGACY_REVISION,
|
||||
None,
|
||||
"application/json",
|
||||
legacy_initialize(1),
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 200);
|
||||
let session = response.headers()["MCP-Session-Id"]
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.to_owned();
|
||||
let _ = body(response, false).await;
|
||||
for method in ["notifications/initialized", "unknown/notification"] {
|
||||
let mut wrong_kind = json!({"jsonrpc":"2.0","id":"wrong-kind","method":method});
|
||||
let ops = h.sessions.snapshot();
|
||||
let response = request(
|
||||
&h,
|
||||
LEGACY_REVISION,
|
||||
Some(&session),
|
||||
"application/json",
|
||||
wrong_kind.clone(),
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 200);
|
||||
assert_eq!(body(response, false).await["error"]["code"], -32601);
|
||||
assert_eq!(h.sessions.snapshot().mark_initialized, ops.mark_initialized);
|
||||
assert!(!h.sessions.retained(&session).await.unwrap().initialized);
|
||||
wrong_kind.as_object_mut().unwrap().remove("id");
|
||||
if method.starts_with("unknown") {
|
||||
ack(request(
|
||||
&h,
|
||||
LEGACY_REVISION,
|
||||
Some(&session),
|
||||
"application/json",
|
||||
wrong_kind,
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap())
|
||||
.await;
|
||||
assert!(!h.sessions.retained(&session).await.unwrap().initialized);
|
||||
}
|
||||
}
|
||||
let before = sdk(&h.counters);
|
||||
ack(request(
|
||||
&h,
|
||||
LEGACY_REVISION,
|
||||
Some(&session),
|
||||
"application/json",
|
||||
initialized_notification(),
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap())
|
||||
.await;
|
||||
assert!(h.sessions.retained(&session).await.unwrap().initialized);
|
||||
let after = sdk(&h.counters);
|
||||
let mut deltas = vec![[after[0] - before[0], after[1] - before[1]]];
|
||||
let ops = h.sessions.snapshot();
|
||||
let entries = h.counters.snapshot();
|
||||
for method in [
|
||||
"notifications/initialized",
|
||||
"unknown/notification",
|
||||
"tools/call",
|
||||
] {
|
||||
let mut message = payload(MODERN_REVISION, method, json!(1));
|
||||
message.as_object_mut().unwrap().remove("id");
|
||||
let mut req = request(&h, MODERN_REVISION, None, "application/json", message)
|
||||
.build()
|
||||
.unwrap();
|
||||
req.headers_mut().remove("Mcp-Method");
|
||||
req.headers_mut().remove("Mcp-Name");
|
||||
let before = sdk(&h.counters);
|
||||
ack(reqwest::Client::new().execute(req).await.unwrap()).await;
|
||||
let after = sdk(&h.counters);
|
||||
deltas.push([after[0] - before[0], after[1] - before[1]]);
|
||||
}
|
||||
assert_eq!(h.sessions.snapshot(), ops);
|
||||
assert_eq!(h.counters.snapshot().tools_service, entries.tools_service);
|
||||
assert_eq!(h.started.load(Ordering::SeqCst), 0);
|
||||
eprintln!("existing GREEN notification kind/state/early ACK; SDK deltas={deltas:?}");
|
||||
deltas
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn notification_order_and_legacy_registered_kind_wire_control() {
|
||||
notification_control().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn sdk_notification_kind_consumed_on_successful_http() {
|
||||
assert_eq!(
|
||||
notification_control().await,
|
||||
vec![[1, 1]; 4],
|
||||
"SDK notification variant must drive legacy handshake / modern early ACK"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rejection_controls_never_enter_service_or_outbound() {
|
||||
let h = endpoint().await;
|
||||
for revision in [LEGACY_REVISION, MODERN_REVISION] {
|
||||
let session = prepared(&h, revision).await;
|
||||
let base = payload(revision, "tools/list", json!("reject"));
|
||||
let mut malformed = base.clone();
|
||||
malformed["jsonrpc"] = json!("1.0");
|
||||
let mut bad_params = base.clone();
|
||||
bad_params["params"] = json!([]);
|
||||
let mut bad_meta = base.clone();
|
||||
bad_meta["params"] = json!({"_meta":false});
|
||||
let unknown = payload(revision, "unknown/request", json!("reject"));
|
||||
let wrong_era = payload(
|
||||
revision,
|
||||
if revision == MODERN_REVISION {
|
||||
"initialize"
|
||||
} else {
|
||||
"server/discover"
|
||||
},
|
||||
json!("reject"),
|
||||
);
|
||||
for (message, status, code) in [
|
||||
(malformed, 400, -32600),
|
||||
(bad_params, 400, -32600),
|
||||
(bad_meta, 400, -32020),
|
||||
(
|
||||
unknown,
|
||||
if revision == MODERN_REVISION {
|
||||
404
|
||||
} else {
|
||||
200
|
||||
},
|
||||
-32601,
|
||||
),
|
||||
(
|
||||
wrong_era,
|
||||
if revision == MODERN_REVISION {
|
||||
404
|
||||
} else {
|
||||
200
|
||||
},
|
||||
-32601,
|
||||
),
|
||||
] {
|
||||
let entries = h.counters.snapshot();
|
||||
let ops = h.sessions.snapshot();
|
||||
let response = request(
|
||||
&h,
|
||||
revision,
|
||||
session.as_deref(),
|
||||
"application/json",
|
||||
message.clone(),
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status().as_u16(), status, "{revision} {message}");
|
||||
let wire = body(response, false).await;
|
||||
assert_eq!(wire["error"]["code"], code, "{revision} {message}: {wire}");
|
||||
assert!(wire.get("result").is_none());
|
||||
assert_eq!(h.counters.snapshot().tools_service, entries.tools_service);
|
||||
assert_eq!(h.started.load(Ordering::SeqCst), 0);
|
||||
if revision == MODERN_REVISION {
|
||||
assert_eq!(h.sessions.snapshot(), ops);
|
||||
}
|
||||
}
|
||||
}
|
||||
for (header, value) in [("Mcp-Method", "ping"), ("Mcp-Name", "wrong-tool")] {
|
||||
let ops = h.sessions.snapshot();
|
||||
let entries = h.counters.snapshot();
|
||||
let message = json!({"jsonrpc":"2.0","id":"headers","method":"tools/call","params":{"name":TOOL_NAME,"arguments":{"email":"dispatch@example.com"},"_meta":modern_meta()}});
|
||||
let response = request(&h, MODERN_REVISION, None, "application/json", message)
|
||||
.header(header, value)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 400);
|
||||
assert!(body(response, false).await.get("error").is_some());
|
||||
assert_eq!(h.sessions.snapshot(), ops);
|
||||
assert_eq!(h.counters.snapshot().tools_service, entries.tools_service);
|
||||
assert_eq!(h.started.load(Ordering::SeqCst), 0);
|
||||
}
|
||||
let ops = h.sessions.snapshot();
|
||||
let response = request(
|
||||
&h,
|
||||
"2099-01-01",
|
||||
None,
|
||||
"application/json",
|
||||
payload(LEGACY_REVISION, "tools/list", json!(1)),
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 400);
|
||||
assert!(body(response, false).await.get("error").is_some());
|
||||
assert_eq!(h.sessions.snapshot(), ops);
|
||||
assert_eq!(h.started.load(Ordering::SeqCst), 0);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn observer_independent_positive_control() {
|
||||
let a = Arc::new(CounterSet::default());
|
||||
let b = Arc::new(CounterSet::default());
|
||||
super::sdk_dispatch_envelope_decoded();
|
||||
super::sdk_dispatch_envelope_consumed();
|
||||
assert_eq!(sdk(&a), [0, 0]);
|
||||
tokio::join!(
|
||||
observe(a.clone(), async {
|
||||
super::sdk_dispatch_envelope_decoded();
|
||||
}),
|
||||
observe(b.clone(), async {
|
||||
super::sdk_dispatch_envelope_consumed();
|
||||
})
|
||||
);
|
||||
assert_eq!(sdk(&a), [1, 0]);
|
||||
assert_eq!(sdk(&b), [0, 1]);
|
||||
assert_eq!(a.snapshot(), Snapshot::new(0, 0, 0, 0));
|
||||
assert_eq!(b.snapshot(), Snapshot::new(0, 0, 0, 0));
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
//! Narrow HTTP helpers; all app/auth/catalog/upstream fixtures remain shared.
|
||||
use super::*;
|
||||
|
||||
pub(super) async fn endpoint() -> Endpoint {
|
||||
crank_test_support::postgres_schema_url_for_task("dispatch_owner", "t_e862066c").await;
|
||||
Endpoint::started().await
|
||||
}
|
||||
|
||||
pub(super) fn sdk(c: &CounterSet) -> [usize; 2] {
|
||||
[c.sdk_dispatch_decoded(), c.sdk_dispatch_consumed()]
|
||||
}
|
||||
|
||||
pub(super) fn payload(revision: &str, method: &str, id: Value) -> Value {
|
||||
let mut message = json!({"jsonrpc":"2.0","id":id,"method":method});
|
||||
if revision == MODERN_REVISION {
|
||||
message["params"] = json!({"_meta":modern_meta()});
|
||||
}
|
||||
message
|
||||
}
|
||||
|
||||
pub(super) fn request(
|
||||
h: &Endpoint,
|
||||
revision: &str,
|
||||
session: Option<&str>,
|
||||
accept: &str,
|
||||
message: Value,
|
||||
) -> reqwest::RequestBuilder {
|
||||
h.request(revision, session, &h.key, accept, message)
|
||||
.header("x-request-id", "dispatch-atdd")
|
||||
.header(
|
||||
"traceparent",
|
||||
"00-11111111111111111111111111111111-2222222222222222-01",
|
||||
)
|
||||
}
|
||||
|
||||
pub(super) async fn body(response: reqwest::Response, sse: bool) -> Value {
|
||||
assert_eq!(response.headers()["x-request-id"], "dispatch-atdd");
|
||||
assert_eq!(
|
||||
response.headers()["x-trace-id"],
|
||||
"11111111111111111111111111111111"
|
||||
);
|
||||
assert!(
|
||||
response.headers()["content-type"]
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.starts_with(if sse {
|
||||
"text/event-stream"
|
||||
} else {
|
||||
"application/json"
|
||||
})
|
||||
);
|
||||
let raw = tokio::time::timeout(std::time::Duration::from_secs(6), response.text())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
if sse {
|
||||
let frames: Vec<Value> = raw
|
||||
.lines()
|
||||
.filter_map(|l| l.strip_prefix("data:"))
|
||||
.map(|l| serde_json::from_str(l.trim()).unwrap())
|
||||
.collect();
|
||||
assert_eq!(frames.len(), 1, "one terminal SSE frame: {raw}");
|
||||
frames.into_iter().next().unwrap()
|
||||
} else {
|
||||
serde_json::from_str(&raw).unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) 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());
|
||||
}
|
||||
|
||||
pub(super) async fn prepared(h: &Endpoint, revision: &str) -> Option<String> {
|
||||
if revision == LEGACY_REVISION {
|
||||
return h.session(revision).await;
|
||||
}
|
||||
let ops = h.sessions.snapshot();
|
||||
let response = request(
|
||||
h,
|
||||
revision,
|
||||
None,
|
||||
"application/json",
|
||||
payload(revision, "server/discover", json!(1)),
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 200);
|
||||
assert_eq!(response.headers()["MCP-Protocol-Version"], revision);
|
||||
assert!(response.headers().get("MCP-Session-Id").is_none());
|
||||
let wire = body(response, false).await;
|
||||
assert_eq!(
|
||||
wire["result"]["supportedVersions"],
|
||||
json!([MODERN_REVISION, LEGACY_REVISION])
|
||||
);
|
||||
assert_eq!(wire["result"]["resultType"], "complete");
|
||||
assert!(wire.get("error").is_none(), "{wire}");
|
||||
assert_eq!(h.sessions.snapshot(), ops);
|
||||
None
|
||||
}
|
||||
@@ -395,7 +395,7 @@ async fn rmcp_initialize_input_observer_positive_control() {
|
||||
super::sdk_initialize_input_consumed(¶ms);
|
||||
assert_eq!(c.sdk_initialize_input(), 1);
|
||||
assert_eq!(
|
||||
c.sdk_initialize_result(),
|
||||
c.sdk_initialize_handler_consumed(),
|
||||
0,
|
||||
"input and output are independent"
|
||||
);
|
||||
|
||||
@@ -0,0 +1,272 @@
|
||||
//! Initialized HTTP transition against the existing PostgreSQL store, not an SDK session manager.
|
||||
use super::*;
|
||||
use crate::session::{PostgresTransportSessionStore, TransportSessionStore};
|
||||
use crate::session::{SessionState, SessionStoreError};
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use time::OffsetDateTime;
|
||||
|
||||
struct FaultStore {
|
||||
inner: PostgresTransportSessionStore,
|
||||
fail_get: AtomicBool,
|
||||
fail_mark: AtomicBool,
|
||||
delete_on_mark: AtomicBool,
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl TransportSessionStore for FaultStore {
|
||||
async fn create(
|
||||
&self,
|
||||
revision: &str,
|
||||
workspace: &str,
|
||||
agent: &str,
|
||||
elicitation: bool,
|
||||
now: OffsetDateTime,
|
||||
expires: Option<OffsetDateTime>,
|
||||
) -> Result<String, SessionStoreError> {
|
||||
self.inner
|
||||
.create(revision, workspace, agent, elicitation, now, expires)
|
||||
.await
|
||||
}
|
||||
async fn get(&self, id: &str) -> Result<Option<SessionState>, SessionStoreError> {
|
||||
if self.fail_get.load(Ordering::SeqCst) {
|
||||
return Err(SessionStoreError {
|
||||
details: "test read failure".into(),
|
||||
});
|
||||
}
|
||||
self.inner.get(id).await
|
||||
}
|
||||
async fn mark_initialized(
|
||||
&self,
|
||||
id: &str,
|
||||
now: OffsetDateTime,
|
||||
) -> Result<bool, SessionStoreError> {
|
||||
if self.fail_mark.load(Ordering::SeqCst) {
|
||||
return Err(SessionStoreError {
|
||||
details: "test mark failure".into(),
|
||||
});
|
||||
}
|
||||
if self.delete_on_mark.load(Ordering::SeqCst) {
|
||||
self.inner.delete(id).await?;
|
||||
}
|
||||
self.inner.mark_initialized(id, now).await
|
||||
}
|
||||
async fn delete(&self, id: &str) -> Result<bool, SessionStoreError> {
|
||||
self.inner.delete(id).await
|
||||
}
|
||||
async fn cleanup_expired(&self, now: OffsetDateTime) -> Result<u64, SessionStoreError> {
|
||||
self.inner.cleanup_expired(now).await
|
||||
}
|
||||
async fn active_count(&self, now: OffsetDateTime) -> Result<u64, SessionStoreError> {
|
||||
self.inner.active_count(now).await
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn initialized_durable_transition_reconnect_and_store_failures() {
|
||||
crank_test_support::postgres_schema_url_for_task("initialized_durable", "t_9c033310").await;
|
||||
let registry = test_registry().await;
|
||||
let pool = registry.pool().clone();
|
||||
let store = Arc::new(FaultStore {
|
||||
inner: PostgresTransportSessionStore::from_pool(pool.clone())
|
||||
.await
|
||||
.unwrap(),
|
||||
fail_get: AtomicBool::new(false),
|
||||
fail_mark: AtomicBool::new(false),
|
||||
delete_on_mark: AtomicBool::new(false),
|
||||
});
|
||||
let h = Endpoint::started_with_store(Some(store.clone())).await;
|
||||
let response = post(&h, None, "application/json", legacy_initialize(80)).await;
|
||||
assert_eq!(response.status(), 200);
|
||||
let id = response.headers()["MCP-Session-Id"]
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.to_owned();
|
||||
let before = store.get(&id).await.unwrap().unwrap();
|
||||
assert!(!before.initialized);
|
||||
let response = post(
|
||||
&h,
|
||||
Some(&id),
|
||||
"application/json",
|
||||
initialized_notification(),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(response.status(), 202);
|
||||
assert!(response.bytes().await.unwrap().is_empty());
|
||||
assert_eq!(sdk(&h.counters), [1, 1]);
|
||||
let restarted = PostgresTransportSessionStore::from_pool(pool.clone())
|
||||
.await
|
||||
.unwrap();
|
||||
let after = restarted.get(&id).await.unwrap().unwrap();
|
||||
assert!(after.initialized);
|
||||
assert_eq!(after.id, before.id);
|
||||
assert_eq!(after.workspace_slug, before.workspace_slug);
|
||||
assert_eq!(after.agent_slug, before.agent_slug);
|
||||
assert_eq!(after.protocol_version, before.protocol_version);
|
||||
assert_eq!(after.created_at, before.created_at);
|
||||
assert_eq!(after.expires_at, before.expires_at);
|
||||
assert_eq!(after.supports_elicitation, before.supports_elicitation);
|
||||
let response = post(
|
||||
&h,
|
||||
Some(&id),
|
||||
"application/json",
|
||||
json!({"jsonrpc":"2.0","id":81,"method":"ping"}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(response.status(), 200);
|
||||
assert!(body(response, false).await.get("error").is_none());
|
||||
|
||||
let pending = store
|
||||
.create(
|
||||
LEGACY_REVISION,
|
||||
WORKSPACE_SLUG,
|
||||
AGENT_SLUG,
|
||||
false,
|
||||
OffsetDateTime::now_utc(),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
store.fail_mark.store(true, Ordering::SeqCst);
|
||||
let counts = sdk(&h.counters);
|
||||
let response = post(
|
||||
&h,
|
||||
Some(&pending),
|
||||
"application/json",
|
||||
initialized_notification(),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(response.status(), 500);
|
||||
assert!(response.bytes().await.unwrap().is_empty());
|
||||
assert_eq!(sdk(&h.counters), [counts[0] + 1, counts[1] + 1]);
|
||||
assert!(!restarted.get(&pending).await.unwrap().unwrap().initialized);
|
||||
store.fail_mark.store(false, Ordering::SeqCst);
|
||||
|
||||
// Fail reads without touching registry/auth tables; admission must stop before the SDK.
|
||||
store.fail_get.store(true, Ordering::SeqCst);
|
||||
let counts = sdk(&h.counters);
|
||||
let response = post(
|
||||
&h,
|
||||
Some(&pending),
|
||||
"application/json",
|
||||
initialized_notification(),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(response.status(), 500);
|
||||
assert_eq!(sdk(&h.counters), counts);
|
||||
store.fail_get.store(false, Ordering::SeqCst);
|
||||
assert!(!restarted.get(&pending).await.unwrap().unwrap().initialized);
|
||||
|
||||
// Session can disappear after admission/scoped reads but before the durable UPDATE.
|
||||
store.delete_on_mark.store(true, Ordering::SeqCst);
|
||||
let completed = h.counters.sdk_initialized_handler_completed();
|
||||
let consumed = h.counters.sdk_initialized_handler_consumed();
|
||||
let response = post(
|
||||
&h,
|
||||
Some(&pending),
|
||||
"application/json",
|
||||
initialized_notification(),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(response.status(), 404);
|
||||
assert!(response.bytes().await.unwrap().is_empty());
|
||||
assert_eq!(
|
||||
h.counters.sdk_initialized_handler_completed(),
|
||||
completed + 1
|
||||
);
|
||||
assert_eq!(h.counters.sdk_initialized_handler_consumed(), consumed + 1);
|
||||
assert!(restarted.get(&pending).await.unwrap().is_none());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn initialized_foreign_and_revision_guards_leave_state_untouched() {
|
||||
let h = endpoint().await;
|
||||
for (revision, workspace, agent) in [
|
||||
(LEGACY_REVISION, "foreign-workspace", AGENT_SLUG),
|
||||
(LEGACY_REVISION, WORKSPACE_SLUG, "foreign-agent"),
|
||||
("2024-11-05", WORKSPACE_SLUG, AGENT_SLUG),
|
||||
(MODERN_REVISION, WORKSPACE_SLUG, AGENT_SLUG),
|
||||
] {
|
||||
let id = h
|
||||
.sessions
|
||||
.create(
|
||||
revision,
|
||||
workspace,
|
||||
agent,
|
||||
false,
|
||||
OffsetDateTime::now_utc(),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let state = h.sessions.retained(&id).await.unwrap();
|
||||
let ops = h.sessions.snapshot();
|
||||
let counts = sdk(&h.counters);
|
||||
let response = post(
|
||||
&h,
|
||||
Some(&id),
|
||||
"application/json",
|
||||
initialized_notification(),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(
|
||||
response.status(),
|
||||
if workspace != WORKSPACE_SLUG || agent != AGENT_SLUG {
|
||||
404
|
||||
} else {
|
||||
400
|
||||
}
|
||||
);
|
||||
assert_eq!(h.counters.sdk_initialized_consumed(), counts[1]);
|
||||
if workspace == WORKSPACE_SLUG && agent == AGENT_SLUG {
|
||||
assert_eq!(h.counters.sdk_initialized_decoded(), counts[0]);
|
||||
}
|
||||
assert_eq!(h.sessions.snapshot().mark_initialized, ops.mark_initialized);
|
||||
assert_eq!(h.sessions.retained(&id).await.unwrap(), state);
|
||||
}
|
||||
let id = initialize(&h, "application/json").await;
|
||||
let counts = sdk(&h.counters);
|
||||
let ops = h.sessions.snapshot();
|
||||
let response = h
|
||||
.request(
|
||||
LEGACY_REVISION,
|
||||
Some(&id),
|
||||
&h.key,
|
||||
"application/json",
|
||||
initialized_notification(),
|
||||
)
|
||||
.header("MCP-Session-Id", "conflicting-session")
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 400);
|
||||
assert_eq!(sdk(&h.counters), counts);
|
||||
assert_eq!(h.sessions.snapshot().mark_initialized, ops.mark_initialized);
|
||||
assert!(!h.sessions.retained(&id).await.unwrap().initialized);
|
||||
h.registry
|
||||
.revoke_platform_api_key_for_agent(
|
||||
&workspace_id(),
|
||||
&agent_id(),
|
||||
&crank_core::PlatformApiKeyId::new("pk_progress_other"),
|
||||
&OffsetDateTime::now_utc(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let counts = sdk(&h.counters);
|
||||
let ops = h.sessions.snapshot();
|
||||
let response = h
|
||||
.request(
|
||||
LEGACY_REVISION,
|
||||
Some(&id),
|
||||
&h.other_key,
|
||||
"application/json",
|
||||
initialized_notification(),
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 401);
|
||||
assert_eq!(sdk(&h.counters), counts);
|
||||
assert_eq!(h.sessions.snapshot().create, ops.create);
|
||||
assert_eq!(h.sessions.snapshot().mark_initialized, ops.mark_initialized);
|
||||
assert!(!h.sessions.retained(&id).await.unwrap().initialized);
|
||||
}
|
||||
@@ -0,0 +1,305 @@
|
||||
//! #107 initialized: real HTTP wire control, independent SDK decode and consumption 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, time::Duration};
|
||||
|
||||
#[path = "rmcp_initialized_durable_tests.rs"]
|
||||
mod durable;
|
||||
|
||||
async fn endpoint() -> Endpoint {
|
||||
crank_test_support::postgres_schema_url_for_task("initialized_owner", "t_9c033310").await;
|
||||
Endpoint::started().await
|
||||
}
|
||||
|
||||
fn sdk(c: &CounterSet) -> [usize; 2] {
|
||||
[c.sdk_initialized_decoded(), c.sdk_initialized_consumed()]
|
||||
}
|
||||
|
||||
async fn post(
|
||||
h: &Endpoint,
|
||||
session: Option<&str>,
|
||||
accept: &str,
|
||||
payload: Value,
|
||||
) -> reqwest::Response {
|
||||
h.request(LEGACY_REVISION, session, &h.key, accept, payload)
|
||||
.header("x-request-id", "initialized-atdd")
|
||||
.header(
|
||||
"traceparent",
|
||||
"00-11111111111111111111111111111111-2222222222222222-01",
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
fn correlation(response: &reqwest::Response) {
|
||||
assert_eq!(response.headers()["x-request-id"], "initialized-atdd");
|
||||
assert_eq!(
|
||||
response.headers()["x-trace-id"],
|
||||
"11111111111111111111111111111111"
|
||||
);
|
||||
}
|
||||
|
||||
async fn body(response: reqwest::Response, sse: bool) -> Value {
|
||||
correlation(&response);
|
||||
assert!(
|
||||
response.headers()["content-type"]
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.starts_with(if sse {
|
||||
"text/event-stream"
|
||||
} else {
|
||||
"application/json"
|
||||
})
|
||||
);
|
||||
let raw = tokio::time::timeout(Duration::from_secs(6), response.text())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
if sse {
|
||||
let frames: Vec<Value> = raw
|
||||
.lines()
|
||||
.filter_map(|l| l.strip_prefix("data:"))
|
||||
.map(|l| serde_json::from_str(l.trim()).unwrap())
|
||||
.collect();
|
||||
assert_eq!(frames.len(), 1, "one terminal SSE frame: {raw}");
|
||||
frames.into_iter().next().unwrap()
|
||||
} else {
|
||||
serde_json::from_str(&raw).unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
async fn initialize(h: &Endpoint, accept: &str) -> String {
|
||||
let response = post(h, None, accept, legacy_initialize(71)).await;
|
||||
assert_eq!(response.status(), 200);
|
||||
assert_eq!(response.headers()["MCP-Protocol-Version"], LEGACY_REVISION);
|
||||
let id = response.headers()["MCP-Session-Id"]
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.to_owned();
|
||||
let wire = body(response, accept.starts_with("text/event-stream")).await;
|
||||
assert_eq!(wire["id"], 71);
|
||||
assert_eq!(wire["result"]["protocolVersion"], LEGACY_REVISION);
|
||||
assert!(wire.get("error").is_none());
|
||||
let state = h.sessions.retained(&id).await.expect("retained session");
|
||||
assert!(!state.initialized);
|
||||
assert_eq!(state.workspace_slug, WORKSPACE_SLUG);
|
||||
assert_eq!(state.agent_slug, AGENT_SLUG);
|
||||
id
|
||||
}
|
||||
|
||||
async fn control() -> Vec<[usize; 2]> {
|
||||
let h = endpoint().await;
|
||||
let mut deltas = vec![];
|
||||
for accept in ["application/json", "text/event-stream, application/json"] {
|
||||
for params in [
|
||||
None,
|
||||
Some(json!({})),
|
||||
Some(json!({"ignored":[null,true],
|
||||
"protocolVersion":false,"capabilities":42,"_meta":{"future":[]}})),
|
||||
] {
|
||||
let id = initialize(&h, accept).await;
|
||||
let untouched = initialize(&h, "application/json").await;
|
||||
let before_state = h.sessions.retained(&id).await.unwrap();
|
||||
let mut notification = json!({"jsonrpc":"2.0","method":"notifications/initialized",
|
||||
"extension":{"future":[null,42]}});
|
||||
if let Some(params) = params {
|
||||
notification["params"] = params;
|
||||
}
|
||||
let before = sdk(&h.counters);
|
||||
let ops = h.sessions.snapshot();
|
||||
let admission = h.counters.snapshot();
|
||||
let response = post(&h, Some(&id), accept, notification.clone()).await;
|
||||
assert_eq!(response.status(), 202);
|
||||
correlation(&response);
|
||||
assert!(response.headers().get("MCP-Session-Id").is_none());
|
||||
assert!(response.headers().get("content-type").is_none());
|
||||
assert!(response.bytes().await.unwrap().is_empty());
|
||||
assert_session_ops(
|
||||
"initialized",
|
||||
ops,
|
||||
h.sessions.snapshot(),
|
||||
SessionOps {
|
||||
get: 2,
|
||||
create: 0,
|
||||
mark_initialized: 1,
|
||||
},
|
||||
);
|
||||
assert_deltas(
|
||||
"initialized",
|
||||
admission,
|
||||
h.counters.snapshot(),
|
||||
Snapshot::new(1, 0, 1, 0),
|
||||
);
|
||||
let after = sdk(&h.counters);
|
||||
deltas.push([after[0] - before[0], after[1] - before[1]]);
|
||||
let state = h.sessions.retained(&id).await.unwrap();
|
||||
assert!(state.initialized);
|
||||
assert_eq!(state.id, before_state.id);
|
||||
assert_eq!(state.workspace_slug, before_state.workspace_slug);
|
||||
assert_eq!(state.agent_slug, before_state.agent_slug);
|
||||
assert_eq!(state.protocol_version, before_state.protocol_version);
|
||||
assert_eq!(state.created_at, before_state.created_at);
|
||||
assert_eq!(state.expires_at, before_state.expires_at);
|
||||
assert_eq!(
|
||||
state.supports_elicitation,
|
||||
before_state.supports_elicitation
|
||||
);
|
||||
assert!(state.updated_at >= before_state.updated_at);
|
||||
assert!(!h.sessions.retained(&untouched).await.unwrap().initialized);
|
||||
let response = post(
|
||||
&h,
|
||||
Some(&id),
|
||||
accept,
|
||||
json!({"jsonrpc":"2.0","id":"tools/Ю","method":"tools/list"}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(response.status(), 200);
|
||||
assert_eq!(response.headers()["MCP-Protocol-Version"], LEGACY_REVISION);
|
||||
let wire = body(response, accept.starts_with("text/event-stream")).await;
|
||||
assert_eq!(wire["id"], "tools/Ю");
|
||||
assert!(wire.get("error").is_none());
|
||||
assert_eq!(wire["result"]["tools"][0]["name"], TOOL_NAME);
|
||||
eprintln!(
|
||||
"existing GREEN initialize -> initialized -> tools/list accept={accept} notification={notification}; SDK delta={:?}",
|
||||
deltas.last().unwrap()
|
||||
);
|
||||
}
|
||||
}
|
||||
deltas
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn initialized_wire_handshake_tolerance_and_scoped_state() {
|
||||
control().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn initialized_sdk_decoded_on_real_http_handshake() {
|
||||
let deltas = control().await;
|
||||
assert_eq!(
|
||||
deltas.iter().map(|d| d[0]).collect::<Vec<_>>(),
|
||||
vec![1; 6],
|
||||
"real HTTP initialized must decode the SDK InitializedNotification"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn initialized_sdk_variant_consumed_by_session_transition() {
|
||||
let deltas = control().await;
|
||||
assert_eq!(
|
||||
deltas.iter().map(|d| d[1]).collect::<Vec<_>>(),
|
||||
vec![1; 6],
|
||||
"matched ClientNotification variant must drive the real scoped session mutation, not just decode"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn initialized_admission_and_wrong_kind_never_mutate_or_consume() {
|
||||
let h = endpoint().await;
|
||||
let id = initialize(&h, "application/json").await;
|
||||
let mut wrong_initialize = legacy_initialize(72);
|
||||
wrong_initialize.as_object_mut().unwrap().remove("id");
|
||||
let mut wrong_initialized = initialized_notification();
|
||||
wrong_initialized["id"] = json!(73);
|
||||
let mut cases = vec![
|
||||
(wrong_initialize, 202, None),
|
||||
(wrong_initialized, 200, Some(-32601)),
|
||||
];
|
||||
for params in [json!(null), json!(true), json!(42), json!("bad"), json!([])] {
|
||||
cases.push((
|
||||
json!({"jsonrpc":"2.0","method":"notifications/initialized","params":params}),
|
||||
400,
|
||||
Some(-32600),
|
||||
));
|
||||
}
|
||||
for meta in [
|
||||
json!(null),
|
||||
json!(false),
|
||||
json!(42),
|
||||
json!("bad"),
|
||||
json!([]),
|
||||
] {
|
||||
cases.push((
|
||||
json!({"jsonrpc":"2.0","method":"notifications/initialized","params":{"_meta":meta}}),
|
||||
400,
|
||||
Some(-32020),
|
||||
));
|
||||
}
|
||||
cases.push((
|
||||
json!({"jsonrpc":"1.0","method":"notifications/initialized"}),
|
||||
400,
|
||||
Some(-32600),
|
||||
));
|
||||
for (payload, status, code) in cases {
|
||||
let ops = h.sessions.snapshot();
|
||||
let before = sdk(&h.counters);
|
||||
let response = post(&h, Some(&id), "application/json", payload.clone()).await;
|
||||
assert_eq!(response.status().as_u16(), status, "{payload}");
|
||||
if let Some(code) = code {
|
||||
let wire = body(response, false).await;
|
||||
assert_eq!(wire["error"]["code"], code, "{payload}: {wire}");
|
||||
assert!(wire.get("result").is_none());
|
||||
} else {
|
||||
assert!(response.bytes().await.unwrap().is_empty());
|
||||
}
|
||||
let after = h.sessions.snapshot();
|
||||
assert_eq!(after.create, ops.create);
|
||||
assert_eq!(after.mark_initialized, ops.mark_initialized);
|
||||
assert!(!h.sessions.retained(&id).await.unwrap().initialized);
|
||||
assert_eq!(
|
||||
sdk(&h.counters),
|
||||
before,
|
||||
"rejected before SDK decode/consume: {payload}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn initialized_missing_unknown_sessions_and_modern_never_consume() {
|
||||
let h = endpoint().await;
|
||||
for (session, status) in [(None, 400), (Some("unknown-session"), 404)] {
|
||||
let ops = h.sessions.snapshot();
|
||||
let response = post(&h, session, "application/json", initialized_notification()).await;
|
||||
assert_eq!(response.status().as_u16(), status);
|
||||
assert!(response.bytes().await.unwrap().is_empty());
|
||||
assert_eq!(h.sessions.snapshot().mark_initialized, ops.mark_initialized);
|
||||
assert_eq!(h.counters.sdk_initialized_consumed(), 0);
|
||||
}
|
||||
let ops = h.sessions.snapshot();
|
||||
let response = h.request(MODERN_REVISION, None, &h.key, "application/json",
|
||||
json!({"jsonrpc":"2.0","method":"notifications/initialized","params":{"_meta":modern_meta()}}))
|
||||
.send().await.unwrap();
|
||||
assert_eq!(response.status(), 202);
|
||||
assert!(response.bytes().await.unwrap().is_empty());
|
||||
assert_eq!(
|
||||
h.sessions.snapshot(),
|
||||
ops,
|
||||
"modern signal never accesses storage"
|
||||
);
|
||||
assert_eq!(h.counters.sdk_initialized_consumed(), 0);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn initialized_observer_independent_positive_control() {
|
||||
let a = Arc::new(CounterSet::default());
|
||||
let b = Arc::new(CounterSet::default());
|
||||
let notification: rmcp::model::InitializedNotification =
|
||||
serde_json::from_value(json!({"method":"notifications/initialized"})).unwrap();
|
||||
super::sdk_initialized_notification_decoded(¬ification);
|
||||
super::sdk_initialized_notification_consumed(¬ification);
|
||||
assert_eq!(sdk(&a), [0, 0]);
|
||||
tokio::join!(
|
||||
observe(a.clone(), async {
|
||||
super::sdk_initialized_notification_decoded(¬ification);
|
||||
}),
|
||||
observe(b.clone(), async {
|
||||
super::sdk_initialized_notification_consumed(¬ification);
|
||||
})
|
||||
);
|
||||
assert_eq!(sdk(&a), [1, 0]);
|
||||
assert_eq!(sdk(&b), [0, 1], "decode alone never proves consumption");
|
||||
assert_eq!(a.snapshot(), Snapshot::new(0, 0, 0, 0));
|
||||
assert_eq!(b.snapshot(), Snapshot::new(0, 0, 0, 0));
|
||||
}
|
||||
@@ -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,12 @@
|
||||
//! Handler-specific acceptance oracle, distinct from existing wire-level GREEN controls.
|
||||
use super::rmcp_logging_runtime_tests;
|
||||
|
||||
#[tokio::test]
|
||||
async fn legacy_logging_http_completes_and_consumes_the_sdk_handler() {
|
||||
// Existing real build_app HTTP control proves the JSON/SSE contract independently.
|
||||
assert_eq!(
|
||||
rmcp_logging_runtime_tests::control("2025-11-25").await,
|
||||
[1, 1, 1, 1, 1],
|
||||
"legacy wire succeeded but the awaited SDK handler was not completed/consumed"
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,155 @@
|
||||
#![allow(deprecated)]
|
||||
use super::*;
|
||||
use crate::protocol::SetLevelCommand;
|
||||
use serde_json::json;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
fn request(level: &str) -> SetLevelRequestParams {
|
||||
serde_json::from_value(json!({"level": level})).expect("valid SDK logging level")
|
||||
}
|
||||
fn handler(store: &Arc<protocol::LogLevelStore>) -> LoggingHandler {
|
||||
LoggingHandler {
|
||||
store: store.clone(),
|
||||
session_id: "current".into(),
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn typed_sdk_level_is_the_applied_level_and_execution_is_single() {
|
||||
let store = Arc::new(protocol::LogLevelStore::new());
|
||||
store.set("other", LogLevel::Debug);
|
||||
let counters = Arc::new(super::super::dispatch_observer::CounterSet::default());
|
||||
let events = super::super::dispatch_observer::observe(
|
||||
counters.clone(),
|
||||
protocol::logging_scope(async {
|
||||
// Mutate the typed value after validation: no raw command may override it later.
|
||||
let mut typed = SetLevelCommand {
|
||||
level: "critical".into(),
|
||||
}
|
||||
.validate()
|
||||
.unwrap();
|
||||
typed.level = LoggingLevel::Info;
|
||||
let result = invoke(&handler(&store), typed, request_context().await.unwrap()).await;
|
||||
assert!(result.is_ok());
|
||||
protocol::set_sse_acceptable();
|
||||
let events = protocol::take_notifications();
|
||||
let response = response(
|
||||
&json!({"id":91}),
|
||||
crate::transport::ResponseMode::Json,
|
||||
crate::jsonrpc::LEGACY_PROTOCOL_VERSION,
|
||||
result,
|
||||
);
|
||||
assert_eq!(response.status(), 200);
|
||||
assert_eq!(store.get("current"), Some(LogLevel::Info));
|
||||
assert_eq!(store.get("other"), Some(LogLevel::Debug));
|
||||
events
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(counters.sdk_logging_handler_completed(), 1);
|
||||
assert_eq!(counters.sdk_logging_handler_consumed(), 1);
|
||||
assert_eq!(events.len(), 1);
|
||||
assert_eq!(
|
||||
events[0]["params"]["data"],
|
||||
json!({
|
||||
"event": protocol::EVENT_LEVEL_APPLIED, "outcome": "applied"
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
struct Controlled {
|
||||
inner: LoggingHandler,
|
||||
entered: AtomicUsize,
|
||||
error: Option<ErrorData>,
|
||||
pending: bool,
|
||||
}
|
||||
impl ServerHandler for Controlled {
|
||||
async fn set_level(
|
||||
&self,
|
||||
request: SetLevelRequestParams,
|
||||
context: RequestContext<RoleServer>,
|
||||
) -> Result<(), ErrorData> {
|
||||
self.entered.fetch_add(1, Ordering::SeqCst);
|
||||
if let Some(error) = &self.error {
|
||||
return Err(error.clone());
|
||||
}
|
||||
if self.pending {
|
||||
std::future::pending::<()>().await;
|
||||
}
|
||||
ServerHandler::set_level(&self.inner, request, context).await
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn actual_trait_error_controls_the_http_response_without_store_effect() {
|
||||
let store = Arc::new(protocol::LogLevelStore::new());
|
||||
let error = ErrorData::invalid_params("controlled handler error", None);
|
||||
let controlled = Controlled {
|
||||
inner: handler(&store),
|
||||
entered: AtomicUsize::new(0),
|
||||
error: Some(error),
|
||||
pending: false,
|
||||
};
|
||||
for mode in [
|
||||
crate::transport::ResponseMode::Json,
|
||||
crate::transport::ResponseMode::Sse,
|
||||
] {
|
||||
let result = invoke(
|
||||
&controlled,
|
||||
request("notice"),
|
||||
request_context().await.unwrap(),
|
||||
)
|
||||
.await;
|
||||
let reply = response(
|
||||
&json!({"id":"controlled"}),
|
||||
mode,
|
||||
crate::jsonrpc::LEGACY_PROTOCOL_VERSION,
|
||||
result,
|
||||
);
|
||||
assert_eq!(reply.status(), 200);
|
||||
let bytes = axum::body::to_bytes(reply.into_body(), 4096).await.unwrap();
|
||||
let raw = std::str::from_utf8(&bytes).unwrap();
|
||||
let raw = raw
|
||||
.lines()
|
||||
.find_map(|l| l.strip_prefix("data:"))
|
||||
.unwrap_or(raw);
|
||||
let body: serde_json::Value = serde_json::from_str(raw).unwrap();
|
||||
assert_eq!(body["id"], "controlled");
|
||||
assert_eq!(body["error"]["code"], -32602);
|
||||
assert_eq!(body["error"]["message"], "controlled handler error");
|
||||
assert!(body.get("result").is_none());
|
||||
}
|
||||
assert_eq!(controlled.entered.load(Ordering::SeqCst), 2);
|
||||
assert_eq!(store.get("current"), None);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn dropping_pending_await_before_store_effect_does_not_detach_work() {
|
||||
let store = Arc::new(protocol::LogLevelStore::new());
|
||||
let controlled = Controlled {
|
||||
inner: handler(&store),
|
||||
entered: AtomicUsize::new(0),
|
||||
error: None,
|
||||
pending: true,
|
||||
};
|
||||
let context = request_context().await.unwrap();
|
||||
let mut future = Box::pin(invoke(&controlled, request("alert"), context));
|
||||
assert!(futures_util::poll!(future.as_mut()).is_pending());
|
||||
assert_eq!(controlled.entered.load(Ordering::SeqCst), 1);
|
||||
drop(future);
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(store.get("current"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_command_maps_to_safe_invalid_params_error_data() {
|
||||
let error = SetLevelCommand {
|
||||
level: "not-a-level".to_owned(),
|
||||
}
|
||||
.validate()
|
||||
.unwrap_err();
|
||||
assert_eq!(error, protocol::INVALID_LEVEL);
|
||||
let sdk_error = ErrorData::invalid_params(error, None);
|
||||
assert_eq!(sdk_error.code.0, -32602);
|
||||
assert_eq!(sdk_error.message, protocol::INVALID_LEVEL);
|
||||
}
|
||||
@@ -78,7 +78,7 @@ fn opted(level: Value) -> Value {
|
||||
meta[LEVEL] = level;
|
||||
json!({"_meta":meta})
|
||||
}
|
||||
async fn control(revision: &str) -> [usize; 3] {
|
||||
pub(super) async fn control(revision: &str) -> [usize; 5] {
|
||||
let h = Endpoint::started().await;
|
||||
let session = h.session(revision).await;
|
||||
let session = session.as_deref();
|
||||
@@ -131,6 +131,11 @@ async fn control(revision: &str) -> [usize; 3] {
|
||||
assert_eq!(h.counters.sdk_logging_notification(), 0);
|
||||
}
|
||||
}
|
||||
assert_eq!(
|
||||
handlers(&h.counters),
|
||||
[0, 0],
|
||||
"rejected input must not invoke the handler"
|
||||
);
|
||||
let before = counts(&h.counters);
|
||||
let (method, params, expected) = if revision == LEGACY_REVISION {
|
||||
(
|
||||
@@ -155,7 +160,7 @@ async fn control(revision: &str) -> [usize; 3] {
|
||||
assert_eq!(events, vec![expected]);
|
||||
assert!(raw.len() < 4096);
|
||||
let after = counts(&h.counters);
|
||||
let delta = std::array::from_fn(|i| after[i] - before[i]);
|
||||
let delta: [usize; 3] = std::array::from_fn(|i| after[i] - before[i]);
|
||||
// Legacy severity persists, modern opt-in does not leak into the next request.
|
||||
let (body, events, _) = reply(h.post(revision, session, "tools/list", json!({})).await).await;
|
||||
assert!(body["result"]["tools"].is_array());
|
||||
@@ -169,6 +174,7 @@ async fn control(revision: &str) -> [usize; 3] {
|
||||
.await
|
||||
.unwrap();
|
||||
let before = counts(&h.counters);
|
||||
let before_handlers = handlers(&h.counters);
|
||||
let era = h.counters.snapshot();
|
||||
let response = h
|
||||
.post(
|
||||
@@ -186,13 +192,20 @@ async fn control(revision: &str) -> [usize; 3] {
|
||||
let raw = response.text().await.unwrap();
|
||||
assert!(!raw.contains("notifications/message"));
|
||||
assert_eq!(counts(&h.counters), before);
|
||||
assert_eq!(handlers(&h.counters), before_handlers);
|
||||
let after = h.counters.snapshot();
|
||||
assert_eq!(after.era_modern, era.era_modern);
|
||||
assert_eq!(after.era_legacy, era.era_legacy);
|
||||
eprintln!(
|
||||
"existing GREEN logging HTTP {revision}: safe SSE, result, opt-in/invalid/era/auth controls passed; SDK positive delta={delta:?}"
|
||||
);
|
||||
delta
|
||||
[
|
||||
delta[0],
|
||||
delta[1],
|
||||
delta[2],
|
||||
h.counters.sdk_logging_handler_completed(),
|
||||
h.counters.sdk_logging_handler_consumed(),
|
||||
]
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_logging_wire_legacy() {
|
||||
@@ -206,7 +219,7 @@ async fn rmcp_logging_wire_modern() {
|
||||
async fn rmcp_logging_sdk_legacy() {
|
||||
assert_eq!(
|
||||
control(LEGACY_REVISION).await,
|
||||
[1, 1, 1],
|
||||
[1, 1, 1, 1, 1],
|
||||
"missing SDK legacy request/level/notification after successful HTTP wire assertions"
|
||||
);
|
||||
}
|
||||
@@ -214,7 +227,7 @@ async fn rmcp_logging_sdk_legacy() {
|
||||
async fn rmcp_logging_sdk_modern() {
|
||||
assert_eq!(
|
||||
control(MODERN_REVISION).await,
|
||||
[0, 1, 1],
|
||||
[0, 1, 1, 0, 0],
|
||||
"missing SDK modern level/notification after successful HTTP wire assertions"
|
||||
);
|
||||
}
|
||||
@@ -256,3 +269,140 @@ async fn rmcp_logging_observer_scope_control() {
|
||||
assert_eq!(counts(&a), [1, 1, 1]);
|
||||
assert_eq!(counts(&b), [0, 0, 1]);
|
||||
}
|
||||
|
||||
fn handlers(c: &CounterSet) -> [usize; 2] {
|
||||
[
|
||||
c.sdk_logging_handler_completed(),
|
||||
c.sdk_logging_handler_consumed(),
|
||||
]
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_logging_all_levels_json_sse_and_ignored_extensions() {
|
||||
let h = Endpoint::started().await;
|
||||
let session = h.session(LEGACY_REVISION).await.unwrap();
|
||||
for accept in ["application/json", "text/event-stream, application/json"] {
|
||||
for level in [
|
||||
"debug",
|
||||
"info",
|
||||
"notice",
|
||||
"warning",
|
||||
"error",
|
||||
"critical",
|
||||
"alert",
|
||||
"emergency",
|
||||
] {
|
||||
let before = handlers(&h.counters);
|
||||
let response = h.post_with_accept(LEGACY_REVISION, Some(&session), "logging/setLevel",
|
||||
json!({"level":level,"extension":{"CANARY":"ignored"},"_meta":{"extension":true}}), accept).await;
|
||||
assert_eq!(response.headers()["MCP-Protocol-Version"], LEGACY_REVISION);
|
||||
assert_eq!(
|
||||
response.headers()["x-request-id"],
|
||||
"logging-handler-control"
|
||||
);
|
||||
let (body, events, raw) = reply(response).await;
|
||||
assert_eq!(body["result"], json!({}));
|
||||
assert!(!raw.contains("CANARY"));
|
||||
if accept == "application/json" || !["debug", "info", "notice"].contains(&level) {
|
||||
assert!(events.is_empty());
|
||||
} else {
|
||||
let mut expected = vec![notification(
|
||||
"notice",
|
||||
"mcp.logging.level_applied",
|
||||
"applied",
|
||||
)];
|
||||
if ["debug", "info"].contains(&level) {
|
||||
expected.push(notification("info", "mcp.request.served", "ok"));
|
||||
}
|
||||
assert_eq!(events, expected);
|
||||
}
|
||||
assert_eq!(handlers(&h.counters), before.map(|n| n + 1));
|
||||
}
|
||||
}
|
||||
let before = handlers(&h.counters);
|
||||
let response = h
|
||||
.post(
|
||||
LEGACY_REVISION,
|
||||
Some(&session),
|
||||
"logging/setLevel",
|
||||
json!({"level":"info","_meta":7}),
|
||||
)
|
||||
.await;
|
||||
assert!(response.status().is_client_error());
|
||||
assert!(!response.text().await.unwrap().contains("CANARY"));
|
||||
assert_eq!(handlers(&h.counters), before);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_logging_session_guards_do_not_enter_the_handler() {
|
||||
use crate::session::TransportSessionStore;
|
||||
let h = Endpoint::started().await;
|
||||
let uninitialized = h
|
||||
.sessions
|
||||
.create(
|
||||
LEGACY_REVISION,
|
||||
WORKSPACE_SLUG,
|
||||
AGENT_SLUG,
|
||||
false,
|
||||
time::OffsetDateTime::now_utc(),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let foreign = h
|
||||
.sessions
|
||||
.create(
|
||||
LEGACY_REVISION,
|
||||
WORKSPACE_SLUG,
|
||||
"another-agent",
|
||||
false,
|
||||
time::OffsetDateTime::now_utc(),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
h.sessions
|
||||
.mark_initialized(&foreign, time::OffsetDateTime::now_utc())
|
||||
.await
|
||||
.unwrap();
|
||||
for session in [
|
||||
None,
|
||||
Some("unknown"),
|
||||
Some(uninitialized.as_str()),
|
||||
Some(foreign.as_str()),
|
||||
] {
|
||||
let response = h
|
||||
.post(
|
||||
LEGACY_REVISION,
|
||||
session,
|
||||
"logging/setLevel",
|
||||
json!({"level":"debug"}),
|
||||
)
|
||||
.await;
|
||||
let status = response.status();
|
||||
let raw = response.text().await.unwrap();
|
||||
if session == Some(uninitialized.as_str()) {
|
||||
assert_eq!(status, 200);
|
||||
let body: Value = serde_json::from_str(&raw).unwrap();
|
||||
assert_eq!(body["error"]["code"], -32002);
|
||||
} else {
|
||||
assert_eq!(status.as_u16(), if session.is_none() { 400 } else { 404 });
|
||||
}
|
||||
assert!(!raw.contains("mcp.logging.level_applied"));
|
||||
assert_eq!(handlers(&h.counters), [0, 0]);
|
||||
assert_eq!(h.counters.sdk_logging_dispatch(), 0);
|
||||
}
|
||||
let session = h.session(LEGACY_REVISION).await;
|
||||
let (body, _, _) = reply(
|
||||
h.post(
|
||||
LEGACY_REVISION,
|
||||
session.as_deref(),
|
||||
"logging/setLevel",
|
||||
json!({"level":"notice"}),
|
||||
)
|
||||
.await,
|
||||
)
|
||||
.await;
|
||||
assert_eq!(body["result"], json!({}));
|
||||
assert_eq!(handlers(&h.counters), [1, 1]);
|
||||
}
|
||||
@@ -7,6 +7,7 @@ use crank_runtime::{
|
||||
pub(super) struct Endpoint {
|
||||
pub registry: crank_registry::PostgresRegistry,
|
||||
pub counters: Arc<CounterSet>,
|
||||
pub sessions: Arc<crate::session::InMemorySessionStore>,
|
||||
key: String,
|
||||
url: String,
|
||||
server: tokio::task::JoinHandle<()>,
|
||||
@@ -18,7 +19,7 @@ impl Drop for Endpoint {
|
||||
}
|
||||
impl Endpoint {
|
||||
pub async fn started() -> Self {
|
||||
crank_test_support::postgres_schema_url_for_task("logging_owner", "t_c28c3800").await;
|
||||
crank_test_support::postgres_schema_url_for_task("logging_handler", "t_dbf2bdff").await;
|
||||
let registry = test_registry().await;
|
||||
let operation = test_operation("http://127.0.0.1:9");
|
||||
registry
|
||||
@@ -38,6 +39,7 @@ impl Endpoint {
|
||||
publish_agent(®istry, &operation).await;
|
||||
let key = create_api_key(®istry).await;
|
||||
let counters = Arc::new(CounterSet::default());
|
||||
let sessions = Arc::new(crate::session::InMemorySessionStore::default());
|
||||
let app = crate::build_app(
|
||||
registry.clone(),
|
||||
Duration::ZERO,
|
||||
@@ -49,7 +51,7 @@ impl Endpoint {
|
||||
.build(),
|
||||
RequestRateLimiter::new(RequestRateLimitConfig::new(10_000, 10_000).unwrap()),
|
||||
Arc::new(InMemoryCoordinationStateStore::default()),
|
||||
Arc::new(crate::session::InMemorySessionStore::default()),
|
||||
sessions.clone(),
|
||||
Arc::new(crate::auth::CommunityMachineCredentialVerifier),
|
||||
);
|
||||
let scope = counters.clone();
|
||||
@@ -73,22 +75,41 @@ impl Endpoint {
|
||||
Self {
|
||||
registry,
|
||||
counters,
|
||||
sessions,
|
||||
key,
|
||||
url,
|
||||
server,
|
||||
}
|
||||
}
|
||||
pub async fn post(
|
||||
&self,
|
||||
revision: &str,
|
||||
session: Option<&str>,
|
||||
method: &str,
|
||||
params: Value,
|
||||
) -> reqwest::Response {
|
||||
self.post_with_accept(
|
||||
revision,
|
||||
session,
|
||||
method,
|
||||
params,
|
||||
"text/event-stream, application/json",
|
||||
)
|
||||
.await
|
||||
}
|
||||
pub async fn post_with_accept(
|
||||
&self,
|
||||
revision: &str,
|
||||
session: Option<&str>,
|
||||
method: &str,
|
||||
mut params: Value,
|
||||
accept: &str,
|
||||
) -> reqwest::Response {
|
||||
let mut request = reqwest::Client::new()
|
||||
.post(&self.url)
|
||||
.bearer_auth(&self.key)
|
||||
.header("Accept", "text/event-stream, application/json")
|
||||
.header("Accept", accept)
|
||||
.header("x-request-id", "logging-handler-control")
|
||||
.header("MCP-Protocol-Version", revision);
|
||||
if let Some(session) = session {
|
||||
request = request.header("MCP-Session-Id", session);
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,120 @@
|
||||
//! #107 real HTTP contract for awaited legacy SDK notification handlers.
|
||||
use super::rmcp_progress_cancel_runtime_tests::fixtures::Endpoint;
|
||||
use super::support::*;
|
||||
use serde_json::{Value, json};
|
||||
use std::time::Duration;
|
||||
|
||||
async fn legacy_session(h: &Endpoint) -> String {
|
||||
let response = h
|
||||
.request(
|
||||
LEGACY_REVISION,
|
||||
None,
|
||||
&h.key,
|
||||
"application/json",
|
||||
legacy_initialize(801),
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 200);
|
||||
let session = response.headers()["MCP-Session-Id"]
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.to_owned();
|
||||
let body: Value = json_body(response).await;
|
||||
assert_eq!(body["result"]["protocolVersion"], LEGACY_REVISION);
|
||||
session
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn initialized_handler_executes_and_is_consumed_by_real_http_caller() {
|
||||
crank_test_support::postgres_schema_url_for_task("notification_handler", "t_2a52960d").await;
|
||||
let h = Endpoint::started().await;
|
||||
let session = legacy_session(&h).await;
|
||||
let response = h
|
||||
.request(
|
||||
LEGACY_REVISION,
|
||||
Some(&session),
|
||||
&h.key,
|
||||
"application/json",
|
||||
json!({"jsonrpc":"2.0","method":"notifications/initialized"}),
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 202, "legacy HTTP wire positive control");
|
||||
assert!(response.bytes().await.unwrap().is_empty());
|
||||
assert!(h.sessions.retained(&session).await.unwrap().initialized);
|
||||
assert_eq!(
|
||||
h.counters.sdk_initialized_handler_completed(),
|
||||
1,
|
||||
"real awaited on_initialized must complete its durable operation"
|
||||
);
|
||||
assert_eq!(
|
||||
h.counters.sdk_initialized_handler_consumed(),
|
||||
1,
|
||||
"HTTP caller must consume the outcome of that same SDK handler"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn cancelled_handler_executes_and_is_consumed_for_owned_active_call() {
|
||||
crank_test_support::postgres_schema_url_for_task("notification_handler", "t_2a52960d").await;
|
||||
let h = Endpoint::started().await;
|
||||
let session = h.session(LEGACY_REVISION).await.unwrap();
|
||||
let call = h.call(
|
||||
LEGACY_REVISION,
|
||||
Some(&session),
|
||||
json!(802),
|
||||
Some(json!("cancel")),
|
||||
"text/event-stream",
|
||||
);
|
||||
let active = tokio::spawn(async move { call.send().await.unwrap().text().await.unwrap() });
|
||||
h.wait_started(1).await;
|
||||
h.cancel(&h.key, &session, json!({"requestId":802})).await;
|
||||
tokio::time::timeout(Duration::from_secs(2), active)
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
h.counters.sdk_cancelled_handler_completed(),
|
||||
1,
|
||||
"real awaited on_cancelled must cancel the owned call"
|
||||
);
|
||||
assert_eq!(
|
||||
h.counters.sdk_cancelled_handler_consumed(),
|
||||
1,
|
||||
"HTTP caller must consume the outcome of that same SDK handler"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn modern_notifications_remain_ack_only_without_legacy_handlers() {
|
||||
crank_test_support::postgres_schema_url_for_task("notification_handler", "t_2a52960d").await;
|
||||
let h = Endpoint::started().await;
|
||||
let before = h.sessions.snapshot();
|
||||
let response = h.request(MODERN_REVISION, None, &h.key, "application/json",
|
||||
json!({"jsonrpc":"2.0","method":"notifications/initialized","params":{"_meta":modern_meta()}}))
|
||||
.send().await.unwrap();
|
||||
assert_eq!(response.status(), 202);
|
||||
assert!(response.bytes().await.unwrap().is_empty());
|
||||
let response = h.request(MODERN_REVISION, None, &h.key, "application/json",
|
||||
json!({"jsonrpc":"2.0","method":"notifications/cancelled","params":{"requestId":802,"_meta":modern_meta()}}))
|
||||
.send().await.unwrap();
|
||||
assert_eq!(response.status(), 202);
|
||||
assert!(response.bytes().await.unwrap().is_empty());
|
||||
assert_session_ops(
|
||||
"modern notification ACK",
|
||||
before,
|
||||
h.sessions.snapshot(),
|
||||
SessionOps {
|
||||
get: 0,
|
||||
create: 0,
|
||||
mark_initialized: 0,
|
||||
},
|
||||
);
|
||||
assert_eq!(h.counters.sdk_initialized_handler_completed(), 0);
|
||||
assert_eq!(h.counters.sdk_initialized_handler_consumed(), 0);
|
||||
assert_eq!(h.counters.sdk_cancelled_handler_completed(), 0);
|
||||
assert_eq!(h.counters.sdk_cancelled_handler_consumed(), 0);
|
||||
}
|
||||
@@ -0,0 +1,291 @@
|
||||
//! Direct controls of the production awaited notification boundary.
|
||||
use super::*;
|
||||
use crate::session::{
|
||||
InMemorySessionStore, SessionState, SessionStoreError, TransportSessionStore,
|
||||
};
|
||||
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
|
||||
use time::OffsetDateTime;
|
||||
|
||||
#[derive(Default)]
|
||||
struct Store {
|
||||
inner: InMemorySessionStore,
|
||||
marks: AtomicUsize,
|
||||
reads: AtomicUsize,
|
||||
entered: AtomicBool,
|
||||
dropped: AtomicBool,
|
||||
pending: AtomicBool,
|
||||
fail_get: AtomicBool,
|
||||
gate: tokio::sync::Notify,
|
||||
}
|
||||
struct Witness<'a>(&'a AtomicBool);
|
||||
impl Drop for Witness<'_> {
|
||||
fn drop(&mut self) {
|
||||
self.0.store(true, SeqCst);
|
||||
}
|
||||
}
|
||||
impl Store {
|
||||
async fn wait(&self) {
|
||||
if self.pending.load(SeqCst) {
|
||||
let _witness = Witness(&self.dropped);
|
||||
self.entered.store(true, SeqCst);
|
||||
self.gate.notified().await;
|
||||
}
|
||||
}
|
||||
}
|
||||
#[async_trait::async_trait]
|
||||
impl TransportSessionStore for Store {
|
||||
async fn create(
|
||||
&self,
|
||||
v: &str,
|
||||
w: &str,
|
||||
a: &str,
|
||||
e: bool,
|
||||
n: OffsetDateTime,
|
||||
x: Option<OffsetDateTime>,
|
||||
) -> Result<String, SessionStoreError> {
|
||||
self.inner.create(v, w, a, e, n, x).await
|
||||
}
|
||||
async fn get(&self, id: &str) -> Result<Option<SessionState>, SessionStoreError> {
|
||||
self.wait().await;
|
||||
self.reads.fetch_add(1, SeqCst);
|
||||
if self.fail_get.load(SeqCst) {
|
||||
return Err(SessionStoreError {
|
||||
details: "test read refusal".into(),
|
||||
});
|
||||
}
|
||||
self.inner.get(id).await
|
||||
}
|
||||
async fn mark_initialized(
|
||||
&self,
|
||||
id: &str,
|
||||
n: OffsetDateTime,
|
||||
) -> Result<bool, SessionStoreError> {
|
||||
self.wait().await;
|
||||
self.marks.fetch_add(1, SeqCst);
|
||||
self.inner.mark_initialized(id, n).await
|
||||
}
|
||||
async fn delete(&self, id: &str) -> Result<bool, SessionStoreError> {
|
||||
self.inner.delete(id).await
|
||||
}
|
||||
async fn cleanup_expired(&self, n: OffsetDateTime) -> Result<u64, SessionStoreError> {
|
||||
self.inner.cleanup_expired(n).await
|
||||
}
|
||||
async fn active_count(&self, n: OffsetDateTime) -> Result<u64, SessionStoreError> {
|
||||
self.inner.active_count(n).await
|
||||
}
|
||||
}
|
||||
async fn fixture() -> (Arc<AppState>, Arc<Store>, String) {
|
||||
let mut state = (*super::super::rmcp_tools_tests::test_state().await).clone();
|
||||
let store = Arc::new(Store::default());
|
||||
let id = store
|
||||
.create(
|
||||
"2025-11-25",
|
||||
"w",
|
||||
"a",
|
||||
false,
|
||||
OffsetDateTime::now_utc(),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
state.sessions = store.clone();
|
||||
(Arc::new(state), store, id)
|
||||
}
|
||||
fn initialized_handler(state: Arc<AppState>, id: &str) -> OutcomeHandler {
|
||||
OutcomeHandler {
|
||||
operation: Operation::Initialized {
|
||||
state,
|
||||
session_id: id.to_owned(),
|
||||
},
|
||||
outcome: Mutex::new(None),
|
||||
}
|
||||
}
|
||||
fn cancelled_handler(state: Arc<AppState>, id: &str, raw: Option<Value>) -> OutcomeHandler {
|
||||
OutcomeHandler {
|
||||
operation: Operation::Cancelled {
|
||||
state,
|
||||
path: AgentRoutePath {
|
||||
workspace_slug: "w".into(),
|
||||
agent_slug: "a".into(),
|
||||
},
|
||||
credential: VerifiedMachineCredential {
|
||||
machine_access_mode: crank_core::MachineAccessMode::StaticAgentKey,
|
||||
max_security_level: crank_core::OperationSecurityLevel::Standard,
|
||||
scopes: vec![],
|
||||
platform_api_key_id: None,
|
||||
},
|
||||
session_id: Some(id.to_owned()),
|
||||
request_id: raw,
|
||||
},
|
||||
outcome: Mutex::new(None),
|
||||
}
|
||||
}
|
||||
struct Noop;
|
||||
impl ServerHandler for Noop {}
|
||||
|
||||
#[tokio::test]
|
||||
async fn notification_handler_noop_and_bootstrap_failure_have_no_effect() {
|
||||
let (state, store, id) = fixture().await;
|
||||
let init = initialized_handler(state.clone(), &id);
|
||||
assert_eq!(
|
||||
initialized_with(&Noop, &init, notification_context()).await,
|
||||
StatusCode::INTERNAL_SERVER_ERROR
|
||||
);
|
||||
assert_eq!(
|
||||
initialized_with(&init, &init, async { Err(()) }).await,
|
||||
StatusCode::INTERNAL_SERVER_ERROR
|
||||
);
|
||||
let cancel = cancelled_handler(state.clone(), &id, None);
|
||||
let scope = super::super::lifecycle::InFlightScope {
|
||||
session_id: id.clone(),
|
||||
owner: String::new(),
|
||||
};
|
||||
let entry = state
|
||||
.in_flight
|
||||
.register(&scope, &serde_json::json!(1))
|
||||
.unwrap();
|
||||
let (params, _) = cancelled_params(&serde_json::json!({"requestId":1})).unwrap();
|
||||
cancelled_with(&Noop, &cancel, params.clone(), notification_context()).await;
|
||||
cancelled_with(&cancel, &cancel, params, async { Err(()) }).await;
|
||||
assert!(cancel.take().is_none());
|
||||
assert_eq!(store.marks.load(SeqCst), 0);
|
||||
assert_eq!(store.reads.load(SeqCst), 0);
|
||||
assert!(!store.inner.get(&id).await.unwrap().unwrap().initialized);
|
||||
assert!(futures_util::poll!(Box::pin(entry.cancel_signal().cancelled())).is_pending());
|
||||
// Positive control: exactly one durable operation, and the caller drains its outcome.
|
||||
assert_eq!(
|
||||
initialized_with(&init, &init, notification_context()).await,
|
||||
StatusCode::ACCEPTED
|
||||
);
|
||||
assert_eq!(store.marks.load(SeqCst), 1);
|
||||
assert!(init.take().is_none());
|
||||
assert!(store.inner.get(&id).await.unwrap().unwrap().initialized);
|
||||
}
|
||||
|
||||
struct Mutate(Arc<OutcomeHandler>, NumberOrString);
|
||||
impl ServerHandler for Mutate {
|
||||
async fn on_cancelled(
|
||||
&self,
|
||||
mut p: CancelledNotificationParam,
|
||||
ctx: NotificationContext<RoleServer>,
|
||||
) {
|
||||
assert!(ctx.peer.is_transport_closed());
|
||||
p.request_id = Some(self.1.clone());
|
||||
ServerHandler::on_cancelled(self.0.as_ref(), p, ctx).await;
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn notification_handler_typed_target_mutation_and_raw_number_separation() {
|
||||
let (state, store, id) = fixture().await;
|
||||
let scope = super::super::lifecycle::InFlightScope {
|
||||
session_id: id.clone(),
|
||||
owner: String::new(),
|
||||
};
|
||||
for raw in [
|
||||
serde_json::json!(18446744073709551615_u64),
|
||||
serde_json::json!(1.25),
|
||||
] {
|
||||
let numeric = state.in_flight.register(&scope, &raw).unwrap();
|
||||
let text = state
|
||||
.in_flight
|
||||
.register(&scope, &Value::String(raw.to_string()))
|
||||
.unwrap();
|
||||
let changed = state
|
||||
.in_flight
|
||||
.register(&scope, &serde_json::json!(42))
|
||||
.unwrap();
|
||||
let (params, original) = cancelled_params(&serde_json::json!({"requestId":raw})).unwrap();
|
||||
let h = Arc::new(cancelled_handler(state.clone(), &id, original));
|
||||
let mutation = Mutate(h.clone(), NumberOrString::Number(42));
|
||||
cancelled_with(
|
||||
&mutation,
|
||||
h.as_ref(),
|
||||
params.clone(),
|
||||
notification_context(),
|
||||
)
|
||||
.await;
|
||||
assert!(futures_util::poll!(Box::pin(changed.cancel_signal().cancelled())).is_ready());
|
||||
assert!(futures_util::poll!(Box::pin(numeric.cancel_signal().cancelled())).is_pending());
|
||||
assert!(futures_util::poll!(Box::pin(text.cancel_signal().cancelled())).is_pending());
|
||||
assert!(h.take().is_none());
|
||||
cancelled_with(h.as_ref(), h.as_ref(), params, notification_context()).await;
|
||||
assert!(futures_util::poll!(Box::pin(numeric.cancel_signal().cancelled())).is_ready());
|
||||
assert!(futures_util::poll!(Box::pin(text.cancel_signal().cancelled())).is_pending());
|
||||
}
|
||||
assert_eq!(
|
||||
store.reads.load(SeqCst),
|
||||
4,
|
||||
"one lookup per real callback, no bootstrap effects"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn notification_handler_store_read_refusal_does_not_cancel() {
|
||||
let (state, store, id) = fixture().await;
|
||||
let scope = super::super::lifecycle::InFlightScope {
|
||||
session_id: id.clone(),
|
||||
owner: String::new(),
|
||||
};
|
||||
let entry = state
|
||||
.in_flight
|
||||
.register(&scope, &serde_json::json!(7))
|
||||
.unwrap();
|
||||
let (params, _) = cancelled_params(&serde_json::json!({"requestId":7})).unwrap();
|
||||
let h = cancelled_handler(state, &id, None);
|
||||
store.fail_get.store(true, SeqCst);
|
||||
ServerHandler::on_cancelled(&h, params, notification_context().await.unwrap()).await;
|
||||
assert_eq!(h.take(), Some(StatusCode::ACCEPTED));
|
||||
assert_eq!(store.reads.load(SeqCst), 1);
|
||||
assert!(futures_util::poll!(Box::pin(entry.cancel_signal().cancelled())).is_pending());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn notification_handler_pending_store_drop_stops_initialized_and_cancelled() {
|
||||
let (state, store, id) = fixture().await;
|
||||
for cancel in [false, true] {
|
||||
store.pending.store(true, SeqCst);
|
||||
store.entered.store(false, SeqCst);
|
||||
store.dropped.store(false, SeqCst);
|
||||
let h = if cancel {
|
||||
cancelled_handler(state.clone(), &id, None)
|
||||
} else {
|
||||
initialized_handler(state.clone(), &id)
|
||||
};
|
||||
let scope = super::super::lifecycle::InFlightScope {
|
||||
session_id: id.clone(),
|
||||
owner: String::new(),
|
||||
};
|
||||
let entry = state
|
||||
.in_flight
|
||||
.register(&scope, &serde_json::json!(7))
|
||||
.unwrap();
|
||||
let (params, _) = cancelled_params(&serde_json::json!({"requestId":7})).unwrap();
|
||||
let mut future = Box::pin(async {
|
||||
if cancel {
|
||||
cancelled_with(&h, &h, params, notification_context()).await;
|
||||
} else {
|
||||
initialized_with(&h, &h, notification_context()).await;
|
||||
}
|
||||
});
|
||||
tokio::time::timeout(std::time::Duration::from_secs(2), async {
|
||||
tokio::select! {
|
||||
_ = &mut future => panic!("pending operation completed"),
|
||||
_ = async { while !store.entered.load(SeqCst) { tokio::task::yield_now().await; } } => {}
|
||||
}
|
||||
}).await.unwrap();
|
||||
assert!(!store.dropped.load(SeqCst));
|
||||
drop(future);
|
||||
assert!(
|
||||
store.dropped.load(SeqCst),
|
||||
"the actual store future belongs to this await"
|
||||
);
|
||||
store.gate.notify_waiters();
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(store.marks.load(SeqCst), 0);
|
||||
assert_eq!(store.reads.load(SeqCst), 0);
|
||||
assert!(h.take().is_none());
|
||||
assert!(!store.inner.get(&id).await.unwrap().unwrap().initialized);
|
||||
assert!(futures_util::poll!(Box::pin(entry.cancel_signal().cancelled())).is_pending());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,238 @@
|
||||
//! #107 ping: existing wire GREEN is independent from the SDK execution oracle.
|
||||
use super::rmcp_progress_cancel_runtime_tests::fixtures::Endpoint;
|
||||
use super::{CounterSet, Snapshot, observe, support::*};
|
||||
use serde_json::{Value, json};
|
||||
use std::{sync::Arc, time::Duration};
|
||||
|
||||
async fn endpoint() -> Endpoint {
|
||||
crank_test_support::postgres_schema_url_for_task("ping_owner", "t_83746dc7").await;
|
||||
Endpoint::started().await
|
||||
}
|
||||
|
||||
fn ping(revision: &str, extended: bool) -> Value {
|
||||
let mut payload = json!({"jsonrpc":"2.0","id":"ping/Ю","method":"ping"});
|
||||
if revision == MODERN_REVISION || extended {
|
||||
payload["params"] = json!({"_meta":if revision == MODERN_REVISION {
|
||||
modern_meta()
|
||||
} else { json!({}) }});
|
||||
}
|
||||
if extended {
|
||||
payload["params"]["ignored"] = json!([null, {"future":true}]);
|
||||
payload["params"]["_meta"]["future"] = json!(42);
|
||||
payload["extension"] = json!({"nested":[false]});
|
||||
}
|
||||
payload
|
||||
}
|
||||
|
||||
async fn wire_body(response: reqwest::Response, sse: bool) -> Value {
|
||||
assert_eq!(response.headers()["x-request-id"], "ping-atdd");
|
||||
assert_eq!(
|
||||
response.headers()["x-trace-id"],
|
||||
"11111111111111111111111111111111"
|
||||
);
|
||||
assert!(
|
||||
response.headers()["content-type"]
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.starts_with(if sse {
|
||||
"text/event-stream"
|
||||
} else {
|
||||
"application/json"
|
||||
})
|
||||
);
|
||||
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, "one terminal frame: {raw}");
|
||||
frames.into_iter().next().unwrap()
|
||||
} else {
|
||||
serde_json::from_str(&raw).unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
fn correlated(request: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
|
||||
request.header("x-request-id", "ping-atdd").header(
|
||||
"traceparent",
|
||||
"00-11111111111111111111111111111111-2222222222222222-01",
|
||||
)
|
||||
}
|
||||
|
||||
async fn success_control(revision: &str) -> Vec<(usize, usize)> {
|
||||
let h = endpoint().await;
|
||||
// The existing fixture performs real initialize -> initialized for legacy only.
|
||||
let session = h.session(revision).await;
|
||||
let mut sdk = vec![];
|
||||
for (accept, extended) in [
|
||||
("application/json", false),
|
||||
("text/event-stream, application/json", true),
|
||||
] {
|
||||
let counters = h.counters.snapshot();
|
||||
let ops = h.sessions.snapshot();
|
||||
let before = (
|
||||
h.counters.sdk_ping_handler_completed(),
|
||||
h.counters.sdk_ping_handler_consumed(),
|
||||
);
|
||||
let response = correlated(h.request(
|
||||
revision,
|
||||
session.as_deref(),
|
||||
&h.key,
|
||||
accept,
|
||||
ping(revision, extended),
|
||||
))
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 200);
|
||||
assert_eq!(response.headers()["MCP-Protocol-Version"], revision);
|
||||
assert!(response.headers().get("MCP-Session-Id").is_none());
|
||||
let wire = wire_body(response, accept.starts_with("text/event-stream")).await;
|
||||
let result = if revision == MODERN_REVISION {
|
||||
json!({"protocolVersion":revision,"resultType":"complete"})
|
||||
} else {
|
||||
json!({"protocolVersion":revision})
|
||||
};
|
||||
assert_eq!(wire, json!({"jsonrpc":"2.0","id":"ping/Ю","result":result}));
|
||||
assert_deltas(
|
||||
"ping",
|
||||
counters,
|
||||
h.counters.snapshot(),
|
||||
Snapshot::new(
|
||||
1,
|
||||
usize::from(revision == MODERN_REVISION),
|
||||
usize::from(revision == LEGACY_REVISION),
|
||||
0,
|
||||
),
|
||||
);
|
||||
assert_session_ops(
|
||||
"ping",
|
||||
ops,
|
||||
h.sessions.snapshot(),
|
||||
SessionOps {
|
||||
get: 2 * usize::from(revision == LEGACY_REVISION),
|
||||
create: 0,
|
||||
mark_initialized: 0,
|
||||
},
|
||||
);
|
||||
sdk.push((
|
||||
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={:?}",
|
||||
sdk.last().unwrap()
|
||||
);
|
||||
}
|
||||
sdk
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn ping_wire_json_sse_tolerance_and_session_contract() {
|
||||
success_control(LEGACY_REVISION).await;
|
||||
success_control(MODERN_REVISION).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn ping_sdk_legacy_request_and_result() {
|
||||
assert_eq!(
|
||||
success_control(LEGACY_REVISION).await,
|
||||
vec![(1, 1); 2],
|
||||
"successful legacy HTTP ping must consume SDK request and serialize SDK result"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn ping_sdk_modern_request_and_result() {
|
||||
assert_eq!(
|
||||
success_control(MODERN_REVISION).await,
|
||||
vec![(1, 1); 2],
|
||||
"successful stateless HTTP ping must consume SDK request and serialize SDK result"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn ping_guards_never_enter_sdk() {
|
||||
let h = endpoint().await;
|
||||
for revision in [LEGACY_REVISION, MODERN_REVISION] {
|
||||
let mut payload = ping(revision, true);
|
||||
if revision == MODERN_REVISION {
|
||||
payload["params"]["_meta"] = Value::Null;
|
||||
}
|
||||
let response = correlated(h.request(revision, None, &h.key, "application/json", payload))
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 400);
|
||||
if revision == LEGACY_REVISION {
|
||||
assert!(response.headers().get("content-type").is_none());
|
||||
assert!(response.bytes().await.unwrap().is_empty());
|
||||
} else {
|
||||
let wire = wire_body(response, false).await;
|
||||
assert_eq!(wire["id"], "ping/Ю");
|
||||
assert_eq!(wire["error"]["code"], -32020);
|
||||
assert!(wire.get("result").is_none());
|
||||
}
|
||||
assert_eq!(
|
||||
(
|
||||
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)");
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn ping_observer_positive_control() {
|
||||
let c = Arc::new(CounterSet::default());
|
||||
observe(c.clone(), async {
|
||||
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_handler_completed();
|
||||
super::sdk_ping_handler_consumed();
|
||||
observe(Arc::new(CounterSet::default()), async {
|
||||
super::sdk_ping_handler_completed();
|
||||
super::sdk_ping_handler_consumed();
|
||||
})
|
||||
.await;
|
||||
assert_eq!(
|
||||
(
|
||||
c.sdk_ping_handler_completed(),
|
||||
c.sdk_ping_handler_consumed()
|
||||
),
|
||||
(1, 1),
|
||||
"scope isolation and out-of-scope no-op"
|
||||
);
|
||||
assert_eq!(c.snapshot(), Snapshot::new(0, 0, 0, 0));
|
||||
}
|
||||
@@ -26,6 +26,9 @@ impl Drop for Endpoint {
|
||||
}
|
||||
impl Endpoint {
|
||||
pub async fn started() -> Self {
|
||||
Self::started_with_store(None).await
|
||||
}
|
||||
pub async fn started_with_store(store: Option<crate::session::SharedSessionStore>) -> Self {
|
||||
crank_test_support::postgres_schema_url_for_task("progress_owner", "t_d65dd129").await;
|
||||
let registry = test_registry().await;
|
||||
let gate = Arc::new(Semaphore::new(0));
|
||||
@@ -103,7 +106,7 @@ impl Endpoint {
|
||||
.build(),
|
||||
RequestRateLimiter::new(RequestRateLimitConfig::new(10_000, 10_000).unwrap()),
|
||||
Arc::new(InMemoryCoordinationStateStore::default()),
|
||||
sessions.clone(),
|
||||
store.unwrap_or_else(|| sessions.clone()),
|
||||
Arc::new(crate::auth::CommunityMachineCredentialVerifier),
|
||||
);
|
||||
let scope = counters.clone();
|
||||
|
||||
@@ -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());
|
||||
|
||||
@@ -1,12 +1,10 @@
|
||||
//! #107: HTTP wire controls are independent of the SDK execution oracle.
|
||||
//! A real committed Tool removal exercises the watcher; existing mcp_signals::scenarios covers
|
||||
//! Resource/Prompt publications, isolation, coalescing, reconnect and authoritative recovery.
|
||||
use super::signals_test_support::{self as fixtures, Endpoint, terminal};
|
||||
use super::{CounterSet, support::*};
|
||||
use serde_json::{Value, json};
|
||||
use std::{sync::Arc, time::Duration};
|
||||
#[path = "rmcp_signals_test_support.rs"]
|
||||
mod fixtures;
|
||||
use fixtures::{Endpoint, terminal};
|
||||
use std::time::Duration;
|
||||
|
||||
const SUB_ID: &str = "io.modelcontextprotocol/subscriptionId";
|
||||
const ACK: &str = "notifications/subscriptions/acknowledged";
|
||||
|
||||
@@ -1,10 +1,12 @@
|
||||
//! Small real catalog fixture; broader Resource/Prompt mutations stay in mcp_signals::scenarios.
|
||||
use super::*;
|
||||
use super::{CounterSet, support::*};
|
||||
use crank_core::{AgentStatus, AgentVersion, ToolSelectionPolicy};
|
||||
use crank_registry::{CreateAgentDraftVersionRequest, PublishAgentRequest, PublishRequest};
|
||||
use crank_runtime::{
|
||||
InMemoryCoordinationStateStore, RequestRateLimitConfig, RequestRateLimiter, SecretCrypto,
|
||||
};
|
||||
use serde_json::{Value, json};
|
||||
use std::{sync::Arc, time::Duration};
|
||||
|
||||
pub(super) struct Endpoint {
|
||||
pub registry: crank_registry::PostgresRegistry,
|
||||
@@ -21,7 +23,7 @@ impl Drop for Endpoint {
|
||||
impl Endpoint {
|
||||
pub async fn started() -> Self {
|
||||
// First caller labels the shared, exit-cleaned disposable PostgreSQL with this owner.
|
||||
crank_test_support::postgres_schema_url_for_task("signals_owner", "t_7d5f77a6").await;
|
||||
crank_test_support::postgres_schema_url_for_task("signals_owner", "t_35c2ce53").await;
|
||||
let registry = test_registry().await;
|
||||
// This fixture only lists/removes a Tool; no upstream execution is needed.
|
||||
let operation = test_operation("http://127.0.0.1:9");
|
||||
|
||||
@@ -0,0 +1,90 @@
|
||||
//! #107 subscription handler acceptance: real HTTP wire first, then SDK runtime oracle.
|
||||
use super::CounterSet;
|
||||
use serde_json::{Value, json};
|
||||
use std::time::Duration;
|
||||
|
||||
use super::signals_test_support::Endpoint;
|
||||
|
||||
const SUB_ID: &str = "io.modelcontextprotocol/subscriptionId";
|
||||
const ACK: &str = "notifications/subscriptions/acknowledged";
|
||||
const TOOLS: &str = "notifications/tools/list_changed";
|
||||
|
||||
fn snapshot(c: &CounterSet) -> [usize; 5] {
|
||||
[
|
||||
c.sdk_subscription_listen_entered(),
|
||||
c.sdk_subscription_handler_completed(),
|
||||
c.sdk_subscription_handler_consumed(),
|
||||
c.sdk_subscription_notification_consumed(),
|
||||
c.sdk_subscription_owner_completed(),
|
||||
]
|
||||
}
|
||||
|
||||
async fn http_control(id: Value) -> ([usize; 5], [usize; 3]) {
|
||||
let h = Endpoint::started().await;
|
||||
let started = snapshot(&h.counters);
|
||||
let sdk_wire_before = [
|
||||
h.counters.sdk_subscriptions_listen(),
|
||||
h.counters.sdk_subscriptions_acknowledged(),
|
||||
h.counters.sdk_signal_notification(),
|
||||
];
|
||||
let mut stream = h.listen(id.clone(), json!({"toolsListChanged":true})).await;
|
||||
let first = stream.frame().await;
|
||||
assert_eq!(first["method"], ACK, "HTTP SSE ACK must be first");
|
||||
assert_eq!(first["params"]["_meta"][SUB_ID], id, "exact JSON ACK id");
|
||||
assert_eq!(first["params"]["_meta"][SUB_ID].to_string(), id.to_string());
|
||||
assert_eq!(
|
||||
first["params"]["notifications"],
|
||||
json!({"toolsListChanged":true})
|
||||
);
|
||||
stream.silent().await;
|
||||
|
||||
h.draft_without_tools().await;
|
||||
h.publish_without_tools().await;
|
||||
let notification = stream.frame().await;
|
||||
assert_eq!(notification["method"], TOOLS);
|
||||
assert_eq!(
|
||||
notification["params"]["_meta"][SUB_ID], id,
|
||||
"exact JSON notification id"
|
||||
);
|
||||
assert_eq!(
|
||||
notification["params"]["_meta"][SUB_ID].to_string(),
|
||||
id.to_string()
|
||||
);
|
||||
stream.silent().await;
|
||||
|
||||
let wire = [
|
||||
h.counters.sdk_subscriptions_listen() - sdk_wire_before[0],
|
||||
h.counters.sdk_subscriptions_acknowledged() - sdk_wire_before[1],
|
||||
h.counters.sdk_signal_notification() - sdk_wire_before[2],
|
||||
];
|
||||
drop(stream);
|
||||
tokio::time::timeout(Duration::from_secs(3), async {
|
||||
while h.counters.sdk_subscription_owner_completed() == started[4] {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.expect("HTTP close must join SDK owner/pump");
|
||||
let runtime = std::array::from_fn(|i| snapshot(&h.counters)[i] - started[i]);
|
||||
(runtime, wire)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn modern_http_wire_control_and_sdk_handler_runtime() {
|
||||
for id in [
|
||||
json!(u64::MAX),
|
||||
serde_json::from_str("0.12345678901234567890123456789").unwrap(),
|
||||
] {
|
||||
let (runtime, wire) = http_control(id).await;
|
||||
assert_eq!(
|
||||
wire,
|
||||
[1, 1, 1],
|
||||
"SDK decode/ACK/notification consumed through HTTP"
|
||||
);
|
||||
assert_eq!(
|
||||
runtime,
|
||||
[1, 0, 0, 1, 1],
|
||||
"cancelled listen must not be reported as completed; owner/pump must finish"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,260 @@
|
||||
use super::*;
|
||||
use crate::app::dispatch_observer::{self as observer, CounterSet};
|
||||
use serde_json::json;
|
||||
use std::time::Duration;
|
||||
|
||||
fn meta() -> RequestMetaObject {
|
||||
project_meta(&json!({"params":{"_meta":{
|
||||
"io.modelcontextprotocol/protocolVersion":"2026-07-28",
|
||||
"io.modelcontextprotocol/clientCapabilities":{},
|
||||
}}}))
|
||||
}
|
||||
fn filter(value: Value) -> SubscriptionFilter {
|
||||
serde_json::from_value(value).unwrap()
|
||||
}
|
||||
async fn finished(c: &CounterSet) {
|
||||
tokio::time::timeout(Duration::from_secs(2), async {
|
||||
while c.sdk_subscription_owner_completed() != 1 {
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.expect("owner must join SDK bridge");
|
||||
}
|
||||
|
||||
struct Controlled {
|
||||
fail: bool,
|
||||
tools: bool,
|
||||
calls: Arc<std::sync::atomic::AtomicUsize>,
|
||||
}
|
||||
impl ServerHandler for Controlled {
|
||||
fn get_info(&self) -> ServerConfig {
|
||||
let mut info = ServerConfig::default();
|
||||
info.capabilities = serde_json::from_value(
|
||||
json!({"tools":{"listChanged":self.tools}, "resources":{"listChanged":true}}),
|
||||
)
|
||||
.unwrap();
|
||||
info
|
||||
}
|
||||
fn accepted_subscription_filter(&self, _: &SubscriptionFilter) -> Option<SubscriptionFilter> {
|
||||
Some(filter(
|
||||
json!({"toolsListChanged":true, "resourcesListChanged":true, "promptsListChanged":true}),
|
||||
))
|
||||
}
|
||||
async fn listen(&self, context: SubscriptionContext) -> Result<(), ErrorData> {
|
||||
self.calls.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
||||
assert!(context.sink().notify_prompt_list_changed().await.is_err());
|
||||
if self.fail {
|
||||
return Err(ErrorData::internal_error("controlled refusal", None));
|
||||
}
|
||||
if self.tools {
|
||||
context.sink().notify_tool_list_changed().await.unwrap();
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn actual_owner_consumes_typed_success_error_and_capability_subset_without_final_wire() {
|
||||
for (fail, tools) in [(false, true), (false, false), (true, false)] {
|
||||
let c = Arc::new(CounterSet::default());
|
||||
observer::observe(c.clone(), async {
|
||||
let calls = Arc::new(std::sync::atomic::AtomicUsize::new(0));
|
||||
let handler = Controlled {
|
||||
fail,
|
||||
tools,
|
||||
calls: calls.clone(),
|
||||
};
|
||||
let (sender, mut receiver) = mpsc::channel(4);
|
||||
let operation = own(
|
||||
handler,
|
||||
filter(json!({"toolsListChanged":true,"promptsListChanged":true})),
|
||||
meta(),
|
||||
json!(1.25),
|
||||
sender,
|
||||
);
|
||||
let task = tokio::spawn(observer::observe(c.clone(), operation));
|
||||
let ack: Value = serde_json::from_str(&receiver.recv().await.unwrap()).unwrap();
|
||||
assert_eq!(
|
||||
ack["params"]["notifications"],
|
||||
if tools {
|
||||
json!({"toolsListChanged":true})
|
||||
} else {
|
||||
json!({})
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
ack["params"]["_meta"][signals::SUBSCRIPTION_ID_KEY],
|
||||
json!(1.25)
|
||||
);
|
||||
let result = tokio::time::timeout(Duration::from_secs(2), task)
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert_eq!(calls.load(std::sync::atomic::Ordering::SeqCst), 1);
|
||||
assert_eq!(c.sdk_subscription_handler_consumed(), 1);
|
||||
assert_eq!(c.sdk_subscription_owner_completed(), 1);
|
||||
if fail {
|
||||
assert_eq!(result.unwrap_err().message, "controlled refusal");
|
||||
} else {
|
||||
result.unwrap();
|
||||
}
|
||||
if tools {
|
||||
let value: Value = serde_json::from_str(&receiver.recv().await.unwrap()).unwrap();
|
||||
assert_eq!(value["method"], "notifications/tools/list_changed");
|
||||
}
|
||||
assert!(
|
||||
receiver.recv().await.is_none(),
|
||||
"no result/error/second ACK on wire"
|
||||
);
|
||||
})
|
||||
.await;
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unpolled_body_and_pre_ack_drop_join_owner_and_release_permit() {
|
||||
for before_ack in [true, false] {
|
||||
let c = Arc::new(CounterSet::default());
|
||||
observer::observe(c.clone(), async {
|
||||
struct Pending;
|
||||
impl ServerHandler for Pending {
|
||||
fn accepted_subscription_filter(
|
||||
&self,
|
||||
_: &SubscriptionFilter,
|
||||
) -> Option<SubscriptionFilter> {
|
||||
Some(SubscriptionFilter::new())
|
||||
}
|
||||
async fn listen(&self, context: SubscriptionContext) -> Result<(), ErrorData> {
|
||||
context.cancelled().await;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
if before_ack {
|
||||
{
|
||||
let future =
|
||||
start_with(Pending, SubscriptionFilter::new(), meta(), json!("cancel"));
|
||||
tokio::pin!(future);
|
||||
assert!(futures_util::poll!(&mut future).is_pending());
|
||||
}
|
||||
} else {
|
||||
let (ack, receiver) =
|
||||
start_with(Pending, SubscriptionFilter::new(), meta(), json!("body"))
|
||||
.await
|
||||
.unwrap();
|
||||
let semaphore = Arc::new(tokio::sync::Semaphore::new(1));
|
||||
let guard = semaphore.clone().try_acquire_owned().unwrap();
|
||||
let body = signals::frames_stream(vec![ack], receiver, guard);
|
||||
drop(body);
|
||||
assert_eq!(semaphore.available_permits(), 1);
|
||||
}
|
||||
finished(&c).await;
|
||||
assert_eq!(c.sdk_subscription_owner_completed(), 1);
|
||||
})
|
||||
.await;
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn gone_catalog_finishes_real_listener_and_pre_ack_rejection_is_not_success() {
|
||||
let c = Arc::new(CounterSet::default());
|
||||
observer::observe(c.clone(), async {
|
||||
let read: Reader = Box::new(|| panic!("Gone baseline must never read again"));
|
||||
let handler = Listener {
|
||||
capabilities: ServerCapabilities::default(),
|
||||
watch: Mutex::new(Some((
|
||||
Watch {
|
||||
workspace_slug: "w".into(),
|
||||
agent_slug: "a".into(),
|
||||
signals: signals::Signals::ALL,
|
||||
wire: signals::Wire::Legacy,
|
||||
legacy_stream: None,
|
||||
deadline: None,
|
||||
},
|
||||
read,
|
||||
Err(ReadError::Gone),
|
||||
))),
|
||||
};
|
||||
let (_, mut receiver) =
|
||||
start_with(handler, SubscriptionFilter::new(), meta(), json!("gone"))
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(receiver.recv().await.is_none(), "no final frame");
|
||||
finished(&c).await;
|
||||
assert_eq!(c.sdk_subscription_handler_completed(), 1);
|
||||
assert_eq!(c.sdk_subscription_handler_consumed(), 1);
|
||||
})
|
||||
.await;
|
||||
struct Refused;
|
||||
impl ServerHandler for Refused {}
|
||||
let result = start_with(Refused, SubscriptionFilter::new(), meta(), json!("refused")).await;
|
||||
assert!(
|
||||
result.is_err(),
|
||||
"SDK refusal before ACK must not create a successful stream"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pending_catalog_read_is_dropped_and_sdk_tasks_join_on_body_close() {
|
||||
let c = Arc::new(CounterSet::default());
|
||||
observer::observe(c.clone(), async {
|
||||
let entered = Arc::new(tokio::sync::Notify::new());
|
||||
let dropped = Arc::new(std::sync::atomic::AtomicUsize::new(0));
|
||||
struct DropRead(Arc<std::sync::atomic::AtomicUsize>);
|
||||
impl Drop for DropRead {
|
||||
fn drop(&mut self) {
|
||||
self.0.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
||||
}
|
||||
}
|
||||
let e = entered.clone();
|
||||
let d = dropped.clone();
|
||||
let read: Reader = Box::new(move || {
|
||||
let e = e.clone();
|
||||
let d = d.clone();
|
||||
Box::pin(async move {
|
||||
let _guard = DropRead(d);
|
||||
e.notify_one();
|
||||
std::future::pending().await
|
||||
})
|
||||
});
|
||||
let handler = Listener {
|
||||
capabilities: ServerCapabilities::default(),
|
||||
watch: Mutex::new(Some((
|
||||
Watch {
|
||||
workspace_slug: "w".into(),
|
||||
agent_slug: "a".into(),
|
||||
signals: signals::Signals::ALL,
|
||||
wire: signals::Wire::Legacy,
|
||||
legacy_stream: None,
|
||||
deadline: None,
|
||||
},
|
||||
read,
|
||||
Ok(CatalogFingerprint::default()),
|
||||
))),
|
||||
};
|
||||
assert_eq!(
|
||||
ServerHandler::supported_protocol_versions(&handler)
|
||||
.iter()
|
||||
.map(|v| v.as_str())
|
||||
.collect::<Vec<_>>(),
|
||||
crate::jsonrpc::SUPPORTED_PROTOCOL_VERSIONS
|
||||
);
|
||||
let (_, receiver) = start_with(
|
||||
handler,
|
||||
SubscriptionFilter::new(),
|
||||
meta(),
|
||||
json!("pending-read"),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
tokio::time::timeout(Duration::from_secs(2), entered.notified())
|
||||
.await
|
||||
.unwrap();
|
||||
drop(receiver);
|
||||
finished(&c).await;
|
||||
assert_eq!(dropped.load(std::sync::atomic::Ordering::SeqCst), 1);
|
||||
assert_eq!(c.sdk_subscription_handler_completed(), 0);
|
||||
assert_eq!(c.sdk_subscription_handler_consumed(), 0);
|
||||
})
|
||||
.await;
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -41,14 +41,36 @@ Completion-срез #107 на базе rc.20/rmcp3.9.0 подключает `com
|
||||
|
||||
Logging-срез #107 на базе rc.22/rmcp3.9.0 использует существующий общий `protocol/logging.rs`, уже подключённый к штатному `build_app` HTTP: legacy `logging/setLevel` после прежней bounded string boundary декодируется в настоящий `SetLevelRequestParams`, а modern `_meta[io.modelcontextprotocol/logLevel]` — в SDK `LoggingLevel`. Неизвестные legacy поля, включая `_meta`, остаются игнорируемыми; неверные уровни дают прежний безопасный `INVALID_LEVEL`, modern отсутствие/неверное значение не включает logging. Domain severity ordering/store сохраняются явно: SDK enum не задаёт Ord. `notifications/message.params` сериализуется через `LoggingMessageNotificationParam` только из закрытого safe vocabulary; JSON-RPC envelope остаётся прежним. HTTP ATDD наблюдает реальные SDK decode/serialization обеих revisions и revoked-auth rejection; существующая logging-матрица и streamed progress regression сохраняют opt-in/isolation/filtering/JSON silence и carried scope. Очереди, try_lock/drop, transport/session/auth/lifecycle/capabilities не меняются; собственного runtime parsing уровня и handwritten params builder больше нет. Потребитель — действующий MCP HTTP клиент; signals/progress/cancel/subscriptions/прочие notifications и envelopes/transport/lifecycle ещё не объявляются перенесёнными. Полный #107, feature qualification и production deployment этим срезом не завершены.
|
||||
|
||||
Logging-handler-срез #107 поверх rc.38/rmcp3.9.0 подключает legacy `LoggingSetLevel` в `app/legacy_dispatch.rs` к прямому request-owned await `ServerHandler::set_level` в `app/rmcp_logging.rs`. Override применяет именно typed level к прежнему session store, активирует request-local level и записывает safe event; actual Result/ErrorData определяет JSON/SSE ответ. Bounded command validation остаётся до инертного bootstrap, bootstrap закрыт до рабочего handler. DTO-only execution оставлен только для старых protocol unit tests. HTTP completion/consumption, восемь levels, ignored extensions/admission, session/revocation guards и modern rejection дополняются direct typed mutation/error/single-execution/pending-drop controls; logging matrix и streamed carried scope сохраняются. try_lock skip по-прежнему не подтверждается readback и не превращается в blocking write; drop до эффекта не обещает rollback выполненного store.set. SDK Peer callbacks/transport/SessionManager не подключены; #107 остаётся partial, full/load/external-client qualification и production не входят в срез.
|
||||
|
||||
Progress/cancel-срез #107 на базе rc.23/rmcp3.9.0 подключает штатный SSE `lifecycle::progress_frame` обеих revisions к сериализации `ProgressNotificationParam`, а legacy `handle_cancelled_notification` — к декодированию `CancelledNotificationParam.request_id`. Локальная projection+restore сохраняет исходные JSON numbers токена/ID и целочисленный u64 progress, включая значения вне i64/exact-f64; message и omissions берутся из SDK. Decoder передаёт SDK только requestId, не валидируя reason/_meta/extensions. Session+credential ownership, bounded queues/slots, transport, auth и modern stream-close cancellation не меняются. Runtime ATDD подтверждает SDK seams отдельно от wire; unit regression проверяет точную числовую форму. Decoder ignore действует только после HTTP admission: `_meta:[]` сохраняет прежний HTTP400/-32020 до SDK decoder. Отдельная HTTP-регрессия проверяет отказ без отмены активного вызова, а допустимый `_meta:{}` с reason/extensions — успешную SDK-отмену. Это частичная миграция params, не завершение #107, feature qualification или production deployment.
|
||||
|
||||
Catalog-change signals/subscriptions-срез #107 на базе rc.24/rmcp3.9.0 использует прежний `protocol/signals.rs` watcher: штатный modern `subscriptions/listen` декодирует notifications через `SubscriptionsListenRequestParams`/`SubscriptionFilter`, а acknowledgment и три list-change notification сериализуются настоящими SDK notification types в `protocol/signals_sdk.rs`. Тонкая входная projection сохраняет прежний запрет explicit null известных filter fields и игнорирование extensions; `_meta` по-прежнему проверяется только HTTP admission до decoder. SDK `NotificationMetaObject` хранит исходный JSON subscriptionId без сужения через RequestId; legacy frames остаются без params, modern ack первым сообщает только true accepted subset. URI-content subscriptions остаются unsupported, bounds32/2048 и64-byte id bound сохранены. Ближайший потребитель уже подключён: действующий `build_app` modern listen SSE и legacy GET SSE после committed catalog changes. HTTP ATDD независимо проверяет SDK execution и wire обеих revisions; прежние signals integration сохраняют Resource/Prompt/Tool delivery, scope, coalescing/recovery. Handwritten filter field DTO и frame builders заменены; fingerprint, watcher timing/queue/drop, auth/session/ownership/TTL/capabilities и transport не меняются. Полный #107, external-client/feature qualification и production deployment этим срезом не завершены.
|
||||
|
||||
Subscriptions-handler-срез #107 поверх rc.39/rmcp3.9.0 подключает modern `app/dispatch.rs::SubscriptionsListen` к единственному request-owned default `Service::handle_request` в `app/rmcp_subscriptions.rs`. Живой локальный SDK Peer обслуживает только outbound notifications: actual SDK ACK и последовательные `SubscriptionSink` list-change notifications поступают через `app/rmcp_subscriptions_output.rs` в прежнюю очередь4 и SSE consumer. Registry capabilities и SDK requested/candidate/advertised intersection определяют accepted subset; URI subscriptions не включаются. Единственный общий watcher сохраняет baseline до ACK, scoped catalog reads, Retry/Gone, cadence/coalescing и legacy delivery. JSON subscriptionId восстанавливается без числового сужения; SDK final Result/ErrorData потребляется owner, не отправляется новым terminal frame. Закрытие body/отмена до ACK дропает pending watcher и завершает/join-ит SDK pump; permit остаётся у body. Это runtime-перенос действующей подписки, не замена HTTP transport/session и не full/load/external-client qualification всего #107.
|
||||
|
||||
Envelopes-срез #107 на базе rc.25/rmcp3.9.0 заменяет handwritten `jsonrpc_result`/`jsonrpc_error` в `jsonrpc.rs` сериализацией настоящих `JsonRpcResponse<Value>` и `JsonRpcError`/`ErrorData`. Уже подключённые consumers — общий `build_app` HTTP JSON и lifecycle SSE terminal обеих revisions; новые dispatch/transport пути не добавляются. Локальная projection+restore сразу возвращает исходные JSON id (включая null, u64 и точную floating-point форму) и i64 error code, которые SDK-типы не представляют полностью; произвольный result и omission error.data сохраняются. Прежний guard correlation не меняется: JSON protocol errors содержат correlation data, lifecycle SSE terminal errors по-прежнему её опускают. Runtime wire controls и отдельный SDK oracle проверяют success/protocol error, а affected regressions — admission, revoked credentials, tool isError и cancellation. Входная валидация, safe response id, auth, статусы/headers, очереди/сессии и transport остаются прежними; это не завершение #107, feature qualification или production deployment.
|
||||
|
||||
Negotiation-results-срез #107 на базе rc.26/rmcp3.9.0 заменяет handwritten ответы legacy `initialize` и modern `server/discover` на настоящие `InitializeResult`/`DiscoverResult` в `protocol/lifecycle_sdk.rs`. Уже подключённый потребитель — штатный `build_app` HTTP JSON/SSE. Версии и их порядок заданы прежним allowlist, capabilities поступают только из registry; server identity, omissions и discovery ttlMs=0/cacheScope=private сохранены. SDK `ServerCapabilities` не представляет дополнительные top-level имена registry: после typed serialization восстанавливаются только отсутствующие ключи, без замены SDK-known полей. HTTP ATDD отдельно проверяет прежний wire и SDK execution, legacy initialize→initialized→защищённый вызов и отсутствие session operations у modern discovery; affected regression сохраняет frozen advertisement, unsupported revision rejection, auth/revocation/Agent scope и legacy transport lifecycle. Следующий initialize-input-срез на базе rc.27 заменяет `app/request.rs::InitializeParams` декодированием настоящего `InitializeRequestParams` в `protocol/lifecycle_sdk.rs`: штатный `handle_initialize` использует SDK `protocol_version` в прежнем allowlist. Локальная projection передаёт только protocolVersion с инертными обязательными SDK capabilities/clientInfo; исходные ignored clientInfo/extensions не валидируются, а raw capabilities сохраняют прежний object-предикат elicitation. HTTP admission (включая запрет sequence params и malformed _meta) остаётся до SDK. Отдельный typed runtime oracle и JSON/SSE tolerance/session ATDD подтверждают использование результата SDK, отсутствие новых отказов и прежний initialize→initialized→защищённый вызов. Generic dispatch/ping, session storage/TTL/reconnect, admission/auth и transport не переносились. Существующий SSE error.data omission не исправляется; полный #107, feature qualification и production deployment не завершены.
|
||||
|
||||
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.
|
||||
|
||||
Notification handler-срез #107 на базе rc.37/rmcp3.9.0 заменяет DTO-only execution legacy `notifications/initialized` и `notifications/cancelled` прямым await настоящих `ServerHandler::on_initialized/on_cancelled` в `app/rmcp_notifications.rs`. Ближайшие подключённые consumers — `dispatch::handle_initialized_notification` и `legacy_dispatch::handle_cancelled_notification` штатного `build_app` HTTP. Durable mark и scoped lookup/cancel выполняются внутри overrides; caller забирает request-local outcome после await, сохраняя empty202/400/404/500 и непрозрачный cancellation ACK. Инертный capture-bootstrap получает настоящий SDK NotificationContext и закрывается до рабочего handler; closed Peer callbacks не поддерживает. No-op/missing outcome, typed-target mutation, numeric/string separation, bootstrap refusal и pending store drop controls дополняют HTTP completed/consumed ATDD; PostgreSQL reconnect/read/write refusal и исчезновение session между get/mark сохраняют прежние guards. Drop прекращает polling request-owned операции, но не обещает rollback уже отправленного SQL или отзыв выполненной отмены. Modern notifications остаются ACK-only без sessions/domain; storage/TTL/reconnect, capabilities, progress/logging/signals/subscriptions и transport не заменены SDK defaults. Старый cancellation decoder оставлен только как test entry к новому production decoder. #107 остаётся open/partial; full/load/external-client qualification, bootstrap performance, #108/4.7 и production не входят в срез.
|
||||
|
||||
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.
|
||||
|
||||
Reference in new issue
Block a user