Merge pull request 'MCP: execute Prompts through request-scoped SDK handlers' (#137) from delivery/rmcp107-prompts-handlers into main
CI / UI Checks (push) Successful in 9s
CI / Rust Checks (push) Successful in 54m59s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 2s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 1h24m37s
CI / UI Checks (push) Successful in 9s
CI / Rust Checks (push) Successful in 54m59s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 2s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 1h24m37s
This commit was merged in pull request #137.
This commit is contained in:
commit
0139eeaac6
11 files changed
+1070
-108
No files matched your search
@@ -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)]
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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<Value>,
|
||||
next_cursor: Option<String>,
|
||||
) -> Result<Value, serde_json::Error> {
|
||||
let result = rmcp::model::ListPromptsResult {
|
||||
prompts: prompts
|
||||
.iter()
|
||||
.cloned()
|
||||
.map(serde_json::from_value)
|
||||
.collect::<Result<Vec<rmcp::model::Prompt>, _>>()?,
|
||||
next_cursor,
|
||||
result_type: None,
|
||||
ttl_ms: None,
|
||||
cache_scope: None,
|
||||
meta: None,
|
||||
};
|
||||
let mut result = serde_json::to_value(result)?;
|
||||
preserve_resource_fields(
|
||||
&prompts,
|
||||
&mut result["prompts"],
|
||||
&["name", "title", "description", "arguments", "_meta"],
|
||||
);
|
||||
for (raw, serialized) in prompts
|
||||
.iter()
|
||||
.zip(result["prompts"].as_array_mut().expect("SDK prompts"))
|
||||
{
|
||||
if let Some(arguments) = raw["arguments"].as_array() {
|
||||
preserve_resource_fields(
|
||||
arguments,
|
||||
&mut serialized["arguments"],
|
||||
&["name", "title", "description", "required"],
|
||||
);
|
||||
}
|
||||
}
|
||||
let (result, extras) = super::rmcp_prompts_projection::list(&prompts, next_cursor)?;
|
||||
let result = super::rmcp_prompts_projection::serialize(result, extras, "prompts")?;
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_prompts_list_result_serialized();
|
||||
Ok(result)
|
||||
@@ -227,40 +183,8 @@ pub(super) fn prompt_get_result(
|
||||
description: Option<String>,
|
||||
messages: Vec<Value>,
|
||||
) -> Result<Value, serde_json::Error> {
|
||||
let sdk_messages = messages
|
||||
.iter()
|
||||
.cloned()
|
||||
.map(|mut message| {
|
||||
if message["role"] == "system" {
|
||||
message["role"] = json!("user");
|
||||
}
|
||||
serde_json::from_value::<rmcp::model::PromptMessage>(message)
|
||||
})
|
||||
.collect::<Result<Vec<_>, _>>()?;
|
||||
let mut result = rmcp::model::GetPromptResult::new(sdk_messages);
|
||||
result.description = description;
|
||||
// Era-specific resultType/cache projection remains at the existing dispatch boundary.
|
||||
result.result_type = None;
|
||||
let mut result = serde_json::to_value(result)?;
|
||||
preserve_resource_fields(&messages, &mut result["messages"], &["role", "content"]);
|
||||
for (raw, serialized) in messages
|
||||
.iter()
|
||||
.zip(result["messages"].as_array_mut().expect("SDK messages"))
|
||||
{
|
||||
if raw["role"] == "system" {
|
||||
serialized["role"] = raw["role"].clone();
|
||||
}
|
||||
// Content extensions/optional nulls are opaque to the pinned SDK.
|
||||
let content = serialized["content"].as_object_mut().expect("SDK content");
|
||||
for (key, value) in raw["content"].as_object().expect("validated content") {
|
||||
if !content.contains_key(key)
|
||||
|| value.is_null()
|
||||
|| matches!(key.as_str(), "annotations" | "resource")
|
||||
{
|
||||
content.insert(key.clone(), value.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
let (result, extras) = super::rmcp_prompts_projection::get(description, &messages)?;
|
||||
let result = super::rmcp_prompts_projection::serialize(result, extras, "messages")?;
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_prompts_get_result_serialized();
|
||||
Ok(result)
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -0,0 +1,302 @@
|
||||
//! Request-owned Prompts trait adapter; domain execution stays in the parent HTTP future.
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use crank_core::{CorrelationContext, ExecutionLocale};
|
||||
use rmcp::{ErrorData, RoleServer, ServerHandler, model::*, service::RequestContext};
|
||||
use serde_json::Value;
|
||||
|
||||
use super::{AppState, rmcp_prompts_projection as projection};
|
||||
use crate::{
|
||||
auth::VerifiedMachineCredential,
|
||||
protocol::{
|
||||
self, ContinuationSupport, PromptGetCommand, PromptsCommand, PromptsListCommand,
|
||||
PromptsOutcome, ServiceContext,
|
||||
},
|
||||
};
|
||||
|
||||
#[derive(Clone)]
|
||||
struct PromptScope {
|
||||
workspace_slug: String,
|
||||
agent_slug: String,
|
||||
credential: VerifiedMachineCredential,
|
||||
correlation: CorrelationContext,
|
||||
continuation: ContinuationSupport,
|
||||
locale: ExecutionLocale,
|
||||
revision: String,
|
||||
limit: Option<usize>,
|
||||
}
|
||||
impl PromptScope {
|
||||
fn new(context: ServiceContext<'_>, revision: &str, limit: Option<usize>) -> Self {
|
||||
Self {
|
||||
workspace_slug: context.workspace_slug.to_owned(),
|
||||
agent_slug: context.agent_slug.to_owned(),
|
||||
credential: context.credential.clone(),
|
||||
correlation: context.correlation.clone(),
|
||||
continuation: context.continuation,
|
||||
locale: context.locale,
|
||||
revision: revision.to_owned(),
|
||||
limit,
|
||||
}
|
||||
}
|
||||
fn context(&self) -> ServiceContext<'_> {
|
||||
ServiceContext {
|
||||
workspace_slug: &self.workspace_slug,
|
||||
agent_slug: &self.agent_slug,
|
||||
credential: &self.credential,
|
||||
correlation: &self.correlation,
|
||||
continuation: self.continuation,
|
||||
locale: self.locale,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
enum ReplyExtras {
|
||||
List(projection::Projection),
|
||||
Get(projection::Projection),
|
||||
DomainError(PromptsOutcome),
|
||||
}
|
||||
#[derive(Clone)]
|
||||
struct PromptHandler {
|
||||
state: Arc<AppState>,
|
||||
reply: Arc<Mutex<Option<ReplyExtras>>>,
|
||||
#[cfg(test)]
|
||||
domain: Option<Arc<tests::Domain>>,
|
||||
}
|
||||
fn internal() -> ErrorData {
|
||||
ErrorData::internal_error("prompt handler unavailable", None)
|
||||
}
|
||||
|
||||
impl PromptHandler {
|
||||
fn new(state: &Arc<AppState>) -> Self {
|
||||
Self {
|
||||
state: state.clone(),
|
||||
reply: Arc::new(Mutex::new(None)),
|
||||
#[cfg(test)]
|
||||
domain: None,
|
||||
}
|
||||
}
|
||||
async fn execute(&self, scope: &PromptScope, command: PromptsCommand) -> PromptsOutcome {
|
||||
#[cfg(test)]
|
||||
if let Some(domain) = &self.domain {
|
||||
return domain.prompts(command).await;
|
||||
}
|
||||
protocol::handle_prompts_command(&self.state, scope.context(), &scope.revision, command)
|
||||
.await
|
||||
}
|
||||
fn save(&self, extras: ReplyExtras) -> Result<(), ErrorData> {
|
||||
let mut slot = self.reply.lock().map_err(|_| internal())?;
|
||||
if slot.is_some() {
|
||||
return Err(internal());
|
||||
}
|
||||
*slot = Some(extras);
|
||||
Ok(())
|
||||
}
|
||||
fn take(&self) -> Option<ReplyExtras> {
|
||||
self.reply.lock().ok()?.take()
|
||||
}
|
||||
fn scope(context: &RequestContext<RoleServer>) -> Result<PromptScope, ErrorData> {
|
||||
context
|
||||
.extensions
|
||||
.get::<PromptScope>()
|
||||
.cloned()
|
||||
.ok_or_else(internal)
|
||||
}
|
||||
fn domain_error(&self, outcome: PromptsOutcome) -> ErrorData {
|
||||
let error = match &outcome {
|
||||
PromptsOutcome::Listed { .. } | PromptsOutcome::Got { .. } => return internal(),
|
||||
PromptsOutcome::InvalidParams(detail) => {
|
||||
ErrorData::invalid_params(detail.clone(), None)
|
||||
}
|
||||
PromptsOutcome::NotAvailable => {
|
||||
ErrorData::invalid_params("the requested prompt is not available", None)
|
||||
}
|
||||
PromptsOutcome::ArgumentsRejected { .. } => {
|
||||
ErrorData::invalid_params("the prompt arguments were rejected", None)
|
||||
}
|
||||
_ => internal(),
|
||||
};
|
||||
if self.save(ReplyExtras::DomainError(outcome)).is_err() {
|
||||
return internal();
|
||||
}
|
||||
error
|
||||
}
|
||||
fn project_list(&self, outcome: PromptsOutcome) -> Result<ListPromptsResult, ErrorData> {
|
||||
match outcome {
|
||||
PromptsOutcome::Listed {
|
||||
prompts,
|
||||
next_cursor,
|
||||
} => {
|
||||
let (result, extras) =
|
||||
projection::list(&prompts, next_cursor).map_err(|_| internal())?;
|
||||
self.save(ReplyExtras::List(extras))?;
|
||||
Ok(result)
|
||||
}
|
||||
other => Err(self.domain_error(other)),
|
||||
}
|
||||
}
|
||||
fn project_get(&self, outcome: PromptsOutcome) -> Result<GetPromptResult, ErrorData> {
|
||||
match outcome {
|
||||
PromptsOutcome::Got {
|
||||
description,
|
||||
messages,
|
||||
} => {
|
||||
let (result, extras) =
|
||||
projection::get(description, &messages).map_err(|_| internal())?;
|
||||
self.save(ReplyExtras::Get(extras))?;
|
||||
Ok(result)
|
||||
}
|
||||
other => Err(self.domain_error(other)),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl ServerHandler for PromptHandler {
|
||||
async fn list_prompts(
|
||||
&self,
|
||||
request: Option<PaginatedRequestParams>,
|
||||
context: RequestContext<RoleServer>,
|
||||
) -> Result<ListPromptsResult, ErrorData> {
|
||||
let scope = Self::scope(&context)?;
|
||||
let command = PromptsCommand::List(PromptsListCommand {
|
||||
cursor: request.unwrap_or_default().cursor,
|
||||
limit: scope.limit,
|
||||
});
|
||||
let outcome = self.execute(&scope, command).await;
|
||||
let result = self.project_list(outcome);
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_prompts_list_handler_completed();
|
||||
result
|
||||
}
|
||||
async fn get_prompt(
|
||||
&self,
|
||||
request: GetPromptRequestParams,
|
||||
context: RequestContext<RoleServer>,
|
||||
) -> Result<GetPromptResponse, ErrorData> {
|
||||
let scope = Self::scope(&context)?;
|
||||
let command = PromptsCommand::Get(PromptGetCommand {
|
||||
name: request.name,
|
||||
arguments: request.arguments,
|
||||
});
|
||||
let outcome = self.execute(&scope, command).await;
|
||||
let result = self.project_get(outcome).map(Into::into);
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_prompts_get_handler_completed();
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
/// Public SDK context seed only; close the inert service before any domain execution.
|
||||
/// shortcut: the closed Peer cannot send callbacks, revisit if Prompts need peer messaging.
|
||||
async fn request_context(
|
||||
handler: &PromptHandler,
|
||||
scope: PromptScope,
|
||||
) -> Result<RequestContext<RoleServer>, ErrorData> {
|
||||
let ping =
|
||||
serde_json::from_value(serde_json::json!({"jsonrpc":"2.0", "id":1, "method":"ping"}))
|
||||
.map_err(|_| internal())?;
|
||||
let (transport, receiver) = rmcp::transport::OneshotTransport::<RoleServer>::new(ping);
|
||||
let revision =
|
||||
serde_json::from_value(Value::String(scope.revision.clone())).map_err(|_| internal())?;
|
||||
let info = InitializeRequestParams::new(
|
||||
ClientCapabilities::default(),
|
||||
Implementation::new("crank-prompt-context", "1"),
|
||||
)
|
||||
.with_protocol_version(revision);
|
||||
let mut running = rmcp::service::serve_directly(handler.clone(), transport, Some(info));
|
||||
let peer = running.peer().clone();
|
||||
running.close().await.map_err(|_| internal())?;
|
||||
drop(receiver);
|
||||
let mut context = RequestContext::new(RequestId::Number(1), peer);
|
||||
context.extensions.insert(scope);
|
||||
Ok(context)
|
||||
}
|
||||
fn restore_list(
|
||||
handler: &PromptHandler,
|
||||
result: Result<ListPromptsResult, ErrorData>,
|
||||
) -> PromptsOutcome {
|
||||
match (result, handler.take()) {
|
||||
(Ok(result), Some(ReplyExtras::List(extras))) => {
|
||||
let cursor = result.next_cursor.clone();
|
||||
match projection::serialize(result, extras, "prompts") {
|
||||
Ok(mut result) => match result["prompts"].take() {
|
||||
Value::Array(prompts) => PromptsOutcome::Listed {
|
||||
prompts,
|
||||
next_cursor: cursor,
|
||||
},
|
||||
_ => PromptsOutcome::CatalogUnavailable,
|
||||
},
|
||||
Err(_) => PromptsOutcome::CatalogUnavailable,
|
||||
}
|
||||
}
|
||||
(Err(_), Some(ReplyExtras::DomainError(error))) => error,
|
||||
_ => PromptsOutcome::CatalogUnavailable,
|
||||
}
|
||||
}
|
||||
fn restore_get(
|
||||
handler: &PromptHandler,
|
||||
result: Result<GetPromptResponse, ErrorData>,
|
||||
) -> PromptsOutcome {
|
||||
match (result, handler.take()) {
|
||||
(Ok(GetPromptResponse::Complete(result)), Some(ReplyExtras::Get(extras))) => {
|
||||
let description = result.description.clone();
|
||||
match projection::serialize(result, extras, "messages") {
|
||||
Ok(mut result) => match result["messages"].take() {
|
||||
Value::Array(messages) => PromptsOutcome::Got {
|
||||
description,
|
||||
messages,
|
||||
},
|
||||
_ => PromptsOutcome::CatalogUnavailable,
|
||||
},
|
||||
Err(_) => PromptsOutcome::CatalogUnavailable,
|
||||
}
|
||||
}
|
||||
(Err(_), Some(ReplyExtras::DomainError(error))) => error,
|
||||
_ => PromptsOutcome::CatalogUnavailable,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) async fn handle(
|
||||
state: &Arc<AppState>,
|
||||
context: ServiceContext<'_>,
|
||||
revision: &str,
|
||||
command: PromptsCommand,
|
||||
) -> PromptsOutcome {
|
||||
let limit = match &command {
|
||||
PromptsCommand::List(list) => list.limit,
|
||||
_ => None,
|
||||
};
|
||||
let handler = PromptHandler::new(state);
|
||||
let context = match request_context(&handler, PromptScope::new(context, revision, limit)).await
|
||||
{
|
||||
Ok(context) => context,
|
||||
Err(_) => return PromptsOutcome::CatalogUnavailable,
|
||||
};
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_prompts_dispatch_enter();
|
||||
match command {
|
||||
PromptsCommand::List(list) => {
|
||||
let result = ServerHandler::list_prompts(
|
||||
&handler,
|
||||
Some(PaginatedRequestParams::default().with_cursor(list.cursor)),
|
||||
context,
|
||||
)
|
||||
.await;
|
||||
let outcome = restore_list(&handler, result);
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_prompts_list_handler_consumed();
|
||||
outcome
|
||||
}
|
||||
PromptsCommand::Get(get) => {
|
||||
let mut request = GetPromptRequestParams::new(get.name);
|
||||
request.arguments = get.arguments;
|
||||
let result = ServerHandler::get_prompt(&handler, request, context).await;
|
||||
let outcome = restore_get(&handler, result);
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_prompts_get_handler_consumed();
|
||||
outcome
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "../rmcp_prompts_handler_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,194 @@
|
||||
//! Prompt-only lossless projection: SDK fields remain sourced from the actual trait result.
|
||||
use rmcp::model::{GetPromptResult, ListPromptsResult};
|
||||
use serde::Serialize;
|
||||
use serde_json::{Map, Value};
|
||||
|
||||
pub(super) fn invalid() -> serde_json::Error {
|
||||
<serde_json::Error as serde::de::Error>::custom("invalid prompt projection")
|
||||
}
|
||||
|
||||
// Store only differences from SDK serialization, not an alternate successful response.
|
||||
pub(super) enum Projection {
|
||||
Same,
|
||||
Opaque(Value),
|
||||
Object {
|
||||
extras: Map<String, Value>,
|
||||
absent: Vec<String>,
|
||||
children: Vec<(String, Projection)>,
|
||||
identity: Map<String, Value>,
|
||||
},
|
||||
Array(Vec<Projection>),
|
||||
}
|
||||
|
||||
impl Projection {
|
||||
fn between(raw: &Value, sdk: &Value) -> Self {
|
||||
match (raw, sdk) {
|
||||
(Value::Object(raw), Value::Object(sdk)) => {
|
||||
let extras = raw
|
||||
.iter()
|
||||
.filter(|(k, _)| !sdk.contains_key(*k))
|
||||
.map(|(k, v)| (k.clone(), v.clone()))
|
||||
.collect();
|
||||
let absent = sdk
|
||||
.keys()
|
||||
.filter(|k| !raw.contains_key(*k))
|
||||
.cloned()
|
||||
.collect();
|
||||
let children = raw
|
||||
.iter()
|
||||
.filter_map(|(k, v)| sdk.get(k).map(|s| (k.clone(), Self::between(v, s))))
|
||||
.collect();
|
||||
let identity = sdk
|
||||
.iter()
|
||||
.filter(|(k, _)| matches!(k.as_str(), "name" | "role" | "type" | "uri"))
|
||||
.map(|(k, v)| (k.clone(), v.clone()))
|
||||
.collect();
|
||||
Self::Object {
|
||||
extras,
|
||||
absent,
|
||||
children,
|
||||
identity,
|
||||
}
|
||||
}
|
||||
(Value::Array(raw), Value::Array(sdk)) => Self::Array(
|
||||
raw.iter()
|
||||
.zip(sdk)
|
||||
.map(|(r, s)| Self::between(r, s))
|
||||
.collect(),
|
||||
),
|
||||
_ if raw == sdk => Self::Same,
|
||||
_ => Self::Opaque(raw.clone()),
|
||||
}
|
||||
}
|
||||
|
||||
fn restore(self, sdk: &mut Value) -> Result<(), serde_json::Error> {
|
||||
match self {
|
||||
Self::Same => {}
|
||||
Self::Opaque(value) => *sdk = value,
|
||||
Self::Object {
|
||||
extras,
|
||||
absent,
|
||||
children,
|
||||
identity,
|
||||
} => {
|
||||
let object = sdk.as_object_mut().ok_or_else(invalid)?;
|
||||
if identity.iter().any(|(k, v)| object.get(k) != Some(v)) {
|
||||
return Err(invalid());
|
||||
}
|
||||
for (key, projection) in children {
|
||||
projection.restore(object.get_mut(&key).ok_or_else(invalid)?)?;
|
||||
}
|
||||
for key in absent {
|
||||
object.remove(&key);
|
||||
}
|
||||
object.extend(extras);
|
||||
}
|
||||
Self::Array(children) => {
|
||||
let array = sdk.as_array_mut().ok_or_else(invalid)?;
|
||||
if array.len() != children.len() {
|
||||
return Err(invalid());
|
||||
}
|
||||
for (projection, item) in children.into_iter().zip(array) {
|
||||
projection.restore(item)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn visible(raw: &Value, fields: &[&str]) -> Result<Value, serde_json::Error> {
|
||||
let raw = raw.as_object().ok_or_else(invalid)?;
|
||||
Ok(Value::Object(
|
||||
raw.iter()
|
||||
.filter(|(key, _)| fields.contains(&key.as_str()))
|
||||
.map(|(key, value)| (key.clone(), value.clone()))
|
||||
.collect(),
|
||||
))
|
||||
}
|
||||
|
||||
pub(super) fn list(
|
||||
prompts: &[Value],
|
||||
next_cursor: Option<String>,
|
||||
) -> Result<(ListPromptsResult, Projection), serde_json::Error> {
|
||||
let mut typed = Vec::with_capacity(prompts.len());
|
||||
for prompt in prompts {
|
||||
let mut prompt = visible(
|
||||
prompt,
|
||||
&["name", "title", "description", "arguments", "_meta"],
|
||||
)?;
|
||||
if let Some(Value::Array(arguments)) = prompt.get_mut("arguments") {
|
||||
for argument in arguments {
|
||||
*argument = visible(argument, &["name", "title", "description", "required"])?;
|
||||
}
|
||||
}
|
||||
typed.push(serde_json::from_value(prompt)?);
|
||||
}
|
||||
let result = ListPromptsResult {
|
||||
prompts: typed,
|
||||
next_cursor,
|
||||
result_type: None,
|
||||
ttl_ms: None,
|
||||
cache_scope: None,
|
||||
meta: None,
|
||||
};
|
||||
let extras = Projection::between(
|
||||
&Value::Array(prompts.to_vec()),
|
||||
&serde_json::to_value(&result)?["prompts"],
|
||||
);
|
||||
Ok((result, extras))
|
||||
}
|
||||
|
||||
pub(super) fn get(
|
||||
description: Option<String>,
|
||||
messages: &[Value],
|
||||
) -> Result<(GetPromptResult, Projection), serde_json::Error> {
|
||||
let mut typed = Vec::with_capacity(messages.len());
|
||||
for message in messages {
|
||||
let mut message = visible(message, &["role", "content"])?;
|
||||
if message["role"] == "system" {
|
||||
message["role"] = Value::String("user".into());
|
||||
}
|
||||
let content = message.get_mut("content").ok_or_else(invalid)?;
|
||||
// Opaque annotations and newly known SDK extensions must not add validation to Crank.
|
||||
let fields: &[&str] = match content["type"].as_str() {
|
||||
Some("text") => &["type", "text", "_meta"],
|
||||
Some("image" | "audio") => &["type", "data", "mimeType", "_meta"],
|
||||
Some("resource") => &["type", "resource", "_meta"],
|
||||
Some("resource_link") => &[
|
||||
"type",
|
||||
"uri",
|
||||
"name",
|
||||
"title",
|
||||
"description",
|
||||
"mimeType",
|
||||
"size",
|
||||
"_meta",
|
||||
],
|
||||
_ => return Err(invalid()),
|
||||
};
|
||||
*content = visible(content, fields)?;
|
||||
if let Some(resource) = content.get_mut("resource") {
|
||||
*resource = visible(resource, &["uri", "mimeType", "text", "blob", "_meta"])?;
|
||||
}
|
||||
typed.push(serde_json::from_value(message)?);
|
||||
}
|
||||
let mut result = GetPromptResult::new(typed);
|
||||
result.description = description;
|
||||
result.result_type = None;
|
||||
let extras = Projection::between(
|
||||
&Value::Array(messages.to_vec()),
|
||||
&serde_json::to_value(&result)?["messages"],
|
||||
);
|
||||
Ok((result, extras))
|
||||
}
|
||||
|
||||
pub(super) fn serialize(
|
||||
result: impl Serialize,
|
||||
extras: Projection,
|
||||
field: &str,
|
||||
) -> Result<Value, serde_json::Error> {
|
||||
let mut result = serde_json::to_value(result)?;
|
||||
extras.restore(result.get_mut(field).ok_or_else(invalid)?)?;
|
||||
Ok(result)
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
//! Handler completion/consumption is independent of the existing DTO wire oracle.
|
||||
use super::{CounterSet, observe, rmcp_prompts_runtime_tests::control, support::*};
|
||||
use std::sync::Arc;
|
||||
|
||||
pub(super) fn counts(c: &CounterSet) -> [usize; 4] {
|
||||
[
|
||||
c.sdk_prompts_list_handler_completed(),
|
||||
c.sdk_prompts_get_handler_completed(),
|
||||
c.sdk_prompts_list_handler_consumed(),
|
||||
c.sdk_prompts_get_handler_consumed(),
|
||||
]
|
||||
}
|
||||
|
||||
pub(super) fn delta(c: &CounterSet, before: [usize; 4], method: &str) -> ([usize; 4], [usize; 4]) {
|
||||
let after = counts(c);
|
||||
let expected = match method {
|
||||
"prompts/list" => [1, 0, 1, 0],
|
||||
"prompts/get" => [0, 1, 0, 1],
|
||||
_ => panic!("not a Prompts method: {method}"),
|
||||
};
|
||||
(std::array::from_fn(|i| after[i] - before[i]), expected)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_prompts_handler_legacy() {
|
||||
control(LEGACY_REVISION, true).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_prompts_handler_modern() {
|
||||
control(MODERN_REVISION, true).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_prompts_handler_observer_positive_control() {
|
||||
use super::{
|
||||
sdk_prompts_get_handler_completed, sdk_prompts_get_handler_consumed,
|
||||
sdk_prompts_list_handler_completed, sdk_prompts_list_handler_consumed,
|
||||
};
|
||||
let a = Arc::new(CounterSet::default());
|
||||
let b = Arc::new(CounterSet::default());
|
||||
sdk_prompts_list_handler_completed();
|
||||
sdk_prompts_get_handler_completed();
|
||||
sdk_prompts_list_handler_consumed();
|
||||
sdk_prompts_get_handler_consumed();
|
||||
assert_eq!(counts(&a), [0; 4], "no-scope markers must be no-ops");
|
||||
let snapshot = a.snapshot();
|
||||
tokio::join!(
|
||||
observe(a.clone(), async {
|
||||
sdk_prompts_list_handler_completed();
|
||||
tokio::task::yield_now().await;
|
||||
sdk_prompts_get_handler_completed();
|
||||
sdk_prompts_list_handler_consumed();
|
||||
sdk_prompts_get_handler_consumed();
|
||||
}),
|
||||
observe(b.clone(), async {
|
||||
sdk_prompts_get_handler_completed();
|
||||
tokio::task::yield_now().await;
|
||||
sdk_prompts_get_handler_consumed();
|
||||
}),
|
||||
);
|
||||
assert_eq!(counts(&a), [1; 4]);
|
||||
assert_eq!(counts(&b), [0, 1, 0, 1]);
|
||||
assert_eq!(a.snapshot(), snapshot);
|
||||
assert_eq!(b.snapshot(), CounterSet::default().snapshot());
|
||||
for c in [&a, &b] {
|
||||
assert_eq!(c.sdk_prompts_dispatch(), 0);
|
||||
assert_eq!(c.sdk_prompts_list_result(), 0);
|
||||
assert_eq!(c.sdk_prompts_get_result(), 0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,392 @@
|
||||
//! Synthetic replies exercise real trait results, restoration and structured cancellation.
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct Domain {
|
||||
outcome: Mutex<Option<PromptsOutcome>>,
|
||||
calls: AtomicUsize,
|
||||
pending: bool,
|
||||
started: tokio::sync::Notify,
|
||||
release: tokio::sync::Notify,
|
||||
dropped: AtomicBool,
|
||||
finished: AtomicBool,
|
||||
}
|
||||
struct DropWitness<'a>(&'a AtomicBool);
|
||||
impl Drop for DropWitness<'_> {
|
||||
fn drop(&mut self) {
|
||||
self.0.store(true, SeqCst);
|
||||
}
|
||||
}
|
||||
impl Domain {
|
||||
pub(super) async fn prompts(&self, command: PromptsCommand) -> PromptsOutcome {
|
||||
self.calls.fetch_add(1, SeqCst);
|
||||
match command {
|
||||
PromptsCommand::List(list) => {
|
||||
assert_eq!(list.limit, Some(7));
|
||||
assert_eq!(list.cursor.as_deref(), Some("opaque"));
|
||||
}
|
||||
PromptsCommand::Get(get) => {
|
||||
assert_eq!(get.name, "bound-prompt");
|
||||
assert_eq!(
|
||||
get.arguments,
|
||||
Some(
|
||||
json!({"number":42,"enabled":true,"nested":[null]})
|
||||
.as_object()
|
||||
.unwrap()
|
||||
.clone()
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
let _guard = DropWitness(&self.dropped);
|
||||
if self.pending {
|
||||
self.started.notify_one();
|
||||
self.release.notified().await;
|
||||
}
|
||||
self.finished.store(true, SeqCst);
|
||||
self.outcome
|
||||
.lock()
|
||||
.unwrap()
|
||||
.take()
|
||||
.expect("exactly one domain execution")
|
||||
}
|
||||
}
|
||||
fn scope(revision: &str) -> PromptScope {
|
||||
PromptScope {
|
||||
workspace_slug: "fresh-workspace".into(),
|
||||
agent_slug: "fresh-agent".into(),
|
||||
credential: VerifiedMachineCredential {
|
||||
machine_access_mode: crank_core::MachineAccessMode::StaticAgentKey,
|
||||
max_security_level: crank_core::OperationSecurityLevel::Standard,
|
||||
scopes: vec![crank_core::PlatformApiKeyScope::Read],
|
||||
platform_api_key_id: Some("fresh-key".into()),
|
||||
},
|
||||
correlation: CorrelationContext::generate(),
|
||||
continuation: ContinuationSupport::from_supported(false),
|
||||
locale: ExecutionLocale::En,
|
||||
revision: revision.into(),
|
||||
limit: Some(7),
|
||||
}
|
||||
}
|
||||
async fn state() -> Arc<AppState> {
|
||||
crank_test_support::postgres_schema_url_for_task("prompts_handler_local", "t_2d797361").await;
|
||||
super::super::rmcp_tools_tests::test_state().await
|
||||
}
|
||||
fn handler(state: &Arc<AppState>, outcome: PromptsOutcome) -> PromptHandler {
|
||||
let mut handler = PromptHandler::new(state);
|
||||
handler.domain = Some(Arc::new(Domain {
|
||||
outcome: Mutex::new(Some(outcome)),
|
||||
..Default::default()
|
||||
}));
|
||||
handler
|
||||
}
|
||||
fn page() -> Option<PaginatedRequestParams> {
|
||||
Some(PaginatedRequestParams::default().with_cursor(Some("opaque".into())))
|
||||
}
|
||||
fn get() -> GetPromptRequestParams {
|
||||
let mut request = GetPromptRequestParams::new("bound-prompt");
|
||||
request.arguments = Some(
|
||||
json!({"number":42,"enabled":true,"nested":[null]})
|
||||
.as_object()
|
||||
.unwrap()
|
||||
.clone(),
|
||||
);
|
||||
request
|
||||
}
|
||||
async fn context(handler: &PromptHandler, revision: &str) -> RequestContext<RoleServer> {
|
||||
let context = request_context(handler, scope(revision)).await.unwrap();
|
||||
assert!(context.peer.is_transport_closed());
|
||||
assert_eq!(
|
||||
Arc::strong_count(&handler.reply),
|
||||
1,
|
||||
"seed service released handler"
|
||||
);
|
||||
assert_eq!(handler.domain.as_ref().unwrap().calls.load(SeqCst), 0);
|
||||
let actual = PromptHandler::scope(&context).unwrap();
|
||||
assert_eq!(actual.workspace_slug, "fresh-workspace");
|
||||
assert_eq!(actual.agent_slug, "fresh-agent");
|
||||
assert_eq!(
|
||||
actual
|
||||
.credential
|
||||
.platform_api_key_id
|
||||
.as_ref()
|
||||
.map(|id| id.as_str()),
|
||||
Some("fresh-key")
|
||||
);
|
||||
assert_eq!(actual.revision, revision);
|
||||
context
|
||||
}
|
||||
fn assert_list(outcome: PromptsOutcome, raw: Vec<Value>, cursor: Option<&str>) {
|
||||
match outcome {
|
||||
PromptsOutcome::Listed {
|
||||
prompts,
|
||||
next_cursor,
|
||||
} => {
|
||||
assert_eq!(prompts, raw);
|
||||
assert_eq!(next_cursor.as_deref(), cursor);
|
||||
}
|
||||
_ => panic!("list restore failed"),
|
||||
}
|
||||
}
|
||||
fn assert_get(outcome: PromptsOutcome, raw: Vec<Value>, expected: Option<&str>) {
|
||||
match outcome {
|
||||
PromptsOutcome::Got {
|
||||
description,
|
||||
messages,
|
||||
} => {
|
||||
assert_eq!(messages, raw);
|
||||
assert_eq!(description.as_deref(), expected);
|
||||
}
|
||||
_ => panic!("get restore failed"),
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_prompts_trait_lossless_and_actual_typed_mutations_consumed() {
|
||||
let state = state().await;
|
||||
for revision in ["2025-11-25", "2026-07-28"] {
|
||||
let raw = vec![
|
||||
json!({"name":"a","description":null,"icons":{"not":"SDK array"},"annotations":false,"x":[null,{"nested":true}],"arguments":[{"name":"n","required":null,"description":null,"type":"integer","default":42,"enum":[1,42],"x":null}]}),
|
||||
json!({"name":"b","arguments":null}),
|
||||
json!({"name":"c"}),
|
||||
];
|
||||
let h = handler(
|
||||
&state,
|
||||
PromptsOutcome::Listed {
|
||||
prompts: raw.clone(),
|
||||
next_cursor: Some("next".into()),
|
||||
},
|
||||
);
|
||||
let c = context(&h, revision).await;
|
||||
let mut result = ServerHandler::list_prompts(&h, page(), c).await.unwrap();
|
||||
result.prompts[0].title = Some("typed-title".into());
|
||||
result.prompts[0].arguments.as_mut().unwrap()[0].title = Some("typed-argument".into());
|
||||
result.next_cursor = Some("typed-cursor".into());
|
||||
let mut expected = raw;
|
||||
expected[0]["title"] = json!("typed-title");
|
||||
expected[0]["arguments"][0]["title"] = json!("typed-argument");
|
||||
assert_list(restore_list(&h, Ok(result)), expected, Some("typed-cursor"));
|
||||
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
|
||||
let text = serde_json::to_string_pretty(&json!({"exact":[null,true]})).unwrap();
|
||||
let raw = vec![
|
||||
json!({"role":"system","content":{"type":"text","text":text,"annotations":[null,42],"x":null},"x":{"nested":true}}),
|
||||
json!({"role":"user","content":{"type":"image","data":"AAEC/w==","mimeType":"image/png","annotations":false,"x":[1,null]}}),
|
||||
json!({"role":"assistant","content":{"type":"audio","data":"AAEC/w==","mimeType":"audio/wav"}}),
|
||||
json!({"role":"user","content":{"type":"resource","resource":{"uri":"crank://text","text":"exact\nbytes","mimeType":null,"x":[null]},"annotations":{"arbitrary":true}}}),
|
||||
json!({"role":"user","content":{"type":"resource","resource":{"uri":"crank://blob","blob":"AAEC/w==","x":false},"x":null}}),
|
||||
json!({"role":"user","content":{"type":"resource_link","uri":"crank://link","name":"link","description":null,"icons":false,"annotations":42,"x":{"a":null}}}),
|
||||
];
|
||||
let h = handler(
|
||||
&state,
|
||||
PromptsOutcome::Got {
|
||||
description: None,
|
||||
messages: raw.clone(),
|
||||
},
|
||||
);
|
||||
let c = context(&h, revision).await;
|
||||
let GetPromptResponse::Complete(mut result) =
|
||||
ServerHandler::get_prompt(&h, get(), c).await.unwrap()
|
||||
else {
|
||||
panic!("expected complete prompt")
|
||||
};
|
||||
result.description = Some("typed-description".into());
|
||||
// Content is mutated through the SDK result, not the original domain JSON.
|
||||
let mut message = serde_json::to_value(&result.messages[0]).unwrap();
|
||||
message["content"]["text"] = json!("typed-text");
|
||||
result.messages[0] = serde_json::from_value(message).unwrap();
|
||||
let mut expected = raw;
|
||||
expected[0]["content"]["text"] = json!("typed-text");
|
||||
assert_get(
|
||||
restore_get(&h, Ok(result.into())),
|
||||
expected,
|
||||
Some("typed-description"),
|
||||
);
|
||||
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
|
||||
let h = handler(
|
||||
&state,
|
||||
PromptsOutcome::Got {
|
||||
description: None,
|
||||
messages: vec![],
|
||||
},
|
||||
);
|
||||
let c = context(&h, revision).await;
|
||||
let result = ServerHandler::get_prompt(&h, get(), c).await;
|
||||
assert_get(restore_get(&h, result), vec![], None);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_prompts_trait_errors_fail_closed_without_reexecution() {
|
||||
let state = state().await;
|
||||
for is_list in [true, false] {
|
||||
for outcome in [
|
||||
PromptsOutcome::InvalidParams("exact-detail".into()),
|
||||
PromptsOutcome::NotAvailable,
|
||||
PromptsOutcome::ArgumentsRejected {
|
||||
reason: "wrong_type",
|
||||
argument: Some("number".into()),
|
||||
},
|
||||
PromptsOutcome::ArgumentsRejected {
|
||||
reason: "missing",
|
||||
argument: None,
|
||||
},
|
||||
PromptsOutcome::DependencyUnavailable { position: 13 },
|
||||
PromptsOutcome::CatalogUnavailable,
|
||||
] {
|
||||
let expected = std::mem::discriminant(&outcome);
|
||||
let h = handler(&state, outcome);
|
||||
let c = context(&h, "2026-07-28").await;
|
||||
let actual = if is_list {
|
||||
let result = ServerHandler::list_prompts(&h, page(), c).await;
|
||||
assert!(result.is_err());
|
||||
restore_list(&h, result)
|
||||
} else {
|
||||
let result = ServerHandler::get_prompt(&h, get(), c).await;
|
||||
assert!(result.is_err());
|
||||
restore_get(&h, result)
|
||||
};
|
||||
assert_eq!(std::mem::discriminant(&actual), expected);
|
||||
match actual {
|
||||
PromptsOutcome::InvalidParams(detail) => assert_eq!(detail, "exact-detail"),
|
||||
PromptsOutcome::ArgumentsRejected { reason, argument } => {
|
||||
assert_eq!(
|
||||
reason,
|
||||
if argument.is_some() {
|
||||
"wrong_type"
|
||||
} else {
|
||||
"missing"
|
||||
}
|
||||
);
|
||||
if let Some(argument) = argument {
|
||||
assert_eq!(argument, "number");
|
||||
}
|
||||
}
|
||||
PromptsOutcome::DependencyUnavailable { position } => assert_eq!(position, 13),
|
||||
_ => {}
|
||||
}
|
||||
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
|
||||
}
|
||||
}
|
||||
let h = handler(
|
||||
&state,
|
||||
PromptsOutcome::Listed {
|
||||
prompts: vec![json!({"description":"missing name"})],
|
||||
next_cursor: None,
|
||||
},
|
||||
);
|
||||
let c = context(&h, "2026-07-28").await;
|
||||
let result = ServerHandler::list_prompts(&h, page(), c).await;
|
||||
assert!(result.is_err());
|
||||
assert!(matches!(
|
||||
restore_list(&h, result),
|
||||
PromptsOutcome::CatalogUnavailable
|
||||
));
|
||||
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
|
||||
for message in [
|
||||
json!({"role":"invalid","content":{"type":"text","text":"x"}}),
|
||||
json!({"role":"user","content":{"type":"text"}}),
|
||||
] {
|
||||
let h = handler(
|
||||
&state,
|
||||
PromptsOutcome::Got {
|
||||
description: None,
|
||||
messages: vec![message],
|
||||
},
|
||||
);
|
||||
let c = context(&h, "2026-07-28").await;
|
||||
let result = ServerHandler::get_prompt(&h, get(), c).await;
|
||||
assert!(result.is_err());
|
||||
assert!(matches!(
|
||||
restore_get(&h, result),
|
||||
PromptsOutcome::CatalogUnavailable
|
||||
));
|
||||
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
|
||||
}
|
||||
for change in 0..3 {
|
||||
let h = handler(
|
||||
&state,
|
||||
PromptsOutcome::Listed {
|
||||
prompts: vec![json!({"name":"a","x":1}), json!({"name":"b","x":2})],
|
||||
next_cursor: None,
|
||||
},
|
||||
);
|
||||
let mut c = context(&h, "2026-07-28").await;
|
||||
c.extensions = Default::default();
|
||||
assert!(ServerHandler::list_prompts(&h, page(), c).await.is_err());
|
||||
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 0);
|
||||
let c = context(&h, "2026-07-28").await;
|
||||
let mut result = ServerHandler::list_prompts(&h, page(), c).await.unwrap();
|
||||
let result = match change {
|
||||
0 => {
|
||||
result.prompts.clear();
|
||||
Ok(result)
|
||||
}
|
||||
1 => {
|
||||
result.prompts.swap(0, 1);
|
||||
Ok(result)
|
||||
}
|
||||
_ => Err(internal()),
|
||||
};
|
||||
assert!(matches!(
|
||||
restore_list(&h, result),
|
||||
PromptsOutcome::CatalogUnavailable
|
||||
));
|
||||
assert_eq!(h.domain.as_ref().unwrap().calls.load(SeqCst), 1);
|
||||
}
|
||||
let h = handler(
|
||||
&state,
|
||||
PromptsOutcome::Got {
|
||||
description: None,
|
||||
messages: vec![],
|
||||
},
|
||||
);
|
||||
let c = context(&h, "2026-07-28").await;
|
||||
let result = ServerHandler::list_prompts(&h, page(), c).await;
|
||||
assert!(result.is_err());
|
||||
assert!(matches!(
|
||||
restore_list(&h, result),
|
||||
PromptsOutcome::CatalogUnavailable
|
||||
));
|
||||
assert!(matches!(
|
||||
restore_get(&h, Err(internal())),
|
||||
PromptsOutcome::CatalogUnavailable
|
||||
));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rmcp_prompts_parent_drop_cancels_domain_and_bootstrap_is_closed() {
|
||||
let state = state().await;
|
||||
for is_list in [true, false] {
|
||||
let mut h = PromptHandler::new(&state);
|
||||
let domain = Arc::new(Domain {
|
||||
pending: true,
|
||||
..Default::default()
|
||||
});
|
||||
h.domain = Some(domain.clone());
|
||||
let c = context(&h, "2026-07-28").await;
|
||||
let mut parent = Box::pin(async {
|
||||
if is_list {
|
||||
let result = ServerHandler::list_prompts(&h, page(), c).await;
|
||||
restore_list(&h, result)
|
||||
} else {
|
||||
let result = ServerHandler::get_prompt(&h, get(), c).await;
|
||||
restore_get(&h, result)
|
||||
}
|
||||
});
|
||||
tokio::select! { _ = &mut parent => panic!("domain should wait"), _ = domain.started.notified() => {} }
|
||||
assert!(!domain.dropped.load(SeqCst));
|
||||
drop(parent);
|
||||
assert!(
|
||||
domain.dropped.load(SeqCst),
|
||||
"domain future dropped synchronously with parent"
|
||||
);
|
||||
domain.release.notify_one();
|
||||
tokio::task::yield_now().await;
|
||||
assert!(!domain.finished.load(SeqCst), "no detached continuation");
|
||||
assert!(h.take().is_none());
|
||||
assert_eq!(domain.calls.load(SeqCst), 1);
|
||||
assert_eq!(Arc::strong_count(&domain), 2);
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@ use serde_json::{Value, json};
|
||||
use std::{sync::Arc, time::Duration};
|
||||
#[path = "rmcp_prompts_test_support.rs"]
|
||||
mod fixtures;
|
||||
use super::rmcp_prompts_handler_runtime_tests as handler;
|
||||
use fixtures::Endpoint;
|
||||
|
||||
fn observe_body(response: Response, counters: Arc<CounterSet>) -> Response {
|
||||
@@ -111,11 +112,15 @@ async fn success(
|
||||
std::array::from_fn(|i| after[i] - before[i]),
|
||||
)
|
||||
}
|
||||
async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
|
||||
pub(super) async fn control(
|
||||
revision: &str,
|
||||
require_handler: bool,
|
||||
) -> Vec<([usize; 3], [usize; 3])> {
|
||||
let h = Endpoint::started().await;
|
||||
let session = h.session(revision).await;
|
||||
let session = session.as_deref();
|
||||
let mut deltas = Vec::new();
|
||||
let mut handlers = Vec::new();
|
||||
let mut first_cursor = None;
|
||||
// Both revisions' JSON contract, plus modern terminal SSE through the same normal app.
|
||||
let modes: &[bool] = if revision == MODERN_REVISION {
|
||||
@@ -130,7 +135,9 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
|
||||
if let Some(ref cursor) = cursor {
|
||||
params["cursor"] = json!(cursor);
|
||||
}
|
||||
let before = handler::counts(&h.counters);
|
||||
let (result, delta) = success(&h, revision, session, "prompts/list", params, sse).await;
|
||||
handlers.push(handler::delta(&h.counters, before, "prompts/list"));
|
||||
let prompts = result["prompts"].as_array().unwrap();
|
||||
assert_eq!(prompts.len(), 1, "{result}");
|
||||
assert_eq!(
|
||||
@@ -174,6 +181,7 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
|
||||
] {
|
||||
let mut previous = None;
|
||||
for _ in 0..2 {
|
||||
let before = handler::counts(&h.counters);
|
||||
let (result, delta) = success(
|
||||
&h,
|
||||
revision,
|
||||
@@ -183,6 +191,7 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
|
||||
sse,
|
||||
)
|
||||
.await;
|
||||
handlers.push(handler::delta(&h.counters, before, "prompts/get"));
|
||||
assert_eq!(result["description"], format!("Published {name}"));
|
||||
assert_eq!(
|
||||
result["messages"],
|
||||
@@ -232,7 +241,9 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
|
||||
"prompts/get",
|
||||
json!({"name":"greeting","arguments":arguments}),
|
||||
);
|
||||
let before = handler::counts(&h.counters);
|
||||
let body = wire(h.post(revision, session, &req, sse).await, &req["id"], sse).await;
|
||||
handlers.push(handler::delta(&h.counters, before, "prompts/get"));
|
||||
assert_eq!(body["error"]["code"], -32602, "{body}");
|
||||
assert_eq!(body["error"]["data"]["reason"], reason, "{body}");
|
||||
assert_eq!(body["error"]["data"]["argument"], argument);
|
||||
@@ -255,7 +266,9 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
|
||||
"prm_a",
|
||||
] {
|
||||
let req = request(revision, "prompts/get", json!({"name":name}));
|
||||
let before = handler::counts(&h.counters);
|
||||
let body = wire(h.post(revision, session, &req, sse).await, &req["id"], sse).await;
|
||||
handlers.push(handler::delta(&h.counters, before, "prompts/get"));
|
||||
assert_eq!(body["error"]["code"], -32602, "{body}");
|
||||
assert_eq!(
|
||||
body["error"]["message"],
|
||||
@@ -269,7 +282,8 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
|
||||
}
|
||||
}
|
||||
for params in [json!({"cursor":"invalid"}), json!({"limit":"invalid"})] {
|
||||
let req = request(revision, "prompts/list", params);
|
||||
let before = handler::counts(&h.counters);
|
||||
let req = request(revision, "prompts/list", params.clone());
|
||||
let body = wire(
|
||||
h.post(revision, session, &req, false).await,
|
||||
&req["id"],
|
||||
@@ -277,6 +291,15 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
|
||||
)
|
||||
.await;
|
||||
assert_eq!(body["error"]["code"], -32602, "{body}");
|
||||
if params.get("cursor").is_some() {
|
||||
handlers.push(handler::delta(&h.counters, before, "prompts/list"));
|
||||
} else {
|
||||
assert_eq!(
|
||||
handler::counts(&h.counters),
|
||||
before,
|
||||
"parsing rejects must not enter handlers"
|
||||
);
|
||||
}
|
||||
}
|
||||
let other = if revision == MODERN_REVISION {
|
||||
LEGACY_REVISION
|
||||
@@ -345,6 +368,27 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
|
||||
),
|
||||
"{binding:?}"
|
||||
);
|
||||
sqlx::query(
|
||||
"update platform_api_keys set scopes_json = '[]'::jsonb where id = 'pk_dispatch_observer'",
|
||||
)
|
||||
.execute(h.registry.pool())
|
||||
.await
|
||||
.unwrap();
|
||||
for (method, params) in [
|
||||
("prompts/list", json!({})),
|
||||
("prompts/get", json!({"name":"greeting"})),
|
||||
] {
|
||||
let before = handler::counts(&h.counters);
|
||||
let req = request(revision, method, params);
|
||||
assert_eq!(h.post(revision, session, &req, false).await.status(), 403);
|
||||
assert_eq!(
|
||||
handler::counts(&h.counters),
|
||||
before,
|
||||
"scope rejects must precede handlers"
|
||||
);
|
||||
}
|
||||
sqlx::query("update platform_api_keys set scopes_json = '[\"read\",\"write\"]'::jsonb where id = 'pk_dispatch_observer'")
|
||||
.execute(h.registry.pool()).await.unwrap();
|
||||
h.registry
|
||||
.revoke_platform_api_key(
|
||||
&workspace_id(),
|
||||
@@ -360,29 +404,41 @@ async fn control(revision: &str) -> Vec<([usize; 3], [usize; 3])> {
|
||||
json!({"name":"greeting","arguments":{"name":"Ada"}}),
|
||||
),
|
||||
] {
|
||||
let before = handler::counts(&h.counters);
|
||||
assert_eq!(
|
||||
h.post(revision, session, &request(revision, method, params), false)
|
||||
.await
|
||||
.status(),
|
||||
401
|
||||
);
|
||||
assert_eq!(
|
||||
handler::counts(&h.counters),
|
||||
before,
|
||||
"revocation must precede handlers"
|
||||
);
|
||||
}
|
||||
eprintln!(
|
||||
"existing GREEN Prompts wire {revision}: populated pagination, typed metadata/values, exact immutable rendering, archive, structured refusals/non-disclosure, correlation/ID/cache, revoked401; SDK actual/expected={deltas:?}"
|
||||
);
|
||||
if require_handler {
|
||||
assert!(
|
||||
handlers.iter().all(|(actual, expected)| actual == expected),
|
||||
"SDK Prompts handler completion/consumption missing after successful HTTP wire/error/guard checks: {handlers:?}"
|
||||
);
|
||||
}
|
||||
deltas
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_prompts_wire_legacy() {
|
||||
control(LEGACY_REVISION).await;
|
||||
control(LEGACY_REVISION, false).await;
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_prompts_wire_modern() {
|
||||
control(MODERN_REVISION).await;
|
||||
control(MODERN_REVISION, false).await;
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_prompts_sdk_legacy() {
|
||||
let deltas = control(LEGACY_REVISION).await;
|
||||
let deltas = control(LEGACY_REVISION, false).await;
|
||||
assert!(
|
||||
deltas.iter().all(|(a, e)| a == e),
|
||||
"SDK typed dispatch/result missing after successful HTTP: {deltas:?}"
|
||||
@@ -390,7 +446,7 @@ async fn rmcp_prompts_sdk_legacy() {
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_prompts_sdk_modern() {
|
||||
let deltas = control(MODERN_REVISION).await;
|
||||
let deltas = control(MODERN_REVISION, false).await;
|
||||
assert!(
|
||||
deltas.iter().all(|(a, e)| a == e),
|
||||
"SDK typed dispatch/result missing after successful HTTP: {deltas:?}"
|
||||
|
||||
@@ -39,7 +39,7 @@ impl Drop for Endpoint {
|
||||
}
|
||||
impl Endpoint {
|
||||
pub async fn started() -> Self {
|
||||
crank_test_support::postgres_schema_url_for_task("prompts_owner", "t_160a763a").await;
|
||||
crank_test_support::postgres_schema_url_for_task("prompts_handler", "t_7afaaafe").await;
|
||||
let registry = test_registry().await;
|
||||
let mut archived_at = test_time();
|
||||
for (id, name, publish) in [
|
||||
|
||||
@@ -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<Value>`/`JsonRpcError` определяют response classification и ранний HTTP202 ACK штатного `build_app` POST обеих revisions. Сохранены object-only result без обязательного resultType, exclusivity result/error, optional error id, произвольные data/params/extensions и любые JSON number id/code; только SDK-несовместимые числа получают внутренние surrogates после проверки исходного wire-предиката, raw message не меняется. Заменён handwritten response classifier/error-object parser. Обнаруженный ATDD обход credentials ранним ACK устранён свежей read-авторизацией no-method сообщений до SDK decode; порядок method-bearing запросов не меняется. Origin/Accept/ambiguous carrier checks предшествуют decode/ACK, ACK остаётся до era/session resolution без session/domain вызовов. HTTP wire и SDK decoded/consumed oracles проверяются отдельно. Domain/generic handler execution, session storage/TTL/reconnect, transport и feature qualification остаются вне среза; полный #107 остаётся open, #108/4.7/production не запускаются.
|
||||
|
||||
Prompts handler-срез #107 на базе rc.33 заменяет прежний DTO-only shim настоящими `ServerHandler::list_prompts/get_prompt` в `app/rmcp_prompts.rs`. Уже подключённый потребитель — `build_app` → обе HTTP dispatch-ветки → `rmcp_dispatch::handle_prompts_command`. Overrides напрямую await-ят прежний domain service ровно один раз; caller потребляет actual typed SDK Result, а request-local projection восстанавливает только непредставимые поля/omissions. Инертный ping-bootstrap закрывается до domain execution; domain future остаётся в parent HTTP future и отменяется при drop. Closed Peer не поддерживает callbacks. HTTP handler completed/consumed ATDD обеих revisions и trait-result mutation/drop regressions подтверждают реальное исполнение, прежние wire/access/error boundaries и lossless content; affected Prompts integration проверяет pinned static/dynamic Resource composition и dependency errors. Domain/auth/storage/session/transport не меняются. Это не завершение #107, feature qualification или разрешение #108/4.7/production.
|
||||
|
||||
Проверяемый результат:
|
||||
|
||||
- Через SDK проходят действующие Tools, Resources, Prompts, completion, уведомления и подписки в применимых revisions, а также progress/cancel и существующая logging policy.
|
||||
|
||||
Reference in new issue
Block a user