Compare commits
5
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
986cd78b96 | ||
|
|
bcdf57074b | ||
|
|
b39e4a3470 | ||
|
|
3b30aad28e | ||
|
|
5611e81579 |
No files matched your search
@@ -41,6 +41,7 @@ mod rmcp_http;
|
||||
#[cfg(test)]
|
||||
#[path = "rmcp_http_tests.rs"]
|
||||
mod rmcp_http_tests;
|
||||
mod rmcp_negotiation;
|
||||
mod rmcp_progress_cancel;
|
||||
mod rmcp_prompts;
|
||||
mod rmcp_prompts_projection;
|
||||
@@ -50,6 +51,8 @@ mod rmcp_resources_projection;
|
||||
mod rmcp_session_tests;
|
||||
#[cfg(test)]
|
||||
mod rmcp_tools;
|
||||
mod rmcp_tools_projection;
|
||||
mod rmcp_tools_runtime;
|
||||
#[cfg(test)]
|
||||
#[path = "rmcp_tools_tests.rs"]
|
||||
mod rmcp_tools_tests;
|
||||
|
||||
@@ -17,8 +17,8 @@ use crate::{
|
||||
CompletionCommand, CompletionOutcome, ContinuationSupport, DispatchDecision, MethodHandler,
|
||||
PromptGetCommand, PromptsCommand, PromptsListCommand, PromptsOutcome, RequestIdentity,
|
||||
ResourceReadCommand, ResourcesCommand, ResourcesListCommand, ResourcesOutcome,
|
||||
ServiceContext, ToolCallCommand, ToolsCommand, ToolsListCommand, ToolsOutcome,
|
||||
declared_mcp_method, discover_result, validate_modern_request_name,
|
||||
ServiceContext, ToolCallCommand, ToolsCommand, ToolsListCommand, declared_mcp_method,
|
||||
validate_modern_request_name,
|
||||
},
|
||||
session::SessionState,
|
||||
tool_error::execution_locale,
|
||||
@@ -38,12 +38,10 @@ use time::OffsetDateTime;
|
||||
use super::response::{
|
||||
completion_result, internal_jsonrpc_error, prompt_arguments_error_response, prompt_get_result,
|
||||
prompts_list_result, resource_error_response, resource_read_result,
|
||||
resource_templates_list_result, resources_list_result, tools_list_result,
|
||||
resource_templates_list_result, resources_list_result,
|
||||
};
|
||||
use super::{AgentRoutePath, AppState, TRANSPORT_SESSION_TTL_MS};
|
||||
use crate::protocol::ResourceTemplatesListError;
|
||||
const SERVER_NAME: &str = "crank-mcp-server";
|
||||
const SERVER_VERSION: &str = env!("CARGO_PKG_VERSION");
|
||||
|
||||
/// Serve a request of the modern stateless era.
|
||||
/// No session is created, read or required; identity comes from the per-request `_meta` metadata that
|
||||
@@ -111,32 +109,43 @@ pub(super) async fn handle_modern_request(
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::Discover,
|
||||
..
|
||||
} => transport_response(
|
||||
StatusCode::OK,
|
||||
jsonrpc_result(
|
||||
request_id(message),
|
||||
discover_result(version, SERVER_NAME, SERVER_VERSION),
|
||||
),
|
||||
response_mode,
|
||||
None,
|
||||
Some(version),
|
||||
),
|
||||
} => {
|
||||
let result = match super::rmcp_negotiation::discover(version).await {
|
||||
Ok(result) => result,
|
||||
Err(error) => return sdk_error_response(message, response_mode, version, error),
|
||||
};
|
||||
transport_response(
|
||||
StatusCode::OK,
|
||||
jsonrpc_result(
|
||||
request_id(message),
|
||||
crate::protocol::project_modern_cacheable_result(version, result),
|
||||
),
|
||||
response_mode,
|
||||
None,
|
||||
Some(version),
|
||||
)
|
||||
}
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::Ping,
|
||||
..
|
||||
} => transport_response(
|
||||
StatusCode::OK,
|
||||
jsonrpc_result(
|
||||
request_id(message),
|
||||
crate::protocol::project_modern_result(
|
||||
version,
|
||||
crate::protocol::ping_result(&json!({"method": "ping"}), version),
|
||||
} => {
|
||||
if let Err(error) = super::rmcp_negotiation::ping().await {
|
||||
return sdk_error_response(message, response_mode, version, error);
|
||||
}
|
||||
transport_response(
|
||||
StatusCode::OK,
|
||||
jsonrpc_result(
|
||||
request_id(message),
|
||||
crate::protocol::project_modern_result(
|
||||
version,
|
||||
json!({"protocolVersion": version}),
|
||||
),
|
||||
),
|
||||
),
|
||||
response_mode,
|
||||
None,
|
||||
Some(version),
|
||||
),
|
||||
response_mode,
|
||||
None,
|
||||
Some(version),
|
||||
)
|
||||
}
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::ToolList,
|
||||
..
|
||||
@@ -170,36 +179,7 @@ pub(super) async fn handle_modern_request(
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
match outcome {
|
||||
ToolsOutcome::List { tools, next_cursor } => {
|
||||
match tools_list_result(tools, next_cursor, version) {
|
||||
Ok(result) => transport_response(
|
||||
StatusCode::OK,
|
||||
jsonrpc_result(request_id(message), result),
|
||||
response_mode,
|
||||
None,
|
||||
Some(version),
|
||||
),
|
||||
Err(error) => internal_jsonrpc_error(message, error),
|
||||
}
|
||||
}
|
||||
ToolsOutcome::InvalidParams(message_text) => transport_response(
|
||||
StatusCode::OK,
|
||||
jsonrpc_error(request_id(message), -32602, message_text),
|
||||
response_mode,
|
||||
None,
|
||||
Some(version),
|
||||
),
|
||||
ToolsOutcome::CatalogUnavailable => {
|
||||
internal_jsonrpc_error(message, "published catalog is unavailable")
|
||||
}
|
||||
// A list command never produces a call outcome; it is answered with the adapter's
|
||||
// internal error instead of being silently ignored.
|
||||
ToolsOutcome::Call(_) => internal_jsonrpc_error(
|
||||
message,
|
||||
"unexpected shared tools outcome for a tools/list",
|
||||
),
|
||||
}
|
||||
super::response::sdk_tools_response(message, response_mode, version, outcome)
|
||||
}
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::ToolCall,
|
||||
@@ -761,6 +741,19 @@ pub(super) async fn handle_modern_request(
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn sdk_error_response(
|
||||
message: &Value,
|
||||
mode: ResponseMode,
|
||||
revision: &str,
|
||||
error: rmcp::ErrorData,
|
||||
) -> Response {
|
||||
let mut envelope = jsonrpc_error(request_id(message), i64::from(error.code.0), error.message);
|
||||
if let Some(data) = error.data {
|
||||
envelope["error"]["data"] = data;
|
||||
}
|
||||
transport_response(StatusCode::OK, envelope, mode, None, Some(revision))
|
||||
}
|
||||
|
||||
/// The verified, era-neutral context of a Resource command: the same workspace/Agent/credential/
|
||||
/// correlation the Tools service receives.
|
||||
fn resource_service_context<'a>(
|
||||
@@ -820,6 +813,10 @@ pub(super) async fn handle_initialize(
|
||||
None,
|
||||
);
|
||||
};
|
||||
let initialize_result = match super::rmcp_negotiation::initialize(protocol_version).await {
|
||||
Ok(result) => result,
|
||||
Err(error) => return sdk_error_response(message, response_mode, protocol_version, error),
|
||||
};
|
||||
let now = OffsetDateTime::now_utc();
|
||||
let expires_at = add_millis(now, TRANSPORT_SESSION_TTL_MS);
|
||||
let supports_elicitation = raw_params
|
||||
@@ -845,10 +842,7 @@ pub(super) async fn handle_initialize(
|
||||
|
||||
transport_response(
|
||||
StatusCode::OK,
|
||||
jsonrpc_result(
|
||||
request_id(message),
|
||||
crate::protocol::initialize_result(protocol_version, SERVER_NAME, SERVER_VERSION),
|
||||
),
|
||||
jsonrpc_result(request_id(message), initialize_result),
|
||||
response_mode,
|
||||
Some(&session_id),
|
||||
Some(protocol_version),
|
||||
|
||||
@@ -54,6 +54,10 @@ 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,
|
||||
@@ -85,8 +89,7 @@ pub(crate) struct CounterSet {
|
||||
sdk_signal_notification: AtomicUsize,
|
||||
sdk_jsonrpc_response: AtomicUsize,
|
||||
sdk_jsonrpc_error: AtomicUsize,
|
||||
sdk_ping_request: AtomicUsize,
|
||||
sdk_ping_result: AtomicUsize,
|
||||
|
||||
sdk_inbound_response_decoded: AtomicUsize,
|
||||
sdk_inbound_error_decoded: AtomicUsize,
|
||||
sdk_inbound_response_consumed: AtomicUsize,
|
||||
@@ -96,11 +99,28 @@ pub(crate) struct CounterSet {
|
||||
sdk_initialized_decoded: AtomicUsize,
|
||||
sdk_initialized_consumed: AtomicUsize,
|
||||
sdk_initialize_input: AtomicUsize,
|
||||
sdk_initialize_result: AtomicUsize,
|
||||
sdk_discover_result: AtomicUsize,
|
||||
|
||||
sdk_initialize_handler_completed: AtomicUsize,
|
||||
sdk_initialize_handler_consumed: AtomicUsize,
|
||||
sdk_discover_handler_completed: AtomicUsize,
|
||||
sdk_discover_handler_consumed: AtomicUsize,
|
||||
sdk_ping_handler_completed: AtomicUsize,
|
||||
sdk_ping_handler_consumed: AtomicUsize,
|
||||
}
|
||||
|
||||
impl CounterSet {
|
||||
pub(crate) fn sdk_tools_list_handler_completed(&self) -> usize {
|
||||
self.sdk_tools_list_handler_completed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_tools_list_handler_consumed(&self) -> usize {
|
||||
self.sdk_tools_list_handler_consumed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_tools_call_handler_completed(&self) -> usize {
|
||||
self.sdk_tools_call_handler_completed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_tools_call_handler_consumed(&self) -> usize {
|
||||
self.sdk_tools_call_handler_consumed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_prompts_list_handler_completed(&self) -> usize {
|
||||
self.sdk_prompts_list_handler_completed
|
||||
.load(Ordering::SeqCst)
|
||||
@@ -164,20 +184,28 @@ impl CounterSet {
|
||||
pub(crate) fn sdk_initialized_consumed(&self) -> usize {
|
||||
self.sdk_initialized_consumed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_ping_request(&self) -> usize {
|
||||
self.sdk_ping_request.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_ping_result(&self) -> usize {
|
||||
self.sdk_ping_result.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_initialize_input(&self) -> usize {
|
||||
self.sdk_initialize_input.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_initialize_result(&self) -> usize {
|
||||
self.sdk_initialize_result.load(Ordering::SeqCst)
|
||||
|
||||
pub(crate) fn sdk_initialize_handler_completed(&self) -> usize {
|
||||
self.sdk_initialize_handler_completed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_discover_result(&self) -> usize {
|
||||
self.sdk_discover_result.load(Ordering::SeqCst)
|
||||
pub(crate) fn sdk_initialize_handler_consumed(&self) -> usize {
|
||||
self.sdk_initialize_handler_consumed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_discover_handler_completed(&self) -> usize {
|
||||
self.sdk_discover_handler_completed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_discover_handler_consumed(&self) -> usize {
|
||||
self.sdk_discover_handler_consumed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_ping_handler_completed(&self) -> usize {
|
||||
self.sdk_ping_handler_completed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_ping_handler_consumed(&self) -> usize {
|
||||
self.sdk_ping_handler_consumed.load(Ordering::SeqCst)
|
||||
}
|
||||
pub(crate) fn sdk_jsonrpc_response(&self) -> usize {
|
||||
self.sdk_jsonrpc_response.load(Ordering::SeqCst)
|
||||
@@ -366,6 +394,23 @@ 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);
|
||||
@@ -548,19 +593,32 @@ pub(crate) fn sdk_jsonrpc_error_serialized() {
|
||||
#[path = "../rmcp_envelopes_runtime_tests.rs"]
|
||||
mod rmcp_envelopes_runtime_tests;
|
||||
|
||||
/// Mark only after successfully serializing a real rmcp InitializeResult.
|
||||
pub(crate) fn sdk_initialize_result_serialized() {
|
||||
increment(|counters| &counters.sdk_initialize_result);
|
||||
pub(crate) fn sdk_initialize_handler_completed() {
|
||||
increment(|c| &c.sdk_initialize_handler_completed);
|
||||
}
|
||||
|
||||
/// Mark only after successfully serializing a real rmcp DiscoverResult.
|
||||
pub(crate) fn sdk_discover_result_serialized() {
|
||||
increment(|counters| &counters.sdk_discover_result);
|
||||
pub(crate) fn sdk_initialize_handler_consumed() {
|
||||
increment(|c| &c.sdk_initialize_handler_consumed);
|
||||
}
|
||||
pub(crate) fn sdk_discover_handler_completed() {
|
||||
increment(|c| &c.sdk_discover_handler_completed);
|
||||
}
|
||||
pub(crate) fn sdk_discover_handler_consumed() {
|
||||
increment(|c| &c.sdk_discover_handler_consumed);
|
||||
}
|
||||
pub(crate) fn sdk_ping_handler_completed() {
|
||||
increment(|c| &c.sdk_ping_handler_completed);
|
||||
}
|
||||
pub(crate) fn sdk_ping_handler_consumed() {
|
||||
increment(|c| &c.sdk_ping_handler_consumed);
|
||||
}
|
||||
|
||||
#[path = "../rmcp_lifecycle_negotiation_runtime_tests.rs"]
|
||||
mod rmcp_lifecycle_negotiation_runtime_tests;
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "../rmcp_negotiation_handler_runtime_tests.rs"]
|
||||
mod rmcp_negotiation_handler_runtime_tests;
|
||||
|
||||
/// Mark only where SDK protocol_version is consumed by initialize negotiation, not at DTO creation.
|
||||
pub(crate) fn sdk_initialize_input_consumed(_params: &rmcp::model::InitializeRequestParams) {
|
||||
increment(|counters| &counters.sdk_initialize_input);
|
||||
@@ -569,16 +627,6 @@ pub(crate) fn sdk_initialize_input_consumed(_params: &rmcp::model::InitializeReq
|
||||
#[path = "../rmcp_initialize_input_runtime_tests.rs"]
|
||||
mod rmcp_initialize_input_runtime_tests;
|
||||
|
||||
/// Mark only where a real SDK PingRequest is consumed by the shared runtime ping seam.
|
||||
pub(crate) fn sdk_ping_request_consumed(_request: &rmcp::model::PingRequest) {
|
||||
increment(|counters| &counters.sdk_ping_request);
|
||||
}
|
||||
|
||||
/// Mark only after successfully serializing the real SDK ping result.
|
||||
pub(crate) fn sdk_ping_result_serialized() {
|
||||
increment(|counters| &counters.sdk_ping_result);
|
||||
}
|
||||
|
||||
#[path = "../rmcp_ping_runtime_tests.rs"]
|
||||
mod rmcp_ping_runtime_tests;
|
||||
|
||||
|
||||
@@ -22,7 +22,6 @@ use super::response::{
|
||||
completion_result, internal_jsonrpc_error, prompt_arguments_error_response, prompt_get_result,
|
||||
prompts_list_result, resource_error_response, resource_read_result,
|
||||
resource_templates_list_result, resources_list_result, take_confirmation_token,
|
||||
tools_list_result,
|
||||
};
|
||||
use super::rmcp_dispatch::{
|
||||
handle_resources_command, handle_tools_command, list_resource_templates,
|
||||
@@ -36,7 +35,7 @@ use crate::{
|
||||
EVENT_LEVEL_APPLIED, INVALID_LEVEL, Kind, LoggingOutcome, MethodHandler, PromptGetCommand,
|
||||
PromptsCommand, PromptsListCommand, PromptsOutcome, RequestIdentity, ResourceReadCommand,
|
||||
ResourcesCommand, ResourcesListCommand, ResourcesOutcome, ServiceContext, SetLevelCommand,
|
||||
ToolCallCommand, ToolsCommand, ToolsListCommand, ToolsOutcome, handle_logging_command,
|
||||
ToolCallCommand, ToolsCommand, ToolsListCommand, handle_logging_command,
|
||||
},
|
||||
tool_error::execution_locale,
|
||||
transport::{ResponseMode, session_id_from_headers, transport_response},
|
||||
@@ -107,14 +106,20 @@ pub(super) async fn handle_legacy_request(
|
||||
Err(response) => return response,
|
||||
};
|
||||
|
||||
if let Err(error) = super::rmcp_negotiation::ping().await {
|
||||
return super::dispatch::sdk_error_response(
|
||||
message,
|
||||
response_mode,
|
||||
&session.protocol_version,
|
||||
error,
|
||||
);
|
||||
}
|
||||
|
||||
transport_response(
|
||||
StatusCode::OK,
|
||||
jsonrpc_result(
|
||||
request_id(message),
|
||||
crate::protocol::ping_result(
|
||||
&json!({"method": "ping"}),
|
||||
&session.protocol_version,
|
||||
),
|
||||
json!({"protocolVersion": session.protocol_version}),
|
||||
),
|
||||
response_mode,
|
||||
None,
|
||||
@@ -159,36 +164,12 @@ pub(super) async fn handle_legacy_request(
|
||||
None,
|
||||
)
|
||||
.await;
|
||||
match outcome {
|
||||
ToolsOutcome::List { tools, next_cursor } => {
|
||||
match tools_list_result(tools, next_cursor, &session.protocol_version) {
|
||||
Ok(result) => transport_response(
|
||||
StatusCode::OK,
|
||||
jsonrpc_result(request_id(message), result),
|
||||
response_mode,
|
||||
None,
|
||||
Some(&session.protocol_version),
|
||||
),
|
||||
Err(error) => internal_jsonrpc_error(message, error),
|
||||
}
|
||||
}
|
||||
ToolsOutcome::InvalidParams(message_text) => transport_response(
|
||||
StatusCode::OK,
|
||||
jsonrpc_error(request_id(message), -32602, message_text),
|
||||
response_mode,
|
||||
None,
|
||||
Some(&session.protocol_version),
|
||||
),
|
||||
ToolsOutcome::CatalogUnavailable => {
|
||||
internal_jsonrpc_error(message, "published catalog is unavailable")
|
||||
}
|
||||
// A list command never produces a call outcome; it is answered with the adapter's
|
||||
// internal error instead of being silently ignored.
|
||||
ToolsOutcome::Call(_) => internal_jsonrpc_error(
|
||||
message,
|
||||
"unexpected shared tools outcome for a tools/list",
|
||||
),
|
||||
}
|
||||
super::response::sdk_tools_response(
|
||||
message,
|
||||
response_mode,
|
||||
&session.protocol_version,
|
||||
outcome,
|
||||
)
|
||||
}
|
||||
DispatchDecision::Allowed {
|
||||
handler: MethodHandler::ToolCall,
|
||||
|
||||
@@ -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>,
|
||||
@@ -256,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,
|
||||
@@ -300,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),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,68 +2,18 @@
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use rmcp::model::{CallToolRequestParams, PaginatedRequestParams};
|
||||
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(
|
||||
|
||||
@@ -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,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;
|
||||
@@ -1,14 +1,10 @@
|
||||
//! Typed negotiation results; admission and session lifecycle remain in the HTTP adapter.
|
||||
|
||||
use rmcp::model::{
|
||||
CacheScope, DiscoverResult, Implementation, InitializeRequestParams, InitializeResult,
|
||||
PingRequest, ProtocolVersion, ServerCapabilities, ServerResult,
|
||||
};
|
||||
use rmcp::model::InitializeRequestParams;
|
||||
#[cfg(test)]
|
||||
use rmcp::model::{InitializeResult, ServerCapabilities};
|
||||
use serde_json::Value;
|
||||
|
||||
use super::advertised_server_capabilities;
|
||||
use crate::jsonrpc::SUPPORTED_PROTOCOL_VERSIONS;
|
||||
|
||||
pub(crate) fn initialize_params(
|
||||
params: &Value,
|
||||
) -> Result<InitializeRequestParams, serde_json::Error> {
|
||||
@@ -20,16 +16,13 @@ pub(crate) fn initialize_params(
|
||||
}))
|
||||
}
|
||||
|
||||
fn protocol_version(revision: &str) -> ProtocolVersion {
|
||||
serde_json::from_value(Value::String(revision.to_owned()))
|
||||
.expect("served protocol revisions are strings")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
fn capabilities(advertised: &Value) -> ServerCapabilities {
|
||||
serde_json::from_value(advertised.clone())
|
||||
.expect("registry capability fragments match SDK capability shapes")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
fn restore_registry_extensions(result: &mut Value, advertised: Value) {
|
||||
let capabilities = result["capabilities"]
|
||||
.as_object_mut()
|
||||
@@ -55,59 +48,6 @@ pub(crate) fn initialized_notification(message: &Value) -> rmcp::model::ClientNo
|
||||
notification.into()
|
||||
}
|
||||
|
||||
pub(crate) fn ping_result(message: &Value, revision: &str) -> Value {
|
||||
// Ping params were ignored after admission; do not add SDK constraints to extensions.
|
||||
let request: PingRequest = serde_json::from_value(serde_json::json!({
|
||||
"method": message["method"]
|
||||
}))
|
||||
.expect("registry dispatched a validated ping request");
|
||||
#[cfg(test)]
|
||||
crate::app::dispatch_observer::sdk_ping_request_consumed(&request);
|
||||
let result = match rmcp::model::ClientRequest::from(request) {
|
||||
rmcp::model::ClientRequest::PingRequest(_) => ServerResult::empty(()),
|
||||
_ => unreachable!("typed ping can only dispatch ping"),
|
||||
};
|
||||
let mut result = serde_json::to_value(result).expect("SDK ping result is serializable");
|
||||
#[cfg(test)]
|
||||
crate::app::dispatch_observer::sdk_ping_result_serialized();
|
||||
// Crank keeps the admitted/session revision in addition to the SDK's empty ping result.
|
||||
result["protocolVersion"] = Value::String(revision.to_owned());
|
||||
result
|
||||
}
|
||||
|
||||
pub(crate) fn initialize_result(revision: &str, name: &str, version: &str) -> Value {
|
||||
let advertised = advertised_server_capabilities(revision);
|
||||
let result = InitializeResult::new(capabilities(&advertised))
|
||||
.with_protocol_version(protocol_version(revision))
|
||||
.with_server_info(Implementation::new(name, version));
|
||||
let mut result = serde_json::to_value(result)
|
||||
.expect("SDK initialize result with registry capabilities is serializable");
|
||||
#[cfg(test)]
|
||||
crate::app::dispatch_observer::sdk_initialize_result_serialized();
|
||||
restore_registry_extensions(&mut result, advertised);
|
||||
result
|
||||
}
|
||||
|
||||
pub(crate) fn discover_result(revision: &str, name: &str, version: &str) -> Value {
|
||||
let advertised = advertised_server_capabilities(revision);
|
||||
let result = DiscoverResult::new(
|
||||
SUPPORTED_PROTOCOL_VERSIONS
|
||||
.iter()
|
||||
.map(|revision| protocol_version(revision))
|
||||
.collect(),
|
||||
capabilities(&advertised),
|
||||
)
|
||||
.with_server_info(Implementation::new(name, version))
|
||||
.with_ttl_ms(0)
|
||||
.with_cache_scope(CacheScope::Private);
|
||||
let mut result = serde_json::to_value(result)
|
||||
.expect("SDK discovery result with registry capabilities is serializable");
|
||||
#[cfg(test)]
|
||||
crate::app::dispatch_observer::sdk_discover_result_serialized();
|
||||
restore_registry_extensions(&mut result, advertised);
|
||||
result
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
@@ -45,9 +45,7 @@ pub(crate) use completion::{
|
||||
CompletionArgument, CompletionCommand, CompletionOutcome, CompletionReference,
|
||||
handle_completion_command,
|
||||
};
|
||||
pub(crate) use lifecycle_sdk::{
|
||||
discover_result, initialize_params, initialize_result, initialized_notification, ping_result,
|
||||
};
|
||||
pub(crate) use lifecycle_sdk::{initialize_params, initialized_notification};
|
||||
pub(crate) use logging::{
|
||||
CarriedScope, EVENT_FAILED, EVENT_LEVEL_APPLIED, EVENT_REJECTED, EVENT_SERVED, INVALID_LEVEL,
|
||||
LogLevel, LogLevelStore, LoggingOutcome, SetLevelCommand, carry_scope, handle_logging_command,
|
||||
|
||||
@@ -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"
|
||||
);
|
||||
|
||||
@@ -7,7 +7,10 @@ use std::{sync::Arc, time::Duration};
|
||||
use super::rmcp_progress_cancel_runtime_tests::fixtures::Endpoint;
|
||||
|
||||
fn sdk_counts(c: &CounterSet) -> [usize; 2] {
|
||||
[c.sdk_initialize_result(), c.sdk_discover_result()]
|
||||
[
|
||||
c.sdk_initialize_handler_consumed(),
|
||||
c.sdk_discover_handler_consumed(),
|
||||
]
|
||||
}
|
||||
|
||||
fn capabilities() -> Value {
|
||||
@@ -197,19 +200,19 @@ async fn rmcp_lifecycle_negotiation_observer_positive_control() {
|
||||
let c = Arc::new(CounterSet::default());
|
||||
observe(c.clone(), async {
|
||||
super::admission_enter();
|
||||
super::sdk_initialize_result_serialized();
|
||||
super::sdk_initialize_handler_consumed();
|
||||
assert_eq!(
|
||||
sdk_counts(&c),
|
||||
[1, 0],
|
||||
"initialize and discovery are separate markers"
|
||||
);
|
||||
super::sdk_discover_result_serialized();
|
||||
super::sdk_discover_handler_consumed();
|
||||
})
|
||||
.await;
|
||||
assert_eq!(sdk_counts(&c), [1, 1]);
|
||||
assert_eq!(c.snapshot(), super::Snapshot::new(1, 0, 0, 0));
|
||||
super::sdk_initialize_result_serialized();
|
||||
super::sdk_discover_result_serialized();
|
||||
super::sdk_initialize_handler_consumed();
|
||||
super::sdk_discover_handler_consumed();
|
||||
assert_eq!(sdk_counts(&c), [1, 1], "out-of-scope markers are no-ops");
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,139 @@
|
||||
//! Behavioral RED for real negotiation/ping handler execution and result consumption.
|
||||
use super::rmcp_progress_cancel_runtime_tests::fixtures::Endpoint;
|
||||
use super::{CounterSet, observe, support::*};
|
||||
use serde_json::{Value, json};
|
||||
use std::{sync::Arc, time::Duration};
|
||||
|
||||
async fn request(
|
||||
h: &Endpoint,
|
||||
revision: &str,
|
||||
payload: Value,
|
||||
accept: &str,
|
||||
session: Option<&str>,
|
||||
) -> reqwest::Response {
|
||||
h.request(revision, session, &h.key, accept, payload)
|
||||
.header("x-request-id", "negotiation-handler-atdd")
|
||||
.header(
|
||||
"traceparent",
|
||||
"00-11111111111111111111111111111111-2222222222222222-01",
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
async fn terminal(response: reqwest::Response, sse: bool) -> Value {
|
||||
assert_eq!(response.status(), 200);
|
||||
let raw = tokio::time::timeout(Duration::from_secs(6), response.text())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
if sse {
|
||||
let frames: Vec<Value> = raw
|
||||
.lines()
|
||||
.filter_map(|line| line.strip_prefix("data:"))
|
||||
.map(|line| serde_json::from_str(line.trim()).unwrap())
|
||||
.collect();
|
||||
assert_eq!(frames.len(), 1, "single terminal response frame");
|
||||
frames.into_iter().next().unwrap()
|
||||
} else {
|
||||
serde_json::from_str(&raw).unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
fn handler_counts(c: &CounterSet) -> [usize; 6] {
|
||||
[
|
||||
c.sdk_initialize_handler_completed(),
|
||||
c.sdk_initialize_handler_consumed(),
|
||||
c.sdk_discover_handler_completed(),
|
||||
c.sdk_discover_handler_consumed(),
|
||||
c.sdk_ping_handler_completed(),
|
||||
c.sdk_ping_handler_consumed(),
|
||||
]
|
||||
}
|
||||
|
||||
fn delta(after: [usize; 6], before: [usize; 6]) -> [usize; 6] {
|
||||
std::array::from_fn(|index| after[index] - before[index])
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_negotiation_handler_http_executes_and_consumes_initialize_discover_and_ping() {
|
||||
crank_test_support::postgres_schema_url_for_task("negotiation_handler_owner", "t_219756db")
|
||||
.await;
|
||||
let h = Endpoint::started().await;
|
||||
let session = h.session(LEGACY_REVISION).await;
|
||||
let before_all = handler_counts(&h.counters);
|
||||
for (revision, method, session) in [
|
||||
(LEGACY_REVISION, "initialize", None),
|
||||
(MODERN_REVISION, "server/discover", None),
|
||||
] {
|
||||
let mut payload = if method == "initialize" {
|
||||
legacy_initialize(1)
|
||||
} else {
|
||||
json!({"jsonrpc":"2.0","id":1,"method":method,"params":{"_meta":modern_meta()}})
|
||||
};
|
||||
for accept in ["application/json", "text/event-stream, application/json"] {
|
||||
if method == "initialize" {
|
||||
payload["id"] = json!(if accept.starts_with("text/event") {
|
||||
2
|
||||
} else {
|
||||
1
|
||||
});
|
||||
}
|
||||
let response = request(&h, revision, payload.clone(), accept, session).await;
|
||||
let body = terminal(response, accept.starts_with("text/event")).await;
|
||||
assert_eq!(body["jsonrpc"], "2.0");
|
||||
}
|
||||
}
|
||||
for revision in [LEGACY_REVISION, MODERN_REVISION] {
|
||||
for accept in ["application/json", "text/event-stream, application/json"] {
|
||||
let payload = json!({"jsonrpc":"2.0","id":"ping","method":"ping","params":{"_meta":if revision == MODERN_REVISION { modern_meta() } else { json!({"future":true}) }}});
|
||||
let response = request(
|
||||
&h,
|
||||
revision,
|
||||
payload,
|
||||
accept,
|
||||
if revision == LEGACY_REVISION {
|
||||
session.as_deref()
|
||||
} else {
|
||||
None
|
||||
},
|
||||
)
|
||||
.await;
|
||||
let body = terminal(response, accept.starts_with("text/event")).await;
|
||||
assert_eq!(body["id"], "ping");
|
||||
assert!(body.get("error").is_none());
|
||||
if revision == LEGACY_REVISION {
|
||||
assert_eq!(body["result"]["protocolVersion"], LEGACY_REVISION);
|
||||
}
|
||||
}
|
||||
}
|
||||
let after = handler_counts(&h.counters);
|
||||
assert_eq!(
|
||||
delta(after, before_all),
|
||||
[2, 2, 2, 2, 4, 4],
|
||||
"successful initialize/discover/ping HTTP responses must complete in and consume their SDK handler results"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_negotiation_handler_observer_positive_control() {
|
||||
let c = Arc::new(CounterSet::default());
|
||||
observe(c.clone(), async {
|
||||
super::sdk_initialize_handler_completed();
|
||||
super::sdk_initialize_handler_consumed();
|
||||
super::sdk_discover_handler_completed();
|
||||
super::sdk_discover_handler_consumed();
|
||||
super::sdk_ping_handler_completed();
|
||||
super::sdk_ping_handler_consumed();
|
||||
assert_eq!(handler_counts(&c), [1; 6]);
|
||||
})
|
||||
.await;
|
||||
assert_eq!(handler_counts(&c), [1; 6]);
|
||||
super::sdk_initialize_handler_completed();
|
||||
assert_eq!(
|
||||
handler_counts(&c),
|
||||
[1; 6],
|
||||
"markers outside observer scope are inert"
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,209 @@
|
||||
//! The production adapters consume actual trait results and own their pending work.
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_negotiation_handler_qa_discover_uses_requested_revision_capabilities() {
|
||||
use crate::protocol::{
|
||||
CAPABILITY_DESCRIPTORS, CapabilityId, CapabilityRegistry, METHOD_DESCRIPTORS,
|
||||
};
|
||||
use std::sync::Arc;
|
||||
|
||||
let mut outcomes = Vec::new();
|
||||
for revisions in [&["2026-07-28"][..], &["2025-11-25"][..]] {
|
||||
let mut descriptors = CAPABILITY_DESCRIPTORS.to_vec();
|
||||
descriptors
|
||||
.iter_mut()
|
||||
.find(|d| d.id == CapabilityId::Tools)
|
||||
.unwrap()
|
||||
.revisions = revisions;
|
||||
let registration =
|
||||
Arc::new(CapabilityRegistry::new(&descriptors, METHOD_DESCRIPTORS).unwrap());
|
||||
crate::app::dispatch_observer::observe_with_registration(registration, async {
|
||||
let expected = advertised_server_capabilities("2026-07-28");
|
||||
let actual = discover("2026-07-28").await.unwrap();
|
||||
outcomes.push((
|
||||
expected["tools"].clone(),
|
||||
actual["capabilities"]["tools"].clone(),
|
||||
));
|
||||
})
|
||||
.await;
|
||||
}
|
||||
assert_eq!(
|
||||
outcomes,
|
||||
vec![
|
||||
(json!({"listChanged":true}), json!({"listChanged":true})),
|
||||
(Value::Null, Value::Null)
|
||||
],
|
||||
"modern-only tools must be advertised; legacy-only tools must not leak into modern discovery"
|
||||
);
|
||||
}
|
||||
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
|
||||
|
||||
#[derive(Default)]
|
||||
struct Control {
|
||||
calls: AtomicUsize,
|
||||
dropped: AtomicBool,
|
||||
finished: AtomicBool,
|
||||
fail: bool,
|
||||
pending: bool,
|
||||
}
|
||||
struct Witness<'a>(&'a AtomicBool);
|
||||
impl Drop for Witness<'_> {
|
||||
fn drop(&mut self) {
|
||||
self.0.store(true, SeqCst);
|
||||
}
|
||||
}
|
||||
fn error() -> ErrorData {
|
||||
ErrorData::new(
|
||||
ErrorCode(-32042),
|
||||
"typed negotiation failure",
|
||||
Some(json!({"proof":42})),
|
||||
)
|
||||
}
|
||||
impl Control {
|
||||
async fn enter(&self, context: &RequestContext<RoleServer>) -> Result<(), ErrorData> {
|
||||
assert!(
|
||||
context.peer.is_transport_closed(),
|
||||
"bootstrap closes before handler"
|
||||
);
|
||||
self.calls.fetch_add(1, SeqCst);
|
||||
let _witness = Witness(&self.dropped);
|
||||
if self.pending {
|
||||
std::future::pending::<()>().await;
|
||||
}
|
||||
self.finished.store(true, SeqCst);
|
||||
if self.fail { Err(error()) } else { Ok(()) }
|
||||
}
|
||||
}
|
||||
impl ServerHandler for Control {
|
||||
async fn initialize(
|
||||
&self,
|
||||
request: InitializeRequestParams,
|
||||
context: RequestContext<RoleServer>,
|
||||
) -> Result<InitializeResult, ErrorData> {
|
||||
self.enter(&context).await?;
|
||||
let mut result = ServerHandler::initialize(&NegotiationHandler, request, context).await?;
|
||||
result.server_info = Implementation::new("typed-initialize", "42");
|
||||
result.capabilities.tools = None;
|
||||
Ok(result)
|
||||
}
|
||||
async fn discover(
|
||||
&self,
|
||||
context: RequestContext<RoleServer>,
|
||||
) -> Result<DiscoverResult, ErrorData> {
|
||||
self.enter(&context).await?;
|
||||
let mut result = ServerHandler::discover(&NegotiationHandler, context).await?;
|
||||
result = result.with_server_info(Implementation::new("typed-discover", "42"));
|
||||
result.capabilities.tools = None;
|
||||
Ok(result)
|
||||
}
|
||||
async fn ping(&self, context: RequestContext<RoleServer>) -> Result<(), ErrorData> {
|
||||
self.enter(&context).await
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_negotiation_handler_mutated_typed_success_is_consumed() {
|
||||
let h = Control::default();
|
||||
let init = initialize_with(&h, "2025-11-25").await.unwrap();
|
||||
assert_eq!(init["serverInfo"]["name"], "typed-initialize");
|
||||
assert!(init["capabilities"].get("tools").is_none());
|
||||
let discover = discover_with(&h, "2026-07-28").await.unwrap();
|
||||
assert_eq!(
|
||||
discover["_meta"]["io.modelcontextprotocol/serverInfo"]["name"],
|
||||
"typed-discover"
|
||||
);
|
||||
assert!(discover["capabilities"].get("tools").is_none());
|
||||
ping_with(&h).await.unwrap();
|
||||
assert_eq!(h.calls.load(SeqCst), 3, "no bootstrap invocation");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_negotiation_handler_typed_errors_are_not_success() {
|
||||
let h = Control {
|
||||
fail: true,
|
||||
..Default::default()
|
||||
};
|
||||
for actual in [
|
||||
initialize_with(&h, "2025-11-25").await.unwrap_err(),
|
||||
discover_with(&h, "2026-07-28").await.unwrap_err(),
|
||||
ping_with(&h).await.unwrap_err(),
|
||||
] {
|
||||
assert_eq!(actual, error());
|
||||
for mode in [
|
||||
crate::transport::ResponseMode::Json,
|
||||
crate::transport::ResponseMode::Sse,
|
||||
] {
|
||||
let response = super::super::dispatch::sdk_error_response(
|
||||
&json!({"id":"typed-error"}),
|
||||
mode,
|
||||
"2025-11-25",
|
||||
actual.clone(),
|
||||
);
|
||||
assert_eq!(response.status(), 200);
|
||||
assert!(response.headers().get("mcp-session-id").is_none());
|
||||
let bytes = axum::body::to_bytes(response.into_body(), usize::MAX)
|
||||
.await
|
||||
.unwrap();
|
||||
let raw = std::str::from_utf8(&bytes).unwrap();
|
||||
let body: Value = match mode {
|
||||
crate::transport::ResponseMode::Json => serde_json::from_str(raw).unwrap(),
|
||||
crate::transport::ResponseMode::Sse => serde_json::from_str(
|
||||
raw.lines()
|
||||
.find_map(|l| l.strip_prefix("data:"))
|
||||
.unwrap()
|
||||
.trim(),
|
||||
)
|
||||
.unwrap(),
|
||||
};
|
||||
assert_eq!(
|
||||
body,
|
||||
json!({"jsonrpc":"2.0","id":"typed-error","error":{"code":-32042,"message":"typed negotiation failure","data":{"proof":42}}})
|
||||
);
|
||||
}
|
||||
}
|
||||
assert_eq!(h.calls.load(SeqCst), 3);
|
||||
assert!(initialize("not-supported").await.is_err());
|
||||
assert_eq!(
|
||||
NegotiationHandler
|
||||
.supported_protocol_versions()
|
||||
.iter()
|
||||
.map(|v| v.as_str())
|
||||
.collect::<Vec<_>>(),
|
||||
SUPPORTED_PROTOCOL_VERSIONS
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_negotiation_handler_drop_cancels_request_owned_work() {
|
||||
for method in 0..3 {
|
||||
let h = Control {
|
||||
pending: true,
|
||||
..Default::default()
|
||||
};
|
||||
let mut future = Box::pin(async {
|
||||
match method {
|
||||
0 => {
|
||||
initialize_with(&h, "2025-11-25").await?;
|
||||
}
|
||||
1 => {
|
||||
discover_with(&h, "2026-07-28").await?;
|
||||
}
|
||||
_ => {
|
||||
ping_with(&h).await?;
|
||||
}
|
||||
}
|
||||
Ok::<_, ErrorData>(())
|
||||
});
|
||||
tokio::select! {
|
||||
result = &mut future => panic!("pending handler completed: {result:?}"),
|
||||
_ = async { while h.calls.load(SeqCst) == 0 { tokio::task::yield_now().await; } } => {}
|
||||
}
|
||||
assert!(!h.dropped.load(SeqCst));
|
||||
drop(future);
|
||||
assert!(h.dropped.load(SeqCst));
|
||||
tokio::task::yield_now().await;
|
||||
assert!(!h.finished.load(SeqCst));
|
||||
assert_eq!(h.calls.load(SeqCst), 1);
|
||||
}
|
||||
}
|
||||
@@ -75,7 +75,10 @@ async fn success_control(revision: &str) -> Vec<(usize, usize)> {
|
||||
] {
|
||||
let counters = h.counters.snapshot();
|
||||
let ops = h.sessions.snapshot();
|
||||
let before = (h.counters.sdk_ping_request(), h.counters.sdk_ping_result());
|
||||
let before = (
|
||||
h.counters.sdk_ping_handler_completed(),
|
||||
h.counters.sdk_ping_handler_consumed(),
|
||||
);
|
||||
let response = correlated(h.request(
|
||||
revision,
|
||||
session.as_deref(),
|
||||
@@ -118,8 +121,8 @@ async fn success_control(revision: &str) -> Vec<(usize, usize)> {
|
||||
},
|
||||
);
|
||||
sdk.push((
|
||||
h.counters.sdk_ping_request() - before.0,
|
||||
h.counters.sdk_ping_result() - before.1,
|
||||
h.counters.sdk_ping_handler_completed() - before.0,
|
||||
h.counters.sdk_ping_handler_consumed() - before.1,
|
||||
));
|
||||
eprintln!(
|
||||
"existing GREEN ping revision={revision} accept={accept} extended={extended}; SDK delta={:?}",
|
||||
@@ -176,9 +179,20 @@ async fn ping_guards_never_enter_sdk() {
|
||||
assert!(wire.get("result").is_none());
|
||||
}
|
||||
assert_eq!(
|
||||
(h.counters.sdk_ping_request(), h.counters.sdk_ping_result()),
|
||||
(
|
||||
h.counters.sdk_ping_handler_completed(),
|
||||
h.counters.sdk_ping_handler_consumed()
|
||||
),
|
||||
(0, 0)
|
||||
);
|
||||
assert_eq!(
|
||||
(
|
||||
h.counters.sdk_ping_handler_completed(),
|
||||
h.counters.sdk_ping_handler_consumed()
|
||||
),
|
||||
(0, 0),
|
||||
"pre-handler guard rejection must not execute or consume the SDK ping handler"
|
||||
);
|
||||
eprintln!("existing GREEN pre-seam guard revision={revision}; SDK=(0,0)");
|
||||
}
|
||||
}
|
||||
@@ -186,24 +200,37 @@ async fn ping_guards_never_enter_sdk() {
|
||||
#[tokio::test]
|
||||
async fn ping_observer_positive_control() {
|
||||
let c = Arc::new(CounterSet::default());
|
||||
let request: rmcp::model::PingRequest =
|
||||
serde_json::from_value(json!({"method":"ping"})).unwrap();
|
||||
observe(c.clone(), async {
|
||||
super::sdk_ping_request_consumed(&request);
|
||||
assert_eq!((c.sdk_ping_request(), c.sdk_ping_result()), (1, 0));
|
||||
super::sdk_ping_result_serialized();
|
||||
assert_eq!((c.sdk_ping_request(), c.sdk_ping_result()), (1, 1));
|
||||
super::sdk_ping_handler_completed();
|
||||
assert_eq!(
|
||||
(
|
||||
c.sdk_ping_handler_completed(),
|
||||
c.sdk_ping_handler_consumed()
|
||||
),
|
||||
(1, 0)
|
||||
);
|
||||
super::sdk_ping_handler_consumed();
|
||||
assert_eq!(
|
||||
(
|
||||
c.sdk_ping_handler_completed(),
|
||||
c.sdk_ping_handler_consumed()
|
||||
),
|
||||
(1, 1)
|
||||
);
|
||||
})
|
||||
.await;
|
||||
super::sdk_ping_request_consumed(&request);
|
||||
super::sdk_ping_result_serialized();
|
||||
super::sdk_ping_handler_completed();
|
||||
super::sdk_ping_handler_consumed();
|
||||
observe(Arc::new(CounterSet::default()), async {
|
||||
super::sdk_ping_request_consumed(&request);
|
||||
super::sdk_ping_result_serialized();
|
||||
super::sdk_ping_handler_completed();
|
||||
super::sdk_ping_handler_consumed();
|
||||
})
|
||||
.await;
|
||||
assert_eq!(
|
||||
(c.sdk_ping_request(), c.sdk_ping_result()),
|
||||
(
|
||||
c.sdk_ping_handler_completed(),
|
||||
c.sdk_ping_handler_consumed()
|
||||
),
|
||||
(1, 1),
|
||||
"scope isolation and out-of-scope no-op"
|
||||
);
|
||||
|
||||
@@ -365,6 +365,45 @@ async fn rmcp_runtime_sdk_dispatch_legacy() {
|
||||
);
|
||||
}
|
||||
|
||||
async fn handler_execution_control(revision: &str) {
|
||||
let h = Endpoint::started().await;
|
||||
let session = h.session(revision).await;
|
||||
let session = session.as_deref();
|
||||
h.list(revision, session, TOOL_NAME).await;
|
||||
h.call(
|
||||
revision,
|
||||
session,
|
||||
TOOL_NAME,
|
||||
&format!("{revision}@handler.test"),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(
|
||||
h.calls.load(Ordering::SeqCst),
|
||||
1,
|
||||
"one domain call expected"
|
||||
);
|
||||
assert_eq!(
|
||||
[
|
||||
h.counters.sdk_tools_list_handler_completed(),
|
||||
h.counters.sdk_tools_list_handler_consumed(),
|
||||
h.counters.sdk_tools_call_handler_completed(),
|
||||
h.counters.sdk_tools_call_handler_consumed(),
|
||||
],
|
||||
[1, 1, 1, 1],
|
||||
"real build_app HTTP tools/list and tools/call must execute and consume SDK handler results ({revision})"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_tools_handler_http_modern() {
|
||||
handler_execution_control(MODERN_REVISION).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_tools_handler_http_legacy() {
|
||||
handler_execution_control(LEGACY_REVISION).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_runtime_observer_is_request_scoped() {
|
||||
let counters = Arc::new(CounterSet::default());
|
||||
|
||||
@@ -0,0 +1,325 @@
|
||||
//! Real trait-result consumption controls and request-owned cancellation.
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct Domain {
|
||||
outcome: Mutex<Option<ToolsOutcome>>,
|
||||
calls: AtomicUsize,
|
||||
pending: bool,
|
||||
started: tokio::sync::Notify,
|
||||
dropped: AtomicBool,
|
||||
}
|
||||
struct Witness<'a>(&'a AtomicBool);
|
||||
impl Drop for Witness<'_> {
|
||||
fn drop(&mut self) {
|
||||
self.0.store(true, SeqCst);
|
||||
}
|
||||
}
|
||||
impl Domain {
|
||||
pub(super) async fn execute(&self, scope: &Scope, command: ToolsCommand) -> ToolsOutcome {
|
||||
self.calls.fetch_add(1, SeqCst);
|
||||
assert_eq!(scope.workspace, "workspace");
|
||||
assert_eq!(scope.agent, "agent");
|
||||
assert_eq!(
|
||||
scope
|
||||
.credential
|
||||
.platform_api_key_id
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.as_str(),
|
||||
"key"
|
||||
);
|
||||
assert_eq!(scope.locale, ExecutionLocale::En);
|
||||
match command {
|
||||
ToolsCommand::List(list) => {
|
||||
assert_eq!(list.cursor.as_deref(), Some("cursor"));
|
||||
assert_eq!(list.limit, Some(7));
|
||||
}
|
||||
ToolsCommand::Call(call) => {
|
||||
assert_eq!(call.tool_name, "bound");
|
||||
assert_eq!(call.arguments, json!({"number":42,"nested":[null]}));
|
||||
assert_eq!(call.confirmation_token.as_deref(), Some("confirmation"));
|
||||
assert!(scope.lifecycle.is_some());
|
||||
}
|
||||
}
|
||||
let _witness = Witness(&self.dropped);
|
||||
self.started.notify_one();
|
||||
if self.pending {
|
||||
std::future::pending::<()>().await;
|
||||
}
|
||||
self.outcome
|
||||
.lock()
|
||||
.unwrap()
|
||||
.take()
|
||||
.expect("one domain call")
|
||||
}
|
||||
}
|
||||
fn scope() -> Scope {
|
||||
Scope {
|
||||
workspace: "workspace".into(),
|
||||
agent: "agent".into(),
|
||||
credential: VerifiedMachineCredential {
|
||||
machine_access_mode: crank_core::MachineAccessMode::StaticAgentKey,
|
||||
max_security_level: crank_core::OperationSecurityLevel::Standard,
|
||||
scopes: vec![crank_core::PlatformApiKeyScope::Read],
|
||||
platform_api_key_id: Some("key".into()),
|
||||
},
|
||||
correlation: CorrelationContext::generate(),
|
||||
continuation: ContinuationSupport::ElicitationUnsupported,
|
||||
locale: ExecutionLocale::En,
|
||||
limit: Some(7),
|
||||
confirmation: Some("confirmation".into()),
|
||||
lifecycle: Some(ToolCallLifecycle::new(None).0),
|
||||
}
|
||||
}
|
||||
async fn state() -> Arc<AppState> {
|
||||
crank_test_support::postgres_schema_url_for_task("tools_handler_local", "t_75a3342f").await;
|
||||
super::super::rmcp_tools_tests::test_state().await
|
||||
}
|
||||
fn handler(state: &Arc<AppState>, outcome: ToolsOutcome) -> Handler {
|
||||
let mut h = Handler::new(state);
|
||||
h.domain = Some(Arc::new(Domain {
|
||||
outcome: Mutex::new(Some(outcome)),
|
||||
..Default::default()
|
||||
}));
|
||||
h
|
||||
}
|
||||
async fn context(h: &Handler) -> RequestContext<RoleServer> {
|
||||
let context = request_context(h, scope()).await.unwrap();
|
||||
assert!(context.peer.is_transport_closed());
|
||||
assert_eq!(Arc::strong_count(&h.extras), 1);
|
||||
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 0);
|
||||
context
|
||||
}
|
||||
fn call() -> CallToolRequestParams {
|
||||
CallToolRequestParams::new("bound").with_arguments(
|
||||
json!({"number":42,"nested":[null]})
|
||||
.as_object()
|
||||
.unwrap()
|
||||
.clone(),
|
||||
)
|
||||
}
|
||||
fn payload(outcome: Outcome, version: &str) -> Value {
|
||||
match super::super::response::sdk_tools_payload(&json!({"id":17}), version, outcome) {
|
||||
super::super::response::ToolCommandPayload::Ok(value) => value,
|
||||
_ => panic!("expected wire payload"),
|
||||
}
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_tools_handler_list_typed_mutation_and_lossless_catalog() {
|
||||
let state = state().await;
|
||||
for version in ["2025-11-25", "2026-07-28"] {
|
||||
let raw = json!({"name":"original","inputSchema":{"type":"object"},"description":null,
|
||||
"annotations":{"readOnlyHint":true,"x-extra":[null]},"icons":null,"x-tool":{}});
|
||||
let h = handler(
|
||||
&state,
|
||||
ToolsOutcome::List {
|
||||
tools: vec![raw.clone()],
|
||||
next_cursor: Some("next".into()),
|
||||
},
|
||||
);
|
||||
let mut result = ServerHandler::list_tools(
|
||||
&h,
|
||||
Some(PaginatedRequestParams::default().with_cursor(Some("cursor".into()))),
|
||||
context(&h).await,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
result.tools[0].name = "mutated".into();
|
||||
result.tools[0].description = Some("typed description".into());
|
||||
result.next_cursor = Some("changed".into());
|
||||
let wire = payload(
|
||||
projection::consume_list(Ok(result), h.take_extras()),
|
||||
version,
|
||||
);
|
||||
let mut expected = raw;
|
||||
expected["name"] = json!("mutated");
|
||||
expected["description"] = json!("typed description");
|
||||
assert_eq!(wire["result"]["tools"], json!([expected]));
|
||||
assert_eq!(wire["result"]["nextCursor"], "changed");
|
||||
assert_eq!(
|
||||
wire["result"].get("resultType").is_some(),
|
||||
version == "2026-07-28"
|
||||
);
|
||||
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
|
||||
}
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_tools_handler_call_typed_content_structured_and_is_error_mutations() {
|
||||
let state = state().await;
|
||||
for version in ["2025-11-25", "2026-07-28"] {
|
||||
for original in [
|
||||
ToolCallOutcome::Completed(Value::Null),
|
||||
ToolCallOutcome::ApprovalPending(json!({"approval":true})),
|
||||
] {
|
||||
let h = handler(&state, ToolsOutcome::Call(original));
|
||||
let result = ServerHandler::call_tool(&h, call(), context(&h).await)
|
||||
.await
|
||||
.unwrap();
|
||||
let CallToolResponse::Complete(mut result) = result else {
|
||||
panic!("complete result");
|
||||
};
|
||||
result.content = vec![ContentBlock::text("typed content")];
|
||||
result.structured_content = Some(json!({"typed":42}));
|
||||
result.is_error = Some(true);
|
||||
let wire = payload(projection::consume_call(Ok(result.into())), version);
|
||||
assert_eq!(
|
||||
wire["result"]["content"],
|
||||
json!([{"type":"text","text":"typed content"}])
|
||||
);
|
||||
assert_eq!(wire["result"]["structuredContent"], json!({"typed":42}));
|
||||
assert_eq!(wire["result"]["isError"], true);
|
||||
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_tools_handler_typed_list_and_call_errors_are_consumed() {
|
||||
let state = state().await;
|
||||
for version in ["2025-11-25", "2026-07-28"] {
|
||||
let h = handler(&state, ToolsOutcome::InvalidParams("original list".into()));
|
||||
let result = ServerHandler::list_tools(
|
||||
&h,
|
||||
Some(PaginatedRequestParams::default().with_cursor(Some("cursor".into()))),
|
||||
context(&h).await,
|
||||
)
|
||||
.await;
|
||||
let mut error = result.unwrap_err();
|
||||
error.message = "mutated list".into();
|
||||
error.data = Some(json!({"typed":true}));
|
||||
let wire = payload(
|
||||
projection::consume_list(Err(error), h.take_extras()),
|
||||
version,
|
||||
);
|
||||
assert_eq!(wire["error"]["message"], "mutated list");
|
||||
assert_eq!(wire["error"]["data"], json!({"typed":true}));
|
||||
let h = handler(
|
||||
&state,
|
||||
ToolsOutcome::Call(ToolCallOutcome::InvalidParams("original call".into())),
|
||||
);
|
||||
let mut error = ServerHandler::call_tool(&h, call(), context(&h).await)
|
||||
.await
|
||||
.unwrap_err();
|
||||
error.code = ErrorCode(-32001);
|
||||
error.message = "mutated call".into();
|
||||
error.data = Some(json!({"typed":42}));
|
||||
let wire = payload(projection::consume_call(Err(error)), version);
|
||||
assert_eq!(wire["error"]["code"], -32001);
|
||||
assert_eq!(wire["error"]["message"], "mutated call");
|
||||
assert_eq!(wire["error"]["data"], json!({"typed":42}));
|
||||
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
|
||||
}
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_tools_handler_domain_outcomes_keep_wire_semantics() {
|
||||
use crate::tool_error::{McpControlError, control_tool_error_contract};
|
||||
let state = state().await;
|
||||
for version in ["2025-11-25", "2026-07-28"] {
|
||||
for kind in 0..6 {
|
||||
let outcome = || match kind {
|
||||
0 => ToolCallOutcome::Completed(Value::Null),
|
||||
1 => ToolCallOutcome::ApprovalPending(json!({"approval":"pending"})),
|
||||
2 => ToolCallOutcome::ApprovalUnavailable(
|
||||
McpControlError::ApprovalElicitationNotSupported,
|
||||
),
|
||||
3 => ToolCallOutcome::Error(control_tool_error_contract(
|
||||
McpControlError::CatalogRevisionChanged,
|
||||
"request",
|
||||
"trace",
|
||||
ExecutionLocale::En,
|
||||
)),
|
||||
4 => ToolCallOutcome::InvalidParams("invalid argument".into()),
|
||||
_ => ToolCallOutcome::InternalFailure,
|
||||
};
|
||||
let h = handler(&state, ToolsOutcome::Call(outcome()));
|
||||
let ctx = context(&h).await;
|
||||
let correlation = Handler::scope(&ctx).unwrap().correlation;
|
||||
let result = ServerHandler::call_tool(&h, call(), ctx).await;
|
||||
let actual = payload(projection::consume_call(result), version);
|
||||
let expected = super::super::response::tool_command_payload(
|
||||
&json!({"id":17}),
|
||||
version,
|
||||
&correlation,
|
||||
ToolsOutcome::Call(outcome()),
|
||||
);
|
||||
match expected {
|
||||
super::super::response::ToolCommandPayload::Ok(expected) => {
|
||||
assert_eq!(actual, expected)
|
||||
}
|
||||
super::super::response::ToolCommandPayload::Internal(_) => {
|
||||
assert_eq!(actual["error"]["code"], -32603);
|
||||
assert_eq!(actual["error"]["message"], "internal server error");
|
||||
}
|
||||
}
|
||||
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
|
||||
}
|
||||
for raw in [
|
||||
json!({"name":"tool","inputSchema":{},"description":null,"_meta":null,"annotations":{},"icons":[]}),
|
||||
json!({"name":"tool","inputSchema":{},"annotations":{"x-annotation":null},"icons":null,"x-tool":[null,{}]}),
|
||||
] {
|
||||
let h = handler(
|
||||
&state,
|
||||
ToolsOutcome::List {
|
||||
tools: vec![raw.clone()],
|
||||
next_cursor: Some(String::new()),
|
||||
},
|
||||
);
|
||||
let result = ServerHandler::list_tools(
|
||||
&h,
|
||||
Some(PaginatedRequestParams::default().with_cursor(Some("cursor".into()))),
|
||||
context(&h).await,
|
||||
)
|
||||
.await;
|
||||
let wire = payload(projection::consume_list(result, h.take_extras()), version);
|
||||
assert_eq!(wire["result"]["tools"], json!([raw]));
|
||||
assert_eq!(wire["result"]["nextCursor"], "");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_tools_handler_pending_domain_dropped_with_parent_and_identity_is_local() {
|
||||
let state = state().await;
|
||||
for list in [false, true] {
|
||||
let mut h = Handler::new(&state);
|
||||
h.domain = Some(Arc::new(Domain {
|
||||
pending: true,
|
||||
..Default::default()
|
||||
}));
|
||||
let ctx = context(&h).await;
|
||||
let other = request_context(
|
||||
&h,
|
||||
Scope {
|
||||
agent: "other-agent".into(),
|
||||
..scope()
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(Handler::scope(&ctx).unwrap().agent, "agent");
|
||||
assert_eq!(Handler::scope(&other).unwrap().agent, "other-agent");
|
||||
let parent = async {
|
||||
if list {
|
||||
let _ = ServerHandler::list_tools(
|
||||
&h,
|
||||
Some(PaginatedRequestParams::default().with_cursor(Some("cursor".into()))),
|
||||
ctx,
|
||||
)
|
||||
.await;
|
||||
} else {
|
||||
let _ = ServerHandler::call_tool(&h, call(), ctx).await;
|
||||
}
|
||||
};
|
||||
let domain = h.domain.as_ref().unwrap();
|
||||
{
|
||||
let parent = parent;
|
||||
tokio::pin!(parent);
|
||||
tokio::select! { _ = domain.started.notified() => {}, _ = &mut parent => panic!("pending domain completed") }
|
||||
assert!(!domain.dropped.load(SeqCst));
|
||||
}
|
||||
assert!(domain.dropped.load(SeqCst));
|
||||
assert_eq!(domain.calls.load(SeqCst), 1);
|
||||
}
|
||||
}
|
||||
@@ -51,6 +51,8 @@ Negotiation-results-срез #107 на базе rc.26/rmcp3.9.0 заменяет
|
||||
|
||||
Ping-срез #107 на базе rc.28/rmcp3.9.0 подключает обе штатные HTTP ветки к общему `protocol/lifecycle_sdk.rs::ping_result`: проекция уже допущенного метода декодируется в `PingRequest`, его SDK request variant выбирает `ServerResult::empty(())`, а сериализованный SDK результат поступает в прежний JSON/SSE terminal. Удалены два handwritten ping result builder; Crank добавляет прежний `protocolVersion` из legacy session либо modern identity, а modern result projection сохраняется. Игнорируемые params/extensions не получают новых SDK ограничений. Legacy initialized-session guard остаётся перед helper; modern ping не обращается к sessions. Runtime ATDD отдельно подтверждает SDK request/result execution и прежние wire/status/headers/id/correlation обеих revisions; affected regressions проверяют session/admission/method/revocation guards. Generic dispatch, session storage/TTL/reconnect, admission/auth и transport остаются прежними; полный #107, feature qualification и production deployment не завершены.
|
||||
|
||||
Negotiation-handler-срез #107 поверх rc.36/rmcp3.9.0 заменяет описанные выше DTO-only negotiation/ping helpers на прямые await настоящих `ServerHandler::initialize/discover/ping` в request-owned `app/rmcp_negotiation.rs`. Реальные consumers — legacy initialize/ping и modern discover/ping штатного `build_app` JSON/SSE; typed Result/ErrorData определяет ответ, а legacy session создаётся только после успешного initialize. Bootstrap инертен и закрывается до handler; pending trait future принадлежит запросу и прекращается при drop. Allowlist/порядок revisions, registry capabilities, identity, discovery cache hints, ignored inputs и прежние durable guards сохранены; projection восстанавливает только непредставимые SDK registry extensions и era-specific wire omissions. HTTP completed/consumed oracle обеих revisions дополнен typed-result mutation/error и drop controls; прежние wire/session/admission/revocation проверки сохраняются. DTO-only production builders удалены, initialized notification остаётся прежним typed переходом. Это не перенос SDK HTTP transport/SessionManager, callbacks или полного lifecycle: #107 остаётся open/partial, bootstrap performance и full/load/external-client qualification не завершены; #108/4.7/production не запускаются.
|
||||
|
||||
Initialized-срез #107 на базе rc.29/rmcp3.9.0 подключает штатный legacy HTTP handshake к `InitializedNotification` и `ClientNotification`: после registry/admission проекция метода декодируется SDK, а matched initialized variant после прежних session/scope guards разрешает существующий durable `mark_initialized`. Игнорируемые params/extensions, 202 с пустым телом, JSON/SSE и modern no-session поведение сохранены; SDK SessionManager не используется. Runtime-тесты отдельно наблюдают decoding и consumption, проверяют PostgreSQL reconnect и отказ store на чтении/записи. Это только lifecycle-срез, не завершение #107.
|
||||
|
||||
Envelope-dispatch-срез #107 на базе rc.30/rmcp3.9.0 подключает обе действующие HTTP ветки `app/dispatch.rs` и `app/legacy_dispatch.rs` к общему `protocol/dispatch_sdk.rs`: после прежних admission/auth guards минимальная проекция декодируется в настоящие `JsonRpcRequest<Value>`/`JsonRpcNotification<Value>`. SDK payload method выбирает прежний `registry::dispatch_decision`, SDK variant определяет request/notification routing вместо повторных raw-JSON predicates. Второй таблицы методов нет; registry остаётся policy gate revisions/capabilities/registered kind. Modern notification ACK по-прежнему предшествует request-only Mcp-Method/Mcp-Name checks и не обращается к sessions/domain. Params и ignored extensions/result/error остаются вне routing projection; SDK-incompatible числовые ID получают только внутренний surrogate, исходные ID/числовая форма остаются в raw message для wire/correlation/cancellation ownership. Для выбранного registry Ping handler typed projection использует canonical ping, сохраняя registered alias semantics. Runtime HTTP ATDD отдельно проверяет SDK decode/consumption и прежний JSON/SSE wire; affected registry/admission, durable initialized/reconnect, progress/cancel и auth guards проверяются без замены storage/transport. Это перенос только generic request/notification envelope routing: domain/generic handler execution, inbound response/error envelopes и их shape validation, session storage/TTL/reconnect, transport и feature qualification остаются вне среза. Полный #107 остаётся open; #108/4.7 и production switch не запускаются.
|
||||
@@ -61,6 +63,8 @@ Prompts handler-срез #107 на базе rc.33 заменяет прежни
|
||||
|
||||
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