diff --git a/crates/crank-community-mcp/src/app.rs b/crates/crank-community-mcp/src/app.rs index c864526..111f61f 100644 --- a/crates/crank-community-mcp/src/app.rs +++ b/crates/crank-community-mcp/src/app.rs @@ -41,6 +41,8 @@ mod rmcp_http; #[path = "rmcp_http_tests.rs"] mod rmcp_http_tests; mod rmcp_progress_cancel; +mod rmcp_prompts; +mod rmcp_prompts_projection; mod rmcp_resources; mod rmcp_resources_projection; #[cfg(test)] diff --git a/crates/crank-community-mcp/src/app/dispatch_observer.rs b/crates/crank-community-mcp/src/app/dispatch_observer.rs index 46fbc60..dbda35f 100644 --- a/crates/crank-community-mcp/src/app/dispatch_observer.rs +++ b/crates/crank-community-mcp/src/app/dispatch_observer.rs @@ -64,6 +64,10 @@ pub(crate) struct CounterSet { 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, @@ -95,6 +99,21 @@ pub(crate) struct CounterSet { } impl CounterSet { + 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) @@ -391,6 +410,26 @@ 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); diff --git a/crates/crank-community-mcp/src/app/response.rs b/crates/crank-community-mcp/src/app/response.rs index a55642f..747dc38 100644 --- a/crates/crank-community-mcp/src/app/response.rs +++ b/crates/crank-community-mcp/src/app/response.rs @@ -166,57 +166,13 @@ pub(super) fn resource_templates_list_result( 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, next_cursor: Option, ) -> Result { - let result = rmcp::model::ListPromptsResult { - prompts: prompts - .iter() - .cloned() - .map(serde_json::from_value) - .collect::, _>>()?, - 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) @@ -227,40 +183,8 @@ pub(super) fn prompt_get_result( description: Option, messages: Vec, ) -> Result { - let sdk_messages = messages - .iter() - .cloned() - .map(|mut message| { - if message["role"] == "system" { - message["role"] = json!("user"); - } - serde_json::from_value::(message) - }) - .collect::, _>>()?; - 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) diff --git a/crates/crank-community-mcp/src/app/rmcp_dispatch.rs b/crates/crank-community-mcp/src/app/rmcp_dispatch.rs index a931906..84b75c4 100644 --- a/crates/crank-community-mcp/src/app/rmcp_dispatch.rs +++ b/crates/crank-community-mcp/src/app/rmcp_dispatch.rs @@ -72,27 +72,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( diff --git a/crates/crank-community-mcp/src/app/rmcp_prompts.rs b/crates/crank-community-mcp/src/app/rmcp_prompts.rs new file mode 100644 index 0000000..39950c5 --- /dev/null +++ b/crates/crank-community-mcp/src/app/rmcp_prompts.rs @@ -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, +} +impl PromptScope { + fn new(context: ServiceContext<'_>, revision: &str, limit: Option) -> Self { + Self { + workspace_slug: context.workspace_slug.to_owned(), + agent_slug: context.agent_slug.to_owned(), + credential: context.credential.clone(), + correlation: context.correlation.clone(), + continuation: context.continuation, + locale: context.locale, + revision: revision.to_owned(), + limit, + } + } + fn context(&self) -> ServiceContext<'_> { + ServiceContext { + workspace_slug: &self.workspace_slug, + agent_slug: &self.agent_slug, + credential: &self.credential, + correlation: &self.correlation, + continuation: self.continuation, + locale: self.locale, + } + } +} + +enum ReplyExtras { + List(projection::Projection), + Get(projection::Projection), + DomainError(PromptsOutcome), +} +#[derive(Clone)] +struct PromptHandler { + state: Arc, + reply: Arc>>, + #[cfg(test)] + domain: Option>, +} +fn internal() -> ErrorData { + ErrorData::internal_error("prompt handler unavailable", None) +} + +impl PromptHandler { + fn new(state: &Arc) -> 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 { + self.reply.lock().ok()?.take() + } + fn scope(context: &RequestContext) -> Result { + context + .extensions + .get::() + .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 { + 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 { + 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, + context: RequestContext, + ) -> Result { + 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, + ) -> Result { + 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, ErrorData> { + let ping = + serde_json::from_value(serde_json::json!({"jsonrpc":"2.0", "id":1, "method":"ping"})) + .map_err(|_| internal())?; + let (transport, receiver) = rmcp::transport::OneshotTransport::::new(ping); + let revision = + serde_json::from_value(Value::String(scope.revision.clone())).map_err(|_| internal())?; + let info = InitializeRequestParams::new( + ClientCapabilities::default(), + Implementation::new("crank-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, +) -> 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, +) -> 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, + 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; diff --git a/crates/crank-community-mcp/src/app/rmcp_prompts_projection.rs b/crates/crank-community-mcp/src/app/rmcp_prompts_projection.rs new file mode 100644 index 0000000..77f8708 --- /dev/null +++ b/crates/crank-community-mcp/src/app/rmcp_prompts_projection.rs @@ -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 { + ::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, + absent: Vec, + children: Vec<(String, Projection)>, + identity: Map, + }, + Array(Vec), +} + +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 { + 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, +) -> 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, + 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 { + let mut result = serde_json::to_value(result)?; + extras.restore(result.get_mut(field).ok_or_else(invalid)?)?; + Ok(result) +} diff --git a/crates/crank-community-mcp/src/rmcp_prompts_handler_runtime_tests.rs b/crates/crank-community-mcp/src/rmcp_prompts_handler_runtime_tests.rs new file mode 100644 index 0000000..04186e0 --- /dev/null +++ b/crates/crank-community-mcp/src/rmcp_prompts_handler_runtime_tests.rs @@ -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); + } +} diff --git a/crates/crank-community-mcp/src/rmcp_prompts_handler_tests.rs b/crates/crank-community-mcp/src/rmcp_prompts_handler_tests.rs new file mode 100644 index 0000000..4c12ac4 --- /dev/null +++ b/crates/crank-community-mcp/src/rmcp_prompts_handler_tests.rs @@ -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>, + 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 { + 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, 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 { + 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 { + 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, 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, 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); + } +} diff --git a/crates/crank-community-mcp/src/rmcp_prompts_runtime_tests.rs b/crates/crank-community-mcp/src/rmcp_prompts_runtime_tests.rs index ba7833c..50e2b8e 100644 --- a/crates/crank-community-mcp/src/rmcp_prompts_runtime_tests.rs +++ b/crates/crank-community-mcp/src/rmcp_prompts_runtime_tests.rs @@ -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) -> 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:?}" diff --git a/crates/crank-community-mcp/src/rmcp_prompts_test_support.rs b/crates/crank-community-mcp/src/rmcp_prompts_test_support.rs index b67c344..6debffa 100644 --- a/crates/crank-community-mcp/src/rmcp_prompts_test_support.rs +++ b/crates/crank-community-mcp/src/rmcp_prompts_test_support.rs @@ -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 [ diff --git a/docs/development/rmcp-migration-plan.md b/docs/development/rmcp-migration-plan.md index 182b2bd..9b78aab 100644 --- a/docs/development/rmcp-migration-plan.md +++ b/docs/development/rmcp-migration-plan.md @@ -57,6 +57,8 @@ Envelope-dispatch-срез #107 на базе rc.30/rmcp3.9.0 подключае Inbound-response-срез #107 на базе rc.31/rmcp3.9.0 подключает no-method ветку общего envelope guard к `protocol/response_sdk.rs`: реальные `JsonRpcResponse`/`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. + Проверяемый результат: - Через SDK проходят действующие Tools, Resources, Prompts, completion, уведомления и подписки в применимых revisions, а также progress/cancel и существующая logging policy.