feat: mcp sdk conformance (#687)
* adds conformance server and client * adds results from initial run of https://github.com/modelcontextprotocol/conformance/tree/main/.claude/skills/mcp-sdk-tier-audit skill * various small changes applied during the testing loop Co-authored-by: Dale Seo <5466341+DaleSeo@users.noreply.github.com>
This commit is contained in:
Alex Hancock
GitHub
parent
b967c132ae
commit
a7e4ae3203
2 changed files with 2392 additions and 10 deletions
987
conformance/src/bin/client.rs
Normal file
987
conformance/src/bin/client.rs
Normal file
|
|
@ -0,0 +1,987 @@
|
|||
use std::future::Future;
|
||||
|
||||
use rmcp::{
|
||||
ClientHandler, ErrorData, RoleClient, ServiceExt,
|
||||
model::*,
|
||||
service::RequestContext,
|
||||
transport::{
|
||||
AuthClient, AuthorizationManager, StreamableHttpClientTransport,
|
||||
auth::{OAuthClientConfig, OAuthState},
|
||||
streamable_http_client::StreamableHttpClientTransportConfig,
|
||||
},
|
||||
};
|
||||
use serde_json::{Value, json};
|
||||
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
|
||||
|
||||
// ─── Context parsed from MCP_CONFORMANCE_CONTEXT ────────────────────────────
|
||||
|
||||
#[derive(Debug, Default, serde::Deserialize)]
|
||||
struct ConformanceContext {
|
||||
#[serde(default)]
|
||||
name: Option<String>,
|
||||
// pre-registration / client-credentials-basic
|
||||
#[serde(default)]
|
||||
client_id: Option<String>,
|
||||
#[serde(default)]
|
||||
client_secret: Option<String>,
|
||||
// client-credentials-jwt
|
||||
#[serde(default)]
|
||||
private_key_pem: Option<String>,
|
||||
#[serde(default)]
|
||||
signing_algorithm: Option<String>,
|
||||
// cross-app-access
|
||||
#[serde(default)]
|
||||
idp_client_id: Option<String>,
|
||||
#[serde(default)]
|
||||
idp_id_token: Option<String>,
|
||||
#[serde(default)]
|
||||
idp_issuer: Option<String>,
|
||||
#[serde(default)]
|
||||
idp_token_endpoint: Option<String>,
|
||||
}
|
||||
|
||||
fn load_context() -> ConformanceContext {
|
||||
std::env::var("MCP_CONFORMANCE_CONTEXT")
|
||||
.ok()
|
||||
.and_then(|s| serde_json::from_str(&s).ok())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
// ─── Client handlers ────────────────────────────────────────────────────────
|
||||
|
||||
/// A basic client handler that does nothing special
|
||||
struct BasicClientHandler;
|
||||
impl ClientHandler for BasicClientHandler {}
|
||||
|
||||
/// A client handler that handles elicitation requests by applying schema defaults.
|
||||
struct ElicitationDefaultsClientHandler;
|
||||
|
||||
impl ClientHandler for ElicitationDefaultsClientHandler {
|
||||
fn get_info(&self) -> ClientInfo {
|
||||
let mut info = ClientInfo::default();
|
||||
info.capabilities.elicitation = Some(ElicitationCapability {
|
||||
form: Some(FormElicitationCapability {
|
||||
schema_validation: Some(true),
|
||||
}),
|
||||
url: None,
|
||||
});
|
||||
info
|
||||
}
|
||||
|
||||
fn create_elicitation(
|
||||
&self,
|
||||
request: CreateElicitationRequestParams,
|
||||
_cx: RequestContext<RoleClient>,
|
||||
) -> impl Future<Output = Result<CreateElicitationResult, ErrorData>> + Send + '_ {
|
||||
async move {
|
||||
let content = match &request {
|
||||
CreateElicitationRequestParams::FormElicitationParams {
|
||||
requested_schema, ..
|
||||
} => {
|
||||
let mut defaults = serde_json::Map::new();
|
||||
for (name, prop) in &requested_schema.properties {
|
||||
match prop {
|
||||
PrimitiveSchema::String(s) => {
|
||||
if let Some(d) = &s.default {
|
||||
defaults.insert(name.clone(), Value::String(d.clone()));
|
||||
}
|
||||
}
|
||||
PrimitiveSchema::Number(n) => {
|
||||
if let Some(d) = n.default {
|
||||
defaults.insert(name.clone(), json!(d));
|
||||
}
|
||||
}
|
||||
PrimitiveSchema::Integer(i) => {
|
||||
if let Some(d) = i.default {
|
||||
defaults.insert(name.clone(), json!(d));
|
||||
}
|
||||
}
|
||||
PrimitiveSchema::Boolean(b) => {
|
||||
if let Some(d) = b.default {
|
||||
defaults.insert(name.clone(), Value::Bool(d));
|
||||
}
|
||||
}
|
||||
PrimitiveSchema::Enum(e) => {
|
||||
let val = match e {
|
||||
EnumSchema::Single(SingleSelectEnumSchema::Untitled(u)) => {
|
||||
u.default.as_ref().map(|d| Value::String(d.clone()))
|
||||
}
|
||||
EnumSchema::Single(SingleSelectEnumSchema::Titled(t)) => {
|
||||
t.default.as_ref().map(|d| Value::String(d.clone()))
|
||||
}
|
||||
EnumSchema::Multi(MultiSelectEnumSchema::Untitled(u)) => {
|
||||
u.default.as_ref().map(|d| {
|
||||
Value::Array(
|
||||
d.iter()
|
||||
.map(|s| Value::String(s.clone()))
|
||||
.collect(),
|
||||
)
|
||||
})
|
||||
}
|
||||
EnumSchema::Multi(MultiSelectEnumSchema::Titled(t)) => {
|
||||
t.default.as_ref().map(|d| {
|
||||
Value::Array(
|
||||
d.iter()
|
||||
.map(|s| Value::String(s.clone()))
|
||||
.collect(),
|
||||
)
|
||||
})
|
||||
}
|
||||
EnumSchema::Legacy(_) => None,
|
||||
};
|
||||
if let Some(v) = val {
|
||||
defaults.insert(name.clone(), v);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(Value::Object(defaults))
|
||||
}
|
||||
_ => Some(json!({})),
|
||||
};
|
||||
Ok(CreateElicitationResult {
|
||||
action: ElicitationAction::Accept,
|
||||
content,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A client handler that handles both sampling and elicitation
|
||||
struct FullClientHandler;
|
||||
|
||||
impl ClientHandler for FullClientHandler {
|
||||
fn get_info(&self) -> ClientInfo {
|
||||
let mut info = ClientInfo::default();
|
||||
info.capabilities.elicitation = Some(ElicitationCapability {
|
||||
form: Some(FormElicitationCapability {
|
||||
schema_validation: Some(true),
|
||||
}),
|
||||
url: None,
|
||||
});
|
||||
info
|
||||
}
|
||||
|
||||
fn create_message(
|
||||
&self,
|
||||
params: CreateMessageRequestParams,
|
||||
_cx: RequestContext<RoleClient>,
|
||||
) -> impl Future<Output = Result<CreateMessageResult, ErrorData>> + Send + '_ {
|
||||
async move {
|
||||
let prompt_text = params
|
||||
.messages
|
||||
.first()
|
||||
.and_then(|m| m.content.first())
|
||||
.and_then(|c| c.as_text())
|
||||
.map(|t| t.text.clone())
|
||||
.unwrap_or_default();
|
||||
Ok(CreateMessageResult {
|
||||
message: SamplingMessage::new(
|
||||
Role::Assistant,
|
||||
SamplingMessageContent::text(format!(
|
||||
"This is a mock LLM response to: {}",
|
||||
prompt_text
|
||||
)),
|
||||
),
|
||||
model: "mock-model".into(),
|
||||
stop_reason: Some("endTurn".into()),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn create_elicitation(
|
||||
&self,
|
||||
_request: CreateElicitationRequestParams,
|
||||
_cx: RequestContext<RoleClient>,
|
||||
) -> impl Future<Output = Result<CreateElicitationResult, ErrorData>> + Send + '_ {
|
||||
async move {
|
||||
Ok(CreateElicitationResult {
|
||||
action: ElicitationAction::Accept,
|
||||
content: Some(json!({"username": "testuser", "email": "test@example.com"})),
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ─── OAuth helpers ──────────────────────────────────────────────────────────
|
||||
|
||||
const CIMD_CLIENT_METADATA_URL: &str = "https://conformance-test.local/client-metadata.json";
|
||||
const REDIRECT_URI: &str = "http://localhost:3000/callback";
|
||||
|
||||
/// Perform the headless OAuth authorization-code flow.
|
||||
///
|
||||
/// 1. Discover metadata, register (or use CIMD), get auth URL
|
||||
/// 2. Fetch the auth URL with redirect:manual → extract code from Location header
|
||||
/// 3. Exchange code for token
|
||||
/// 4. Return an `AuthClient` wrapping `reqwest::Client`
|
||||
async fn perform_oauth_flow(
|
||||
server_url: &str,
|
||||
ctx: &ConformanceContext,
|
||||
) -> anyhow::Result<AuthClient<reqwest::Client>> {
|
||||
let mut oauth = OAuthState::new(server_url, None).await?;
|
||||
|
||||
// Discover + register + get auth URL
|
||||
oauth
|
||||
.start_authorization_with_metadata_url(
|
||||
&[],
|
||||
REDIRECT_URI,
|
||||
Some("conformance-client"),
|
||||
Some(CIMD_CLIENT_METADATA_URL),
|
||||
)
|
||||
.await?;
|
||||
|
||||
let auth_url = oauth.get_authorization_url().await?;
|
||||
tracing::debug!("Authorization URL: {}", auth_url);
|
||||
|
||||
// Headless: fetch the auth URL without following redirects
|
||||
let http = reqwest::Client::builder()
|
||||
.redirect(reqwest::redirect::Policy::none())
|
||||
.build()?;
|
||||
let resp = http.get(&auth_url).send().await?;
|
||||
let location = resp
|
||||
.headers()
|
||||
.get("location")
|
||||
.and_then(|v| v.to_str().ok())
|
||||
.ok_or_else(|| anyhow::anyhow!("No Location header in auth redirect"))?;
|
||||
|
||||
let redirect_url = url::Url::parse(location)?;
|
||||
let code = redirect_url
|
||||
.query_pairs()
|
||||
.find(|(k, _)| k == "code")
|
||||
.map(|(_, v)| v.to_string())
|
||||
.ok_or_else(|| anyhow::anyhow!("No code in redirect URL"))?;
|
||||
let state = redirect_url
|
||||
.query_pairs()
|
||||
.find(|(k, _)| k == "state")
|
||||
.map(|(_, v)| v.to_string())
|
||||
.ok_or_else(|| anyhow::anyhow!("No state in redirect URL"))?;
|
||||
|
||||
tracing::debug!("Got auth code, exchanging for token...");
|
||||
oauth.handle_callback(&code, &state).await?;
|
||||
|
||||
let am = oauth
|
||||
.into_authorization_manager()
|
||||
.ok_or_else(|| anyhow::anyhow!("Failed to get authorization manager"))?;
|
||||
|
||||
Ok(AuthClient::new(reqwest::Client::default(), am))
|
||||
}
|
||||
|
||||
/// Like `perform_oauth_flow` but uses pre-registered client credentials.
|
||||
async fn perform_oauth_flow_preregistered(
|
||||
server_url: &str,
|
||||
client_id: &str,
|
||||
client_secret: &str,
|
||||
) -> anyhow::Result<AuthClient<reqwest::Client>> {
|
||||
let mut manager = AuthorizationManager::new(server_url).await?;
|
||||
let metadata = manager.discover_metadata().await?;
|
||||
manager.set_metadata(metadata);
|
||||
|
||||
// Configure with pre-registered credentials
|
||||
let config = rmcp::transport::auth::OAuthClientConfig {
|
||||
client_id: client_id.to_string(),
|
||||
client_secret: Some(client_secret.to_string()),
|
||||
scopes: vec![],
|
||||
redirect_uri: REDIRECT_URI.to_string(),
|
||||
};
|
||||
manager.configure_client(config)?;
|
||||
|
||||
let scopes = manager.select_scopes(None, &[]);
|
||||
let scope_refs: Vec<&str> = scopes.iter().map(|s| s.as_str()).collect();
|
||||
let auth_url = manager.get_authorization_url(&scope_refs).await?;
|
||||
|
||||
// Headless redirect
|
||||
let http = reqwest::Client::builder()
|
||||
.redirect(reqwest::redirect::Policy::none())
|
||||
.build()?;
|
||||
let resp = http.get(&auth_url).send().await?;
|
||||
let location = resp
|
||||
.headers()
|
||||
.get("location")
|
||||
.and_then(|v| v.to_str().ok())
|
||||
.ok_or_else(|| anyhow::anyhow!("No Location header"))?;
|
||||
let redirect_url = url::Url::parse(location)?;
|
||||
let code = redirect_url
|
||||
.query_pairs()
|
||||
.find(|(k, _)| k == "code")
|
||||
.map(|(_, v)| v.to_string())
|
||||
.ok_or_else(|| anyhow::anyhow!("No code"))?;
|
||||
let state = redirect_url
|
||||
.query_pairs()
|
||||
.find(|(k, _)| k == "state")
|
||||
.map(|(_, v)| v.to_string())
|
||||
.ok_or_else(|| anyhow::anyhow!("No state"))?;
|
||||
|
||||
manager.exchange_code_for_token(&code, &state).await?;
|
||||
|
||||
Ok(AuthClient::new(reqwest::Client::default(), manager))
|
||||
}
|
||||
|
||||
/// Run the standard auth flow, then connect and exercise the server.
|
||||
async fn run_auth_client(server_url: &str, ctx: &ConformanceContext) -> anyhow::Result<()> {
|
||||
let auth_client = perform_oauth_flow(server_url, ctx).await?;
|
||||
|
||||
let transport = StreamableHttpClientTransport::with_client(
|
||||
auth_client,
|
||||
StreamableHttpClientTransportConfig::with_uri(server_url),
|
||||
);
|
||||
|
||||
let client = BasicClientHandler.serve(transport).await?;
|
||||
tracing::debug!("Connected (authenticated)");
|
||||
|
||||
let tools = client.list_tools(Default::default()).await?;
|
||||
tracing::debug!("Listed {} tools", tools.tools.len());
|
||||
|
||||
// Call each tool
|
||||
for tool in &tools.tools {
|
||||
let args = build_tool_arguments(tool);
|
||||
let _ = client
|
||||
.call_tool(CallToolRequestParams {
|
||||
meta: None,
|
||||
name: tool.name.clone(),
|
||||
arguments: args,
|
||||
task: None,
|
||||
})
|
||||
.await;
|
||||
}
|
||||
|
||||
client.cancel().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Auth flow with scope step-up: connect, list tools (ok with basic scope),
|
||||
/// then call tool which triggers 403 → re-auth with expanded scopes → retry.
|
||||
async fn run_auth_scope_step_up_client(
|
||||
server_url: &str,
|
||||
ctx: &ConformanceContext,
|
||||
) -> anyhow::Result<()> {
|
||||
// First auth
|
||||
let mut oauth = OAuthState::new(server_url, None).await?;
|
||||
oauth
|
||||
.start_authorization_with_metadata_url(
|
||||
&[],
|
||||
REDIRECT_URI,
|
||||
Some("conformance-client"),
|
||||
Some(CIMD_CLIENT_METADATA_URL),
|
||||
)
|
||||
.await?;
|
||||
|
||||
let auth_url = oauth.get_authorization_url().await?;
|
||||
let (code, state) = headless_authorize(&auth_url).await?;
|
||||
oauth.handle_callback(&code, &state).await?;
|
||||
|
||||
let am = oauth
|
||||
.into_authorization_manager()
|
||||
.ok_or_else(|| anyhow::anyhow!("No AM"))?;
|
||||
let auth_client = AuthClient::new(reqwest::Client::default(), am);
|
||||
|
||||
let transport = StreamableHttpClientTransport::with_client(
|
||||
auth_client.clone(),
|
||||
StreamableHttpClientTransportConfig::with_uri(server_url),
|
||||
);
|
||||
|
||||
let client = BasicClientHandler.serve(transport).await?;
|
||||
|
||||
let tools = client.list_tools(Default::default()).await?;
|
||||
tracing::debug!("Listed {} tools", tools.tools.len());
|
||||
|
||||
// Try calling tool – may get 403 insufficient_scope
|
||||
for tool in &tools.tools {
|
||||
let args = build_tool_arguments(tool);
|
||||
match client
|
||||
.call_tool(CallToolRequestParams {
|
||||
meta: None,
|
||||
name: tool.name.clone(),
|
||||
arguments: args.clone(),
|
||||
task: None,
|
||||
})
|
||||
.await
|
||||
{
|
||||
Ok(_) => {
|
||||
tracing::debug!("Tool call succeeded on first try");
|
||||
}
|
||||
Err(_) => {
|
||||
tracing::debug!("Tool call failed (likely 403), attempting scope upgrade...");
|
||||
// Drop old client, re-auth with upgraded scopes
|
||||
client.cancel().await.ok();
|
||||
|
||||
// Re-do the full flow; the server will give us the right scopes
|
||||
// on the second authorization request.
|
||||
let mut oauth2 = OAuthState::new(server_url, None).await?;
|
||||
// Pass the escalated scope hint
|
||||
oauth2
|
||||
.start_authorization_with_metadata_url(
|
||||
&[],
|
||||
REDIRECT_URI,
|
||||
Some("conformance-client"),
|
||||
Some(CIMD_CLIENT_METADATA_URL),
|
||||
)
|
||||
.await?;
|
||||
let auth_url2 = oauth2.get_authorization_url().await?;
|
||||
let (code2, state2) = headless_authorize(&auth_url2).await?;
|
||||
oauth2.handle_callback(&code2, &state2).await?;
|
||||
|
||||
let am2 = oauth2.into_authorization_manager().unwrap();
|
||||
let auth_client2 = AuthClient::new(reqwest::Client::default(), am2);
|
||||
let transport2 = StreamableHttpClientTransport::with_client(
|
||||
auth_client2,
|
||||
StreamableHttpClientTransportConfig::with_uri(server_url),
|
||||
);
|
||||
let client2 = BasicClientHandler.serve(transport2).await?;
|
||||
let _ = client2
|
||||
.call_tool(CallToolRequestParams {
|
||||
meta: None,
|
||||
name: tool.name.clone(),
|
||||
arguments: args,
|
||||
task: None,
|
||||
})
|
||||
.await;
|
||||
client2.cancel().await.ok();
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
client.cancel().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Auth flow for scope-retry-limit: keep re-authing on 403 until we hit a limit.
|
||||
async fn run_auth_scope_retry_limit_client(
|
||||
server_url: &str,
|
||||
_ctx: &ConformanceContext,
|
||||
) -> anyhow::Result<()> {
|
||||
let max_retries = 3u32;
|
||||
let mut attempt = 0u32;
|
||||
|
||||
loop {
|
||||
let mut oauth = OAuthState::new(server_url, None).await?;
|
||||
oauth
|
||||
.start_authorization_with_metadata_url(
|
||||
&[],
|
||||
REDIRECT_URI,
|
||||
Some("conformance-client"),
|
||||
Some(CIMD_CLIENT_METADATA_URL),
|
||||
)
|
||||
.await?;
|
||||
let auth_url = oauth.get_authorization_url().await?;
|
||||
let (code, state) = headless_authorize(&auth_url).await?;
|
||||
oauth.handle_callback(&code, &state).await?;
|
||||
|
||||
let am = oauth.into_authorization_manager().unwrap();
|
||||
let auth_client = AuthClient::new(reqwest::Client::default(), am);
|
||||
let transport = StreamableHttpClientTransport::with_client(
|
||||
auth_client,
|
||||
StreamableHttpClientTransportConfig::with_uri(server_url),
|
||||
);
|
||||
|
||||
let client = BasicClientHandler.serve(transport).await?;
|
||||
let tools = client.list_tools(Default::default()).await?;
|
||||
|
||||
let mut got_403 = false;
|
||||
for tool in &tools.tools {
|
||||
let args = build_tool_arguments(tool);
|
||||
match client
|
||||
.call_tool(CallToolRequestParams {
|
||||
meta: None,
|
||||
name: tool.name.clone(),
|
||||
arguments: args,
|
||||
task: None,
|
||||
})
|
||||
.await
|
||||
{
|
||||
Ok(_) => {}
|
||||
Err(_) => {
|
||||
got_403 = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
client.cancel().await.ok();
|
||||
|
||||
if !got_403 {
|
||||
break;
|
||||
}
|
||||
attempt += 1;
|
||||
if attempt >= max_retries {
|
||||
tracing::info!("Reached retry limit ({max_retries}), giving up");
|
||||
return Err(anyhow::anyhow!("Scope retry limit reached"));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Auth flow with pre-registered credentials (from context).
|
||||
async fn run_auth_preregistered_client(
|
||||
server_url: &str,
|
||||
ctx: &ConformanceContext,
|
||||
) -> anyhow::Result<()> {
|
||||
let client_id = ctx
|
||||
.client_id
|
||||
.as_deref()
|
||||
.ok_or_else(|| anyhow::anyhow!("Missing client_id in context"))?;
|
||||
let client_secret = ctx
|
||||
.client_secret
|
||||
.as_deref()
|
||||
.ok_or_else(|| anyhow::anyhow!("Missing client_secret in context"))?;
|
||||
|
||||
let auth_client =
|
||||
perform_oauth_flow_preregistered(server_url, client_id, client_secret).await?;
|
||||
|
||||
let transport = StreamableHttpClientTransport::with_client(
|
||||
auth_client,
|
||||
StreamableHttpClientTransportConfig::with_uri(server_url),
|
||||
);
|
||||
|
||||
let client = BasicClientHandler.serve(transport).await?;
|
||||
let tools = client.list_tools(Default::default()).await?;
|
||||
tracing::debug!("Listed {} tools", tools.tools.len());
|
||||
|
||||
for tool in &tools.tools {
|
||||
let args = build_tool_arguments(tool);
|
||||
let _ = client
|
||||
.call_tool(CallToolRequestParams {
|
||||
meta: None,
|
||||
name: tool.name.clone(),
|
||||
arguments: args,
|
||||
task: None,
|
||||
})
|
||||
.await;
|
||||
}
|
||||
client.cancel().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Client-credentials flow with client_secret_basic.
|
||||
async fn run_client_credentials_basic(
|
||||
server_url: &str,
|
||||
ctx: &ConformanceContext,
|
||||
) -> anyhow::Result<()> {
|
||||
let client_id = ctx
|
||||
.client_id
|
||||
.as_deref()
|
||||
.unwrap_or("conformance-test-client");
|
||||
let client_secret = ctx
|
||||
.client_secret
|
||||
.as_deref()
|
||||
.unwrap_or("conformance-test-secret");
|
||||
|
||||
let mut manager = AuthorizationManager::new(server_url).await?;
|
||||
let metadata = manager.discover_metadata().await?;
|
||||
let token_endpoint = metadata.token_endpoint.clone();
|
||||
manager.set_metadata(metadata);
|
||||
|
||||
let http = reqwest::Client::new();
|
||||
let resp = http
|
||||
.post(&token_endpoint)
|
||||
.basic_auth(client_id, Some(client_secret))
|
||||
.header("content-type", "application/x-www-form-urlencoded")
|
||||
.body("grant_type=client_credentials")
|
||||
.send()
|
||||
.await?;
|
||||
|
||||
let token_resp: serde_json::Value = resp.json().await?;
|
||||
let access_token = token_resp["access_token"]
|
||||
.as_str()
|
||||
.ok_or_else(|| anyhow::anyhow!("No access_token in response"))?;
|
||||
|
||||
// Use static token
|
||||
let transport = StreamableHttpClientTransport::with_client(
|
||||
reqwest::Client::default(),
|
||||
StreamableHttpClientTransportConfig::with_uri(server_url)
|
||||
.auth_header(access_token.to_string()),
|
||||
);
|
||||
|
||||
let client = BasicClientHandler.serve(transport).await?;
|
||||
let tools = client.list_tools(Default::default()).await?;
|
||||
tracing::debug!("Listed {} tools", tools.tools.len());
|
||||
for tool in &tools.tools {
|
||||
let args = build_tool_arguments(tool);
|
||||
let _ = client
|
||||
.call_tool(CallToolRequestParams {
|
||||
meta: None,
|
||||
name: tool.name.clone(),
|
||||
arguments: args,
|
||||
task: None,
|
||||
})
|
||||
.await;
|
||||
}
|
||||
client.cancel().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Client-credentials flow with private_key_jwt (JWT assertion).
|
||||
async fn run_client_credentials_jwt(
|
||||
server_url: &str,
|
||||
ctx: &ConformanceContext,
|
||||
) -> anyhow::Result<()> {
|
||||
let client_id = ctx
|
||||
.client_id
|
||||
.as_deref()
|
||||
.unwrap_or("conformance-test-client");
|
||||
let _pem = ctx
|
||||
.private_key_pem
|
||||
.as_deref()
|
||||
.ok_or_else(|| anyhow::anyhow!("Missing private_key_pem"))?;
|
||||
let _alg = ctx
|
||||
.signing_algorithm
|
||||
.as_deref()
|
||||
.ok_or_else(|| anyhow::anyhow!("Missing signing_algorithm"))?;
|
||||
|
||||
// Discover metadata to get token endpoint
|
||||
let mut manager = AuthorizationManager::new(server_url).await?;
|
||||
let metadata = manager.discover_metadata().await?;
|
||||
let token_endpoint = metadata.token_endpoint.clone();
|
||||
manager.set_metadata(metadata);
|
||||
|
||||
// Build JWT assertion
|
||||
// Parse the PEM private key
|
||||
let key = openssl_free_ec_sign(_pem, client_id, &token_endpoint)?;
|
||||
|
||||
let http = reqwest::Client::new();
|
||||
let form_body = format!(
|
||||
"grant_type=client_credentials&client_assertion_type={}&client_assertion={}",
|
||||
urlencoding::encode("urn:ietf:params:oauth:client-assertion-type:jwt-bearer"),
|
||||
urlencoding::encode(&key),
|
||||
);
|
||||
let resp = http
|
||||
.post(&token_endpoint)
|
||||
.header("content-type", "application/x-www-form-urlencoded")
|
||||
.body(form_body)
|
||||
.send()
|
||||
.await?;
|
||||
|
||||
let token_resp: serde_json::Value = resp.json().await?;
|
||||
let access_token = token_resp["access_token"]
|
||||
.as_str()
|
||||
.ok_or_else(|| anyhow::anyhow!("No access_token: {}", token_resp))?;
|
||||
|
||||
let transport = StreamableHttpClientTransport::with_client(
|
||||
reqwest::Client::default(),
|
||||
StreamableHttpClientTransportConfig::with_uri(server_url)
|
||||
.auth_header(access_token.to_string()),
|
||||
);
|
||||
|
||||
let client = BasicClientHandler.serve(transport).await?;
|
||||
let tools = client.list_tools(Default::default()).await?;
|
||||
tracing::debug!("Listed {} tools", tools.tools.len());
|
||||
for tool in &tools.tools {
|
||||
let args = build_tool_arguments(tool);
|
||||
let _ = client
|
||||
.call_tool(CallToolRequestParams {
|
||||
meta: None,
|
||||
name: tool.name.clone(),
|
||||
arguments: args,
|
||||
task: None,
|
||||
})
|
||||
.await;
|
||||
}
|
||||
client.cancel().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Minimal ES256 JWT signing without heavy deps.
|
||||
/// We use ring or pure-Rust approach. For simplicity, use the p256 + base64 crates
|
||||
/// that are already transitive deps of oauth2.
|
||||
fn openssl_free_ec_sign(pem: &str, client_id: &str, audience: &str) -> anyhow::Result<String> {
|
||||
use std::time::{SystemTime, UNIX_EPOCH};
|
||||
|
||||
// Decode PEM → DER
|
||||
let pem_body = pem
|
||||
.lines()
|
||||
.filter(|l| !l.starts_with("-----"))
|
||||
.collect::<String>();
|
||||
let der = base64_decode(&pem_body)?;
|
||||
|
||||
// Parse PKCS#8 DER to get the raw EC private key bytes
|
||||
// PKCS#8 for EC P-256: the raw 32-byte key is at the end of the structure
|
||||
let raw_key = extract_ec_private_key(&der)?;
|
||||
|
||||
let now = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs();
|
||||
let header = base64url_encode(br#"{"alg":"ES256","typ":"JWT"}"#);
|
||||
let payload_json = serde_json::json!({
|
||||
"iss": client_id,
|
||||
"sub": client_id,
|
||||
"aud": audience,
|
||||
"iat": now,
|
||||
"exp": now + 300,
|
||||
"jti": format!("jti-{}", now),
|
||||
});
|
||||
let payload = base64url_encode(payload_json.to_string().as_bytes());
|
||||
let signing_input = format!("{}.{}", header, payload);
|
||||
|
||||
// Sign with p256
|
||||
let secret_key = p256::ecdsa::SigningKey::from_bytes(raw_key.as_slice().into())
|
||||
.map_err(|e| anyhow::anyhow!("Invalid EC key: {}", e))?;
|
||||
use p256::ecdsa::signature::Signer;
|
||||
let sig: p256::ecdsa::Signature = secret_key.sign(signing_input.as_bytes());
|
||||
let sig_bytes = sig.to_bytes();
|
||||
let sig_b64 = base64url_encode(&sig_bytes);
|
||||
|
||||
Ok(format!("{}.{}", signing_input, sig_b64))
|
||||
}
|
||||
|
||||
fn base64url_encode(data: &[u8]) -> String {
|
||||
use base64::Engine;
|
||||
base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(data)
|
||||
}
|
||||
|
||||
fn base64_decode(s: &str) -> anyhow::Result<Vec<u8>> {
|
||||
use base64::Engine;
|
||||
Ok(base64::engine::general_purpose::STANDARD.decode(s.trim())?)
|
||||
}
|
||||
|
||||
/// Extract the raw 32-byte EC private key from a PKCS#8 DER blob.
|
||||
fn extract_ec_private_key(der: &[u8]) -> anyhow::Result<Vec<u8>> {
|
||||
// PKCS#8 wraps an ECPrivateKey. We look for the octet string containing
|
||||
// the 32-byte private key. A simple heuristic: find 0x04 0x20 (OCTET STRING, len 32)
|
||||
// followed by exactly 32 bytes that form the key.
|
||||
// More robust: parse ASN.1. But for conformance testing this suffices.
|
||||
for i in 0..der.len().saturating_sub(33) {
|
||||
if der[i] == 0x04 && der[i + 1] == 0x20 && i + 34 <= der.len() {
|
||||
return Ok(der[i + 2..i + 34].to_vec());
|
||||
}
|
||||
}
|
||||
Err(anyhow::anyhow!(
|
||||
"Could not extract 32-byte EC private key from PKCS#8 DER"
|
||||
))
|
||||
}
|
||||
|
||||
/// Cross-app access flow (SEP-1046 extension).
|
||||
async fn run_cross_app_access_client(
|
||||
server_url: &str,
|
||||
ctx: &ConformanceContext,
|
||||
) -> anyhow::Result<()> {
|
||||
// For now, fall back to standard auth flow
|
||||
// The cross-app-access test is an extension scenario
|
||||
run_auth_client(server_url, ctx).await
|
||||
}
|
||||
|
||||
// ─── Helpers ────────────────────────────────────────────────────────────────
|
||||
|
||||
/// Fetch an authorization URL headlessly, returning (code, state).
|
||||
async fn headless_authorize(auth_url: &str) -> anyhow::Result<(String, String)> {
|
||||
let http = reqwest::Client::builder()
|
||||
.redirect(reqwest::redirect::Policy::none())
|
||||
.build()?;
|
||||
let resp = http.get(auth_url).send().await?;
|
||||
let location = resp
|
||||
.headers()
|
||||
.get("location")
|
||||
.and_then(|v| v.to_str().ok())
|
||||
.ok_or_else(|| anyhow::anyhow!("No Location header in auth redirect"))?;
|
||||
let redirect_url = url::Url::parse(location)?;
|
||||
let code = redirect_url
|
||||
.query_pairs()
|
||||
.find(|(k, _)| k == "code")
|
||||
.map(|(_, v)| v.to_string())
|
||||
.ok_or_else(|| anyhow::anyhow!("No code in redirect URL"))?;
|
||||
let state = redirect_url
|
||||
.query_pairs()
|
||||
.find(|(k, _)| k == "state")
|
||||
.map(|(_, v)| v.to_string())
|
||||
.ok_or_else(|| anyhow::anyhow!("No state in redirect URL"))?;
|
||||
Ok((code, state))
|
||||
}
|
||||
|
||||
/// Build arguments for a tool based on its input schema.
|
||||
fn build_tool_arguments(tool: &Tool) -> Option<serde_json::Map<String, Value>> {
|
||||
let schema = &tool.input_schema;
|
||||
let properties = schema.get("properties").and_then(|p| p.as_object());
|
||||
let required = schema
|
||||
.get("required")
|
||||
.and_then(|r| r.as_array())
|
||||
.map(|arr| {
|
||||
arr.iter()
|
||||
.filter_map(|v| v.as_str().map(String::from))
|
||||
.collect::<Vec<_>>()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
|
||||
let Some(properties) = properties else {
|
||||
return None;
|
||||
};
|
||||
if properties.is_empty() && required.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
let mut args = serde_json::Map::new();
|
||||
for (name, prop_schema) in properties {
|
||||
if !required.contains(name) {
|
||||
continue;
|
||||
}
|
||||
let type_str = prop_schema.get("type").and_then(|t| t.as_str());
|
||||
let value = match type_str {
|
||||
Some("number") => json!(1.0),
|
||||
Some("integer") => json!(1),
|
||||
Some("string") => json!("test"),
|
||||
Some("boolean") => json!(true),
|
||||
_ => json!(null),
|
||||
};
|
||||
args.insert(name.clone(), value);
|
||||
}
|
||||
Some(args)
|
||||
}
|
||||
|
||||
// ─── Non-auth scenarios ─────────────────────────────────────────────────────
|
||||
|
||||
async fn run_basic_client(server_url: &str) -> anyhow::Result<()> {
|
||||
let transport = StreamableHttpClientTransport::from_uri(server_url);
|
||||
let client = BasicClientHandler.serve(transport).await?;
|
||||
let tools = client.list_tools(Default::default()).await?;
|
||||
tracing::debug!("Listed {} tools", tools.tools.len());
|
||||
client.cancel().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn run_tools_call_client(server_url: &str) -> anyhow::Result<()> {
|
||||
let transport = StreamableHttpClientTransport::from_uri(server_url);
|
||||
let client = FullClientHandler.serve(transport).await?;
|
||||
let tools = client.list_tools(Default::default()).await?;
|
||||
for tool in &tools.tools {
|
||||
let args = build_tool_arguments(tool);
|
||||
let _ = client
|
||||
.call_tool(CallToolRequestParams {
|
||||
meta: None,
|
||||
name: tool.name.clone(),
|
||||
arguments: args,
|
||||
task: None,
|
||||
})
|
||||
.await?;
|
||||
}
|
||||
client.cancel().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn run_elicitation_defaults_client(server_url: &str) -> anyhow::Result<()> {
|
||||
let transport = StreamableHttpClientTransport::from_uri(server_url);
|
||||
let client = ElicitationDefaultsClientHandler.serve(transport).await?;
|
||||
let tools = client.list_tools(Default::default()).await?;
|
||||
let test_tool = tools.tools.iter().find(|t| {
|
||||
let n = t.name.as_ref();
|
||||
n == "test_client_elicitation_defaults" || n == "test_elicitation_sep1034_defaults"
|
||||
});
|
||||
if let Some(tool) = test_tool {
|
||||
let _ = client
|
||||
.call_tool(CallToolRequestParams {
|
||||
meta: None,
|
||||
name: tool.name.clone(),
|
||||
arguments: None,
|
||||
task: None,
|
||||
})
|
||||
.await?;
|
||||
}
|
||||
client.cancel().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn run_sse_retry_client(server_url: &str) -> anyhow::Result<()> {
|
||||
let transport = StreamableHttpClientTransport::from_uri(server_url);
|
||||
let client = BasicClientHandler.serve(transport).await?;
|
||||
let tools = client.list_tools(Default::default()).await?;
|
||||
if let Some(tool) = tools
|
||||
.tools
|
||||
.iter()
|
||||
.find(|t| t.name.as_ref() == "test_reconnection")
|
||||
{
|
||||
let _ = client
|
||||
.call_tool(CallToolRequestParams {
|
||||
meta: None,
|
||||
name: tool.name.clone(),
|
||||
arguments: None,
|
||||
task: None,
|
||||
})
|
||||
.await?;
|
||||
}
|
||||
client.cancel().await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// ─── Main ───────────────────────────────────────────────────────────────────
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> anyhow::Result<()> {
|
||||
tracing_subscriber::registry()
|
||||
.with(
|
||||
tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| "info".into()),
|
||||
)
|
||||
.with(tracing_subscriber::fmt::layer())
|
||||
.init();
|
||||
|
||||
let scenario =
|
||||
std::env::var("MCP_CONFORMANCE_SCENARIO").unwrap_or_else(|_| "initialize".to_string());
|
||||
let server_url = std::env::args()
|
||||
.nth(1)
|
||||
.unwrap_or_else(|| "http://127.0.0.1:8001/mcp".to_string());
|
||||
let ctx = load_context();
|
||||
|
||||
tracing::info!("Running scenario '{}' against {}", scenario, server_url);
|
||||
|
||||
match scenario.as_str() {
|
||||
// Non-auth scenarios
|
||||
"initialize" => run_basic_client(&server_url).await?,
|
||||
"tools_call" => run_tools_call_client(&server_url).await?,
|
||||
"elicitation-sep1034-client-defaults" => {
|
||||
run_elicitation_defaults_client(&server_url).await?
|
||||
}
|
||||
"sse-retry" => run_sse_retry_client(&server_url).await?,
|
||||
|
||||
// Auth scenarios - standard OAuth flow
|
||||
"auth/metadata-default"
|
||||
| "auth/metadata-var1"
|
||||
| "auth/metadata-var2"
|
||||
| "auth/metadata-var3"
|
||||
| "auth/basic-cimd"
|
||||
| "auth/scope-from-www-authenticate"
|
||||
| "auth/scope-from-scopes-supported"
|
||||
| "auth/scope-omitted-when-undefined"
|
||||
| "auth/token-endpoint-auth-basic"
|
||||
| "auth/token-endpoint-auth-post"
|
||||
| "auth/token-endpoint-auth-none"
|
||||
| "auth/2025-03-26-oauth-metadata-backcompat"
|
||||
| "auth/2025-03-26-oauth-endpoint-fallback" => run_auth_client(&server_url, &ctx).await?,
|
||||
|
||||
// Auth - scope step-up
|
||||
"auth/scope-step-up" => run_auth_scope_step_up_client(&server_url, &ctx).await?,
|
||||
|
||||
// Auth - scope retry limit
|
||||
"auth/scope-retry-limit" => run_auth_scope_retry_limit_client(&server_url, &ctx).await?,
|
||||
|
||||
// Auth - pre-registration
|
||||
"auth/pre-registration" => run_auth_preregistered_client(&server_url, &ctx).await?,
|
||||
|
||||
// Auth - resource mismatch (should fail to auth → pass)
|
||||
"auth/resource-mismatch" => {
|
||||
// Try to auth; it should fail because PRM resource doesn't match
|
||||
match run_auth_client(&server_url, &ctx).await {
|
||||
Ok(_) => {
|
||||
tracing::warn!("Auth succeeded despite resource mismatch!");
|
||||
}
|
||||
Err(e) => {
|
||||
tracing::info!("Auth correctly failed: {}", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Auth - client credentials
|
||||
"auth/client-credentials-basic" => run_client_credentials_basic(&server_url, &ctx).await?,
|
||||
"auth/client-credentials-jwt" => run_client_credentials_jwt(&server_url, &ctx).await?,
|
||||
|
||||
// Auth - cross-app access
|
||||
"auth/cross-app-access-complete-flow" => {
|
||||
run_cross_app_access_client(&server_url, &ctx).await?
|
||||
}
|
||||
|
||||
_ => {
|
||||
tracing::warn!("Unknown scenario '{}', trying auth flow", scenario);
|
||||
match run_auth_client(&server_url, &ctx).await {
|
||||
Ok(_) => {}
|
||||
Err(e) => {
|
||||
tracing::debug!("Auth flow failed for unknown scenario: {e}");
|
||||
run_basic_client(&server_url).await?
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
959
conformance/src/bin/server.rs
Normal file
959
conformance/src/bin/server.rs
Normal file
|
|
@ -0,0 +1,959 @@
|
|||
use std::{collections::HashSet, future::Future, sync::Arc};
|
||||
|
||||
use rmcp::{
|
||||
ErrorData, RoleServer, ServerHandler,
|
||||
model::*,
|
||||
service::RequestContext,
|
||||
transport::{
|
||||
StreamableHttpServerConfig, StreamableHttpService,
|
||||
streamable_http_server::session::local::LocalSessionManager,
|
||||
},
|
||||
};
|
||||
use serde_json::{Value, json};
|
||||
use tokio::sync::Mutex;
|
||||
use tracing_subscriber::EnvFilter;
|
||||
|
||||
// Small base64-encoded 1x1 red PNG
|
||||
const TEST_IMAGE_DATA: &str = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==";
|
||||
// Small base64-encoded WAV (silence)
|
||||
const TEST_AUDIO_DATA: &str = "UklGRiQAAABXQVZFZm10IBAAAAABAAEARKwAAIhYAQACABAAZGF0YQAAAAA=";
|
||||
|
||||
/// Helper to convert a serde_json::Value (must be an object) into a JsonObject
|
||||
fn json_object(v: Value) -> JsonObject {
|
||||
match v {
|
||||
Value::Object(map) => map,
|
||||
_ => panic!("Expected JSON object"),
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct ConformanceServer {
|
||||
subscriptions: Arc<Mutex<HashSet<String>>>,
|
||||
log_level: Arc<Mutex<LoggingLevel>>,
|
||||
}
|
||||
|
||||
impl ConformanceServer {
|
||||
fn new() -> Self {
|
||||
Self {
|
||||
subscriptions: Arc::new(Mutex::new(HashSet::new())),
|
||||
log_level: Arc::new(Mutex::new(LoggingLevel::Debug)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ServerHandler for ConformanceServer {
|
||||
fn initialize(
|
||||
&self,
|
||||
_request: InitializeRequestParams,
|
||||
_cx: RequestContext<RoleServer>,
|
||||
) -> impl Future<Output = Result<InitializeResult, ErrorData>> + Send + '_ {
|
||||
async {
|
||||
Ok(InitializeResult {
|
||||
server_info: Implementation {
|
||||
name: "rust-conformance-server".into(),
|
||||
title: None,
|
||||
version: "0.1.0".into(),
|
||||
description: None,
|
||||
icons: None,
|
||||
website_url: None,
|
||||
},
|
||||
capabilities: ServerCapabilities::builder()
|
||||
.enable_prompts()
|
||||
.enable_resources()
|
||||
.enable_tools()
|
||||
.enable_logging()
|
||||
.build(),
|
||||
instructions: Some("Rust MCP conformance test server".into()),
|
||||
..Default::default()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn ping(
|
||||
&self,
|
||||
_cx: RequestContext<RoleServer>,
|
||||
) -> impl Future<Output = Result<(), ErrorData>> + Send + '_ {
|
||||
async { Ok(()) }
|
||||
}
|
||||
|
||||
fn list_tools(
|
||||
&self,
|
||||
_request: Option<PaginatedRequestParams>,
|
||||
_cx: RequestContext<RoleServer>,
|
||||
) -> impl Future<Output = Result<ListToolsResult, ErrorData>> + Send + '_ {
|
||||
async {
|
||||
let tools = vec![
|
||||
Tool::new(
|
||||
"test_simple_text",
|
||||
"Returns simple text content",
|
||||
json_object(json!({
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
})),
|
||||
),
|
||||
Tool::new(
|
||||
"test_image_content",
|
||||
"Returns image content",
|
||||
json_object(json!({
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
})),
|
||||
),
|
||||
Tool::new(
|
||||
"test_audio_content",
|
||||
"Returns audio content",
|
||||
json_object(json!({
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
})),
|
||||
),
|
||||
Tool::new(
|
||||
"test_embedded_resource",
|
||||
"Returns embedded resource content",
|
||||
json_object(json!({
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
})),
|
||||
),
|
||||
Tool::new(
|
||||
"test_multiple_content_types",
|
||||
"Returns multiple content types",
|
||||
json_object(json!({
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
})),
|
||||
),
|
||||
Tool::new(
|
||||
"test_tool_with_logging",
|
||||
"Sends logging notifications during execution",
|
||||
json_object(json!({
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
})),
|
||||
),
|
||||
Tool::new(
|
||||
"test_error_handling",
|
||||
"Always returns an error",
|
||||
json_object(json!({
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
})),
|
||||
),
|
||||
Tool::new(
|
||||
"test_tool_with_progress",
|
||||
"Reports progress notifications",
|
||||
json_object(json!({
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
})),
|
||||
),
|
||||
Tool::new(
|
||||
"test_sampling",
|
||||
"Requests LLM sampling from client",
|
||||
json_object(json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"prompt": { "type": "string", "description": "The prompt to send" }
|
||||
},
|
||||
"required": ["prompt"]
|
||||
})),
|
||||
),
|
||||
Tool::new(
|
||||
"test_elicitation",
|
||||
"Requests user input from client",
|
||||
json_object(json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"message": { "type": "string", "description": "The message to show" }
|
||||
},
|
||||
"required": ["message"]
|
||||
})),
|
||||
),
|
||||
Tool::new(
|
||||
"test_elicitation_sep1034_defaults",
|
||||
"Tests elicitation with default values (SEP-1034)",
|
||||
json_object(json!({
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
})),
|
||||
),
|
||||
Tool::new(
|
||||
"test_elicitation_sep1330_enums",
|
||||
"Tests enum schema improvements (SEP-1330)",
|
||||
json_object(json!({
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
})),
|
||||
),
|
||||
Tool::new(
|
||||
"json_schema_2020_12_tool",
|
||||
"Tool with JSON Schema 2020-12 features",
|
||||
json_object(json!({
|
||||
"$schema": "https://json-schema.org/draft/2020-12/schema",
|
||||
"type": "object",
|
||||
"$defs": {
|
||||
"address": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"street": { "type": "string" },
|
||||
"city": { "type": "string" }
|
||||
}
|
||||
}
|
||||
},
|
||||
"properties": {
|
||||
"name": { "type": "string" },
|
||||
"address": { "$ref": "#/$defs/address" }
|
||||
},
|
||||
"additionalProperties": false
|
||||
})),
|
||||
),
|
||||
Tool::new(
|
||||
"test_reconnection",
|
||||
"Tests SSE reconnection behavior",
|
||||
json_object(json!({
|
||||
"type": "object",
|
||||
"properties": {}
|
||||
})),
|
||||
),
|
||||
];
|
||||
Ok(ListToolsResult {
|
||||
meta: None,
|
||||
tools,
|
||||
next_cursor: None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn call_tool(
|
||||
&self,
|
||||
request: CallToolRequestParams,
|
||||
cx: RequestContext<RoleServer>,
|
||||
) -> impl Future<Output = Result<CallToolResult, ErrorData>> + Send + '_ {
|
||||
async move {
|
||||
let args = request.arguments.unwrap_or_default();
|
||||
match request.name.as_ref() {
|
||||
"test_simple_text" => Ok(CallToolResult {
|
||||
content: vec![Content::text("This is a simple text response for testing.")],
|
||||
structured_content: None,
|
||||
is_error: None,
|
||||
meta: None,
|
||||
}),
|
||||
|
||||
"test_image_content" => Ok(CallToolResult {
|
||||
content: vec![Content::image(TEST_IMAGE_DATA, "image/png")],
|
||||
structured_content: None,
|
||||
is_error: None,
|
||||
meta: None,
|
||||
}),
|
||||
|
||||
"test_audio_content" => {
|
||||
// No Content::audio() helper, construct manually
|
||||
let audio = RawContent::Audio(RawAudioContent {
|
||||
data: TEST_AUDIO_DATA.into(),
|
||||
mime_type: "audio/wav".into(),
|
||||
})
|
||||
.no_annotation();
|
||||
Ok(CallToolResult {
|
||||
content: vec![audio],
|
||||
structured_content: None,
|
||||
is_error: None,
|
||||
meta: None,
|
||||
})
|
||||
}
|
||||
|
||||
"test_embedded_resource" => Ok(CallToolResult {
|
||||
content: vec![Content::resource(ResourceContents::TextResourceContents {
|
||||
uri: "test://embedded-resource".into(),
|
||||
mime_type: Some("text/plain".into()),
|
||||
text: "This is an embedded resource content.".into(),
|
||||
meta: None,
|
||||
})],
|
||||
structured_content: None,
|
||||
is_error: None,
|
||||
meta: None,
|
||||
}),
|
||||
|
||||
"test_multiple_content_types" => Ok(CallToolResult {
|
||||
content: vec![
|
||||
Content::text("Multiple content types test:"),
|
||||
Content::image(TEST_IMAGE_DATA, "image/png"),
|
||||
Content::resource(ResourceContents::TextResourceContents {
|
||||
uri: "test://mixed-content-resource".into(),
|
||||
mime_type: Some("application/json".into()),
|
||||
text: r#"{"test":"data","value":123}"#.into(),
|
||||
meta: None,
|
||||
}),
|
||||
],
|
||||
structured_content: None,
|
||||
is_error: None,
|
||||
meta: None,
|
||||
}),
|
||||
|
||||
"test_tool_with_logging" => {
|
||||
for msg in [
|
||||
"Tool execution started",
|
||||
"Tool processing data",
|
||||
"Tool execution completed",
|
||||
] {
|
||||
let _ = cx
|
||||
.peer
|
||||
.notify_logging_message(LoggingMessageNotificationParam {
|
||||
level: LoggingLevel::Info,
|
||||
logger: Some("conformance-server".into()),
|
||||
data: json!(msg),
|
||||
})
|
||||
.await;
|
||||
tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
|
||||
}
|
||||
|
||||
Ok(CallToolResult {
|
||||
content: vec![Content::text("Logging test completed")],
|
||||
structured_content: None,
|
||||
is_error: None,
|
||||
meta: None,
|
||||
})
|
||||
}
|
||||
|
||||
"test_error_handling" => Ok(CallToolResult {
|
||||
content: vec![Content::text(
|
||||
"This tool intentionally returns an error for testing",
|
||||
)],
|
||||
structured_content: None,
|
||||
is_error: Some(true),
|
||||
meta: None,
|
||||
}),
|
||||
|
||||
"test_tool_with_progress" => {
|
||||
let progress_token = cx.meta.get_progress_token();
|
||||
|
||||
for (progress, message) in
|
||||
[(0.0, "Starting"), (50.0, "Halfway"), (100.0, "Complete")]
|
||||
{
|
||||
if let Some(token) = &progress_token {
|
||||
let _ = cx
|
||||
.peer
|
||||
.notify_progress(ProgressNotificationParam {
|
||||
progress_token: token.clone(),
|
||||
progress,
|
||||
total: Some(100.0),
|
||||
message: Some(message.into()),
|
||||
})
|
||||
.await;
|
||||
}
|
||||
tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
|
||||
}
|
||||
|
||||
Ok(CallToolResult {
|
||||
content: vec![Content::text("Progress test completed")],
|
||||
structured_content: None,
|
||||
is_error: None,
|
||||
meta: None,
|
||||
})
|
||||
}
|
||||
|
||||
"test_sampling" => {
|
||||
let prompt = args
|
||||
.get("prompt")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("Hello");
|
||||
|
||||
match cx
|
||||
.peer
|
||||
.create_message(CreateMessageRequestParams {
|
||||
meta: None,
|
||||
task: None,
|
||||
messages: vec![SamplingMessage::user_text(prompt)],
|
||||
max_tokens: 100,
|
||||
model_preferences: None,
|
||||
system_prompt: None,
|
||||
include_context: None,
|
||||
temperature: None,
|
||||
stop_sequences: None,
|
||||
metadata: None,
|
||||
tools: None,
|
||||
tool_choice: None,
|
||||
})
|
||||
.await
|
||||
{
|
||||
Ok(result) => {
|
||||
let text = result
|
||||
.message
|
||||
.content
|
||||
.first()
|
||||
.and_then(|c| c.as_text())
|
||||
.map(|t| t.text.clone())
|
||||
.unwrap_or_else(|| "No text response".into());
|
||||
Ok(CallToolResult {
|
||||
content: vec![Content::text(format!("LLM response: {}", text))],
|
||||
structured_content: None,
|
||||
is_error: None,
|
||||
meta: None,
|
||||
})
|
||||
}
|
||||
Err(e) => Ok(CallToolResult {
|
||||
content: vec![Content::text(format!("Sampling error: {}", e))],
|
||||
structured_content: None,
|
||||
is_error: Some(true),
|
||||
meta: None,
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
"test_elicitation" => {
|
||||
let message = args
|
||||
.get("message")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("Please provide your information");
|
||||
|
||||
let schema_json = json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"username": {
|
||||
"type": "string",
|
||||
"description": "User's response"
|
||||
},
|
||||
"email": {
|
||||
"type": "string",
|
||||
"description": "User's email address"
|
||||
}
|
||||
},
|
||||
"required": ["username", "email"]
|
||||
});
|
||||
|
||||
let schema: ElicitationSchema = serde_json::from_value(schema_json).unwrap();
|
||||
|
||||
match cx
|
||||
.peer
|
||||
.create_elicitation(CreateElicitationRequestParams::FormElicitationParams {
|
||||
meta: None,
|
||||
message: message.into(),
|
||||
requested_schema: schema,
|
||||
})
|
||||
.await
|
||||
{
|
||||
Ok(result) => Ok(CallToolResult {
|
||||
content: vec![Content::text(format!(
|
||||
"User response: action={}, content={:?}",
|
||||
match result.action {
|
||||
ElicitationAction::Accept => "accept",
|
||||
ElicitationAction::Decline => "decline",
|
||||
ElicitationAction::Cancel => "cancel",
|
||||
},
|
||||
result.content
|
||||
))],
|
||||
structured_content: None,
|
||||
is_error: None,
|
||||
meta: None,
|
||||
}),
|
||||
Err(e) => Ok(CallToolResult {
|
||||
content: vec![Content::text(format!("Elicitation error: {}", e))],
|
||||
structured_content: None,
|
||||
is_error: Some(true),
|
||||
meta: None,
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
"test_elicitation_sep1034_defaults" => {
|
||||
let schema_json = json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"name": {
|
||||
"type": "string",
|
||||
"description": "User's name",
|
||||
"default": "John Doe"
|
||||
},
|
||||
"age": {
|
||||
"type": "integer",
|
||||
"description": "User's age",
|
||||
"default": 30
|
||||
},
|
||||
"score": {
|
||||
"type": "number",
|
||||
"description": "User's score",
|
||||
"default": 95.5
|
||||
},
|
||||
"status": {
|
||||
"type": "string",
|
||||
"description": "User's status",
|
||||
"enum": ["active", "inactive", "pending"],
|
||||
"default": "active"
|
||||
},
|
||||
"verified": {
|
||||
"type": "boolean",
|
||||
"description": "Whether user is verified",
|
||||
"default": true
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let schema: ElicitationSchema = serde_json::from_value(schema_json).unwrap();
|
||||
|
||||
match cx
|
||||
.peer
|
||||
.create_elicitation(CreateElicitationRequestParams::FormElicitationParams {
|
||||
meta: None,
|
||||
message: "Please provide values (all have defaults)".into(),
|
||||
requested_schema: schema,
|
||||
})
|
||||
.await
|
||||
{
|
||||
Ok(result) => Ok(CallToolResult {
|
||||
content: vec![Content::text(format!(
|
||||
"Elicitation completed: action={}, content={:?}",
|
||||
match result.action {
|
||||
ElicitationAction::Accept => "accept",
|
||||
ElicitationAction::Decline => "decline",
|
||||
ElicitationAction::Cancel => "cancel",
|
||||
},
|
||||
result.content
|
||||
))],
|
||||
structured_content: None,
|
||||
is_error: None,
|
||||
meta: None,
|
||||
}),
|
||||
Err(e) => Ok(CallToolResult {
|
||||
content: vec![Content::text(format!("Elicitation error: {}", e))],
|
||||
structured_content: None,
|
||||
is_error: Some(true),
|
||||
meta: None,
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
"test_elicitation_sep1330_enums" => {
|
||||
let schema_json = json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"untitledSingle": {
|
||||
"type": "string",
|
||||
"enum": ["option1", "option2", "option3"]
|
||||
},
|
||||
"titledSingle": {
|
||||
"type": "string",
|
||||
"oneOf": [
|
||||
{ "const": "value1", "title": "First Option" },
|
||||
{ "const": "value2", "title": "Second Option" },
|
||||
{ "const": "value3", "title": "Third Option" }
|
||||
]
|
||||
},
|
||||
"legacyEnum": {
|
||||
"type": "string",
|
||||
"enum": ["opt1", "opt2", "opt3"],
|
||||
"enumNames": ["Option One", "Option Two", "Option Three"]
|
||||
},
|
||||
"untitledMulti": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "string",
|
||||
"enum": ["option1", "option2", "option3"]
|
||||
}
|
||||
},
|
||||
"titledMulti": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"anyOf": [
|
||||
{ "const": "value1", "title": "First Choice" },
|
||||
{ "const": "value2", "title": "Second Choice" },
|
||||
{ "const": "value3", "title": "Third Choice" }
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let schema: ElicitationSchema = serde_json::from_value(schema_json).unwrap();
|
||||
|
||||
match cx
|
||||
.peer
|
||||
.create_elicitation(CreateElicitationRequestParams::FormElicitationParams {
|
||||
meta: None,
|
||||
message: "Test enum schema improvements".into(),
|
||||
requested_schema: schema,
|
||||
})
|
||||
.await
|
||||
{
|
||||
Ok(result) => Ok(CallToolResult {
|
||||
content: vec![Content::text(format!(
|
||||
"Enum elicitation completed: action={}",
|
||||
match result.action {
|
||||
ElicitationAction::Accept => "accept",
|
||||
ElicitationAction::Decline => "decline",
|
||||
ElicitationAction::Cancel => "cancel",
|
||||
}
|
||||
))],
|
||||
structured_content: None,
|
||||
is_error: None,
|
||||
meta: None,
|
||||
}),
|
||||
Err(e) => Ok(CallToolResult {
|
||||
content: vec![Content::text(format!("Elicitation error: {}", e))],
|
||||
structured_content: None,
|
||||
is_error: Some(true),
|
||||
meta: None,
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
"json_schema_2020_12_tool" => {
|
||||
let name = args.get("name").and_then(|v| v.as_str()).unwrap_or("world");
|
||||
Ok(CallToolResult {
|
||||
content: vec![Content::text(format!("Hello, {}!", name))],
|
||||
structured_content: None,
|
||||
is_error: None,
|
||||
meta: None,
|
||||
})
|
||||
}
|
||||
|
||||
"test_reconnection" => {
|
||||
tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
|
||||
Ok(CallToolResult {
|
||||
content: vec![Content::text("Reconnection test completed")],
|
||||
structured_content: None,
|
||||
is_error: None,
|
||||
meta: None,
|
||||
})
|
||||
}
|
||||
|
||||
_ => Err(ErrorData::invalid_params(
|
||||
format!("Unknown tool: {}", request.name),
|
||||
None,
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn list_resources(
|
||||
&self,
|
||||
_request: Option<PaginatedRequestParams>,
|
||||
_cx: RequestContext<RoleServer>,
|
||||
) -> impl Future<Output = Result<ListResourcesResult, ErrorData>> + Send + '_ {
|
||||
async {
|
||||
Ok(ListResourcesResult {
|
||||
meta: None,
|
||||
resources: vec![
|
||||
RawResource {
|
||||
uri: "test://static-text".into(),
|
||||
name: "Static Text Resource".into(),
|
||||
title: None,
|
||||
description: Some("A static text resource for testing".into()),
|
||||
mime_type: Some("text/plain".into()),
|
||||
size: None,
|
||||
icons: None,
|
||||
meta: None,
|
||||
}
|
||||
.no_annotation(),
|
||||
RawResource {
|
||||
uri: "test://static-binary".into(),
|
||||
name: "Static Binary Resource".into(),
|
||||
title: None,
|
||||
description: Some("A static binary/blob resource for testing".into()),
|
||||
mime_type: Some("image/png".into()),
|
||||
size: None,
|
||||
icons: None,
|
||||
meta: None,
|
||||
}
|
||||
.no_annotation(),
|
||||
],
|
||||
next_cursor: None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn read_resource(
|
||||
&self,
|
||||
request: ReadResourceRequestParams,
|
||||
_cx: RequestContext<RoleServer>,
|
||||
) -> impl Future<Output = Result<ReadResourceResult, ErrorData>> + Send + '_ {
|
||||
async move {
|
||||
let uri = request.uri.as_str();
|
||||
match uri {
|
||||
"test://static-text" => Ok(ReadResourceResult {
|
||||
contents: vec![ResourceContents::TextResourceContents {
|
||||
uri: uri.into(),
|
||||
mime_type: Some("text/plain".into()),
|
||||
text: "This is the content of the static text resource.".into(),
|
||||
meta: None,
|
||||
}],
|
||||
}),
|
||||
"test://static-binary" => Ok(ReadResourceResult {
|
||||
contents: vec![ResourceContents::BlobResourceContents {
|
||||
uri: uri.into(),
|
||||
mime_type: Some("image/png".into()),
|
||||
blob: TEST_IMAGE_DATA.into(),
|
||||
meta: None,
|
||||
}],
|
||||
}),
|
||||
_ => {
|
||||
// Check if it matches template: test://template/{id}/data
|
||||
if uri.starts_with("test://template/") && uri.ends_with("/data") {
|
||||
let id = uri
|
||||
.strip_prefix("test://template/")
|
||||
.and_then(|s| s.strip_suffix("/data"))
|
||||
.unwrap_or("unknown");
|
||||
Ok(ReadResourceResult {
|
||||
contents: vec![ResourceContents::TextResourceContents {
|
||||
uri: uri.into(),
|
||||
mime_type: Some("application/json".into()),
|
||||
text: format!(
|
||||
r#"{{"id":"{}","templateTest":true,"data":"Data for ID: {}"}}"#,
|
||||
id, id
|
||||
),
|
||||
meta: None,
|
||||
}],
|
||||
})
|
||||
} else {
|
||||
Err(ErrorData::resource_not_found(
|
||||
format!("Resource not found: {}", uri),
|
||||
None,
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn list_resource_templates(
|
||||
&self,
|
||||
_request: Option<PaginatedRequestParams>,
|
||||
_cx: RequestContext<RoleServer>,
|
||||
) -> impl Future<Output = Result<ListResourceTemplatesResult, ErrorData>> + Send + '_ {
|
||||
async {
|
||||
Ok(ListResourceTemplatesResult {
|
||||
meta: None,
|
||||
resource_templates: vec![
|
||||
RawResourceTemplate {
|
||||
uri_template: "test://template/{id}/data".into(),
|
||||
name: "Dynamic Resource".into(),
|
||||
title: None,
|
||||
description: Some("A dynamic resource with parameter substitution".into()),
|
||||
mime_type: Some("application/json".into()),
|
||||
icons: None,
|
||||
}
|
||||
.no_annotation(),
|
||||
],
|
||||
next_cursor: None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn subscribe(
|
||||
&self,
|
||||
request: SubscribeRequestParams,
|
||||
_cx: RequestContext<RoleServer>,
|
||||
) -> impl Future<Output = Result<(), ErrorData>> + Send + '_ {
|
||||
async move {
|
||||
let mut subs = self.subscriptions.lock().await;
|
||||
subs.insert(request.uri.to_string());
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn unsubscribe(
|
||||
&self,
|
||||
request: UnsubscribeRequestParams,
|
||||
_cx: RequestContext<RoleServer>,
|
||||
) -> impl Future<Output = Result<(), ErrorData>> + Send + '_ {
|
||||
async move {
|
||||
let mut subs = self.subscriptions.lock().await;
|
||||
subs.remove(request.uri.as_str());
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn list_prompts(
|
||||
&self,
|
||||
_request: Option<PaginatedRequestParams>,
|
||||
_cx: RequestContext<RoleServer>,
|
||||
) -> impl Future<Output = Result<ListPromptsResult, ErrorData>> + Send + '_ {
|
||||
async {
|
||||
Ok(ListPromptsResult {
|
||||
meta: None,
|
||||
prompts: vec![
|
||||
Prompt::new(
|
||||
"test_simple_prompt",
|
||||
Some("A simple test prompt with no arguments"),
|
||||
None,
|
||||
),
|
||||
Prompt::new(
|
||||
"test_prompt_with_arguments",
|
||||
Some("A test prompt that accepts arguments"),
|
||||
Some(vec![
|
||||
PromptArgument {
|
||||
name: "name".into(),
|
||||
title: None,
|
||||
description: Some("The name to greet".into()),
|
||||
required: Some(true),
|
||||
},
|
||||
PromptArgument {
|
||||
name: "style".into(),
|
||||
title: None,
|
||||
description: Some("The greeting style".into()),
|
||||
required: Some(false),
|
||||
},
|
||||
]),
|
||||
),
|
||||
Prompt::new(
|
||||
"test_prompt_with_embedded_resource",
|
||||
Some("A test prompt that includes an embedded resource"),
|
||||
None,
|
||||
),
|
||||
Prompt::new(
|
||||
"test_prompt_with_image",
|
||||
Some("A test prompt that includes an image"),
|
||||
None,
|
||||
),
|
||||
],
|
||||
next_cursor: None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn get_prompt(
|
||||
&self,
|
||||
request: GetPromptRequestParams,
|
||||
_cx: RequestContext<RoleServer>,
|
||||
) -> impl Future<Output = Result<GetPromptResult, ErrorData>> + Send + '_ {
|
||||
async move {
|
||||
match request.name.as_str() {
|
||||
"test_simple_prompt" => Ok(GetPromptResult {
|
||||
description: Some("A simple test prompt".into()),
|
||||
messages: vec![PromptMessage::new_text(
|
||||
PromptMessageRole::User,
|
||||
"This is a simple test prompt.",
|
||||
)],
|
||||
}),
|
||||
"test_prompt_with_arguments" => {
|
||||
let args = request.arguments.unwrap_or_default();
|
||||
let name = args.get("name").and_then(|v| v.as_str()).unwrap_or("World");
|
||||
let style = args
|
||||
.get("style")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("friendly");
|
||||
Ok(GetPromptResult {
|
||||
description: Some("A prompt with arguments".into()),
|
||||
messages: vec![PromptMessage::new_text(
|
||||
PromptMessageRole::User,
|
||||
format!("Please greet {} in a {} style.", name, style),
|
||||
)],
|
||||
})
|
||||
}
|
||||
"test_prompt_with_embedded_resource" => Ok(GetPromptResult {
|
||||
description: Some("A prompt with an embedded resource".into()),
|
||||
messages: vec![
|
||||
PromptMessage::new_text(PromptMessageRole::User, "Here is a resource:"),
|
||||
PromptMessage::new_resource(
|
||||
PromptMessageRole::User,
|
||||
"test://static-text".into(),
|
||||
Some("text/plain".into()),
|
||||
Some("Resource content for prompt".into()),
|
||||
None,
|
||||
None,
|
||||
None,
|
||||
),
|
||||
],
|
||||
}),
|
||||
"test_prompt_with_image" => {
|
||||
let image_content = RawImageContent {
|
||||
data: TEST_IMAGE_DATA.into(),
|
||||
mime_type: "image/png".into(),
|
||||
meta: None,
|
||||
};
|
||||
Ok(GetPromptResult {
|
||||
description: Some("A prompt with an image".into()),
|
||||
messages: vec![
|
||||
PromptMessage::new_text(PromptMessageRole::User, "Here is an image:"),
|
||||
PromptMessage {
|
||||
role: PromptMessageRole::User,
|
||||
content: PromptMessageContent::Image {
|
||||
image: image_content.no_annotation(),
|
||||
},
|
||||
},
|
||||
],
|
||||
})
|
||||
}
|
||||
_ => Err(ErrorData::invalid_params(
|
||||
format!("Unknown prompt: {}", request.name),
|
||||
None,
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn complete(
|
||||
&self,
|
||||
request: CompleteRequestParams,
|
||||
_cx: RequestContext<RoleServer>,
|
||||
) -> impl Future<Output = Result<CompleteResult, ErrorData>> + Send + '_ {
|
||||
async move {
|
||||
let values = match &request.r#ref {
|
||||
Reference::Resource(_) => {
|
||||
if request.argument.name == "id" {
|
||||
vec!["1".into(), "2".into(), "3".into()]
|
||||
} else {
|
||||
vec![]
|
||||
}
|
||||
}
|
||||
Reference::Prompt(prompt_ref) => {
|
||||
if request.argument.name == "name" {
|
||||
vec!["Alice".into(), "Bob".into(), "Charlie".into()]
|
||||
} else if request.argument.name == "style" {
|
||||
vec!["friendly".into(), "formal".into(), "casual".into()]
|
||||
} else {
|
||||
vec![prompt_ref.name.clone()]
|
||||
}
|
||||
}
|
||||
};
|
||||
Ok(CompleteResult {
|
||||
completion: CompletionInfo::new(values)
|
||||
.map_err(|e| ErrorData::internal_error(e, None))?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn set_level(
|
||||
&self,
|
||||
request: SetLevelRequestParams,
|
||||
_cx: RequestContext<RoleServer>,
|
||||
) -> impl Future<Output = Result<(), ErrorData>> + Send + '_ {
|
||||
async move {
|
||||
let mut level = self.log_level.lock().await;
|
||||
*level = request.level;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> anyhow::Result<()> {
|
||||
tracing_subscriber::fmt()
|
||||
.with_env_filter(EnvFilter::from_default_env().add_directive(tracing::Level::INFO.into()))
|
||||
.init();
|
||||
|
||||
let port: u16 = std::env::var("PORT")
|
||||
.ok()
|
||||
.and_then(|p| p.parse().ok())
|
||||
.unwrap_or(8001);
|
||||
|
||||
let bind_addr = format!("127.0.0.1:{}", port);
|
||||
tracing::info!("Starting conformance server on {}", bind_addr);
|
||||
|
||||
let server = ConformanceServer::new();
|
||||
let config = StreamableHttpServerConfig {
|
||||
stateful_mode: true,
|
||||
..Default::default()
|
||||
};
|
||||
let service = StreamableHttpService::new(
|
||||
move || Ok(server.clone()),
|
||||
LocalSessionManager::default().into(),
|
||||
config,
|
||||
);
|
||||
|
||||
let router = axum::Router::new().nest_service("/mcp", service);
|
||||
|
||||
let listener = tokio::net::TcpListener::bind(&bind_addr).await?;
|
||||
tracing::info!("Conformance server listening on http://{}/mcp", bind_addr);
|
||||
axum::serve(listener, router).await?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
Loading…
Reference in a new issue