Compare commits

...
Author SHA1 Message Date
bsodfather e359077f6e fix(mcp): update rmcp to 3.9.0 for RUSTSEC-2026-0462
CI / UI Checks (pull_request) Successful in 11s
CI / Rust Checks (pull_request) Successful in 32m46s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
CI / Deploy (pull_request) Skipped
2026-11-10 21:17:38 +00:00
bsodfather c0117ff6b8 Merge pull request 'refactor(mcp): migrate Prompts list/get through rmcp SDK' (#122) from delivery/rmcp107-prompts into main
CI / UI Checks (push) Successful in 13s
CI / Rust Checks (push) Successful in 31m52s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 5s
CI / Deploy (push) Skipped
Community Release / release (push) Failing after 12s
2026-11-10 19:51:33 +00:00
bsodfather 24bba2cf33 refactor(mcp): migrate Prompts requests and results through rmcp SDK
CI / UI Checks (pull_request) Successful in 11s
CI / Rust Checks (pull_request) Successful in 30m13s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Deploy (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
2026-11-10 19:17:54 +00:00
bsodfather f56553c4d6 Merge pull request 'refactor(mcp): Resources request/result runtime through rmcp SDK' (#121) from delivery/rmcp107-resources into main
CI / UI Checks (push) Successful in 12s
CI / Rust Checks (push) Successful in 25m54s
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 56m48s
2026-11-09 05:16:06 +00:00
bsodfather 027e2cb911 refactor(mcp): route Resources requests and results through rmcp SDK
CI / UI Checks (pull_request) Successful in 12s
CI / Rust Checks (pull_request) Successful in 30m41s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
CI / Deploy (pull_request) Skipped
2026-11-09 04:42:43 +00:00
bsodfather adabb2065a Merge pull request 'Serialize MCP Tools responses through rmcp SDK models (partial #107)' (#120) from delivery/rmcp107-tools-responses into main
CI / UI Checks (push) Successful in 8s
CI / Rust Checks (push) Successful in 33m25s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Successful in 51m19s
2026-11-08 23:19:11 +00:00
bsodfather bf773d61b8 feat(mcp): serialize Tools responses through rmcp SDK models
CI / UI Checks (pull_request) Successful in 10s
CI / Rust Checks (pull_request) Successful in 24m38s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
CI / Deploy (pull_request) Skipped
2026-11-08 22:52:00 +00:00
bsodfather 74a98d9362 Merge pull request 'Route existing MCP Tools requests through typed rmcp runtime seam (partial #107)' (#119) from feat/rmcp107-tools-runtime into main
CI / Rust Checks (push) Successful in 24m5s
CI / Rust Feature Validation (push) Skipped
CI / UI Checks (push) Successful in 7s
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
Community Release / release (push) Failing after 45m55s
2026-11-08 15:30:17 +00:00
bsodfather 7f18bce679 feat(mcp): route Tools requests through typed rmcp runtime seam
CI / Rust Checks (pull_request) Successful in 24m17s
CI / Rust Feature Validation (pull_request) Skipped
CI / UI Checks (pull_request) Successful in 7s
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
CI / Deploy (pull_request) Skipped
2026-11-08 15:00:22 +00:00
bsodfather 4ec9d9201b Merge pull request 'Use verified Trivy runner cache and avoid Cargo builds for release-only fixes' (#118) from fix/trivy-runner-cache-20261108 into main
CI / UI Checks (push) Successful in 14s
CI / Rust Checks (push) Failing after 1h39m35s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Failing after 1s
CI / Deploy (push) Skipped
2026-11-08 12:26:19 +00:00
bsodfather cf2909273b perf(ci): scope release tooling changes without unrelated Cargo builds
CI / UI Checks (pull_request) Successful in 8s
CI / Rust Checks (pull_request) Successful in 24m39s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
CI / Deploy (pull_request) Skipped
2026-11-08 14:47:35 +03:00
bsodfather 4a7b230f35 fix(ci): load checksum-verified Trivy from runner tool cache 2026-11-08 14:21:16 +03:00
bsodfather cfe11a0a04 Merge pull request 'fix(ci): download pinned Trivy asset through GitHub API on HTTP failure' (#117) from fix/trivy-asset-api-20261108 into main
CI / UI Checks (push) Successful in 14s
CI / Rust Checks (push) Failing after 17m52s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Failing after 2s
CI / Deploy (push) Skipped
2026-11-08 10:59:43 +00:00
bsodfather 35a21f8ab5 fix(ci): fall back to pinned GitHub asset API for Trivy
CI / UI Checks (pull_request) Successful in 11s
CI / Rust Checks (pull_request) Successful in 25m14s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
CI / Deploy (pull_request) Skipped
2026-11-08 13:02:56 +03:00
bsodfather 2d0deb8963 Merge pull request 'fix(ci): download Trivy database from reachable official registry' (#116) from fix/release-db-source-20261107 into main
CI / UI Checks (push) Successful in 14s
CI / Rust Checks (push) Successful in 25m23s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
2026-11-08 09:40:01 +00:00
22 changed files with 3269 additions and 175 deletions

No files matched your search

+13
View File
@@ -40,6 +40,15 @@ jobs:
with:
fetch-depth: 0
- name: Detect release-tooling-only changes
id: release_tooling
env:
GITEA_EVENT_NAME: ${{ gitea.event_name }}
GITEA_EVENT_BEFORE: ${{ gitea.event.before }}
GITEA_PR_BASE_SHA: ${{ gitea.event.pull_request.base.sha }}
FORCE_FULL: ${{ inputs.validation_level == 'feature' || contains(gitea.event.pull_request.labels.*.name, 'feature-ready') }}
run: python3 scripts/ci-release-tooling-scope.py
- name: Install Rust toolchain
run: |
set -eu
@@ -78,15 +87,18 @@ jobs:
docker info
- name: Check typed runtime configuration contract
if: steps.release_tooling.outputs.ci_only != 'true'
run: |
cargo run -p crank-config --bin crank-config-contract -- --check
python3 scripts/check-runtime-config.py --root .
python3 scripts/check-config-boundaries.py --root .
- name: Check canonical migration contract
if: steps.release_tooling.outputs.ci_only != 'true'
run: cargo run -p admin-api --bin crank-migrate -- plan --check
- name: Check typed metrics contract
if: steps.release_tooling.outputs.ci_only != 'true'
run: |
cargo run -p crank-metrics --bin crank-metrics-contract -- --check
python3 scripts/check-metrics-boundaries.py --root .
@@ -142,6 +154,7 @@ jobs:
python3 scripts/check-openapi-matrix-compatibility.py --base "$base_ref"
- name: Run Crank story ATDD
if: steps.release_tooling.outputs.ci_only != 'true'
run: scripts/ci-story-checks.sh
ui:
name: UI Checks
Generated
+10 -2
View File
@@ -590,6 +590,12 @@ dependencies = [
"tokio-util",
]
[[package]]
name = "const-oid"
version = "0.10.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "be95d4a884358a21a199689323c29e9256b4a1b315e22f183d155422041d3a9a"
[[package]]
name = "cookie"
version = "0.18.1"
@@ -1098,6 +1104,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
dependencies = [
"block-buffer 0.12.1",
"const-oid",
"crypto-common 0.2.2",
"ctutils",
]
@@ -3030,9 +3037,9 @@ dependencies = [
[[package]]
name = "rmcp"
version = "3.7.0"
version = "3.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ece64e19631fc38758181e637c15509a2c2709ee53bfde1e1d58f9dc991f919e"
checksum = "d24a7e92f4bcaa36b97fa93c4fa7ca8f3e669eced949345b3462dba333c7f909"
dependencies = [
"async-trait",
"base64 0.23.1",
@@ -3051,6 +3058,7 @@ dependencies = [
"schemars 1.2.1",
"serde",
"serde_json",
"sha2 0.11.0",
"sse-stream",
"thiserror 2.0.18",
"tokio",
+4 -1
View File
@@ -32,8 +32,11 @@ tokio = { workspace = true, features = ["sync"] }
tracing.workspace = true
uuid.workspace = true
# Typed Tools dispatch uses the SDK; its HTTP transport remains test-only.
rmcp = { version = "=3.9.0" }
[dev-dependencies]
rmcp = { version = "=3.7.0", features = ["transport-streamable-http-server"] }
rmcp = { version = "=3.9.0", features = ["transport-streamable-http-server"] }
crank-mapping = { path = "../crank-mapping" }
crank-test-support = { path = "../crank-test-support" }
metrics-util = "0.20.4"
+1
View File
@@ -34,6 +34,7 @@ pub(crate) mod lifecycle;
mod metrics;
mod request;
mod response;
mod rmcp_dispatch;
#[cfg(test)]
mod rmcp_http;
#[cfg(test)]
+39 -31
View File
@@ -7,6 +7,9 @@
use super::request::{InitializeParams, ToolCallParams};
use super::response::take_confirmation_token;
use super::rmcp_dispatch::{
handle_resources_command, handle_tools_command, list_resource_templates,
};
use crate::{
auth::VerifiedMachineCredential,
jsonrpc::{
@@ -18,8 +21,8 @@ use crate::{
PromptGetCommand, PromptsCommand, PromptsListCommand, PromptsOutcome, RequestIdentity,
ResourceReadCommand, ResourcesCommand, ResourcesListCommand, ResourcesOutcome,
ServiceContext, ToolCallCommand, ToolsCommand, ToolsListCommand, ToolsOutcome,
declared_mcp_method, discover_result, handle_completion_command, handle_prompts_command,
handle_resources_command, handle_tools_command, validate_modern_request_name,
declared_mcp_method, discover_result, handle_completion_command,
validate_modern_request_name,
},
session::SessionState,
tool_error::execution_locale,
@@ -42,7 +45,7 @@ use super::response::{
resource_templates_list_result, resources_list_result, tools_list_result,
};
use super::{AgentRoutePath, AppState, TRANSPORT_SESSION_TTL_MS};
use crate::protocol::{ResourceTemplatesListError, list_resource_templates};
use crate::protocol::ResourceTemplatesListError;
const SERVER_NAME: &str = "crank-mcp-server";
const SERVER_VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -160,19 +163,18 @@ pub(super) async fn handle_modern_request(
)
.await;
match outcome {
ToolsOutcome::List { tools, next_cursor } => transport_response(
StatusCode::OK,
jsonrpc_result(
request_id(message),
crate::protocol::project_modern_cacheable_result(
version,
tools_list_result(tools, next_cursor),
ToolsOutcome::List { tools, next_cursor } => {
match tools_list_result(tools, next_cursor, version) {
Ok(result) => transport_response(
StatusCode::OK,
jsonrpc_result(request_id(message), result),
response_mode,
None,
Some(version),
),
),
response_mode,
None,
Some(version),
),
Err(error) => internal_jsonrpc_error(message, error),
}
}
ToolsOutcome::InvalidParams(message_text) => transport_response(
StatusCode::OK,
jsonrpc_error(request_id(message), -32602, message_text),
@@ -286,10 +288,10 @@ pub(super) async fn handle_modern_request(
StatusCode::OK,
jsonrpc_result(
request_id(message),
crate::protocol::project_modern_cacheable_result(
version,
resources_list_result(resources, next_cursor),
),
match resources_list_result(resources, next_cursor, version) {
Ok(result) => result,
Err(error) => return internal_jsonrpc_error(message, error),
},
),
response_mode,
None,
@@ -345,10 +347,10 @@ pub(super) async fn handle_modern_request(
StatusCode::OK,
jsonrpc_result(
request_id(message),
crate::protocol::project_modern_cacheable_result(
version,
resource_read_result(contents),
),
match resource_read_result(contents, version) {
Ok(result) => result,
Err(error) => return internal_jsonrpc_error(message, error),
},
),
response_mode,
None,
@@ -434,10 +436,10 @@ pub(super) async fn handle_modern_request(
StatusCode::OK,
jsonrpc_result(
request_id(message),
crate::protocol::project_modern_cacheable_result(
version,
resource_templates_list_result(templates, next_cursor),
),
match resource_templates_list_result(templates, next_cursor, version) {
Ok(result) => result,
Err(error) => return internal_jsonrpc_error(message, error),
},
),
response_mode,
None,
@@ -466,7 +468,7 @@ pub(super) async fn handle_modern_request(
);
}
};
let outcome = handle_prompts_command(
let outcome = super::rmcp_dispatch::handle_prompts_command(
state,
resource_service_context(path, credential, transport_correlation, message),
version,
@@ -483,7 +485,10 @@ pub(super) async fn handle_modern_request(
request_id(message),
crate::protocol::project_modern_cacheable_result(
version,
prompts_list_result(prompts, next_cursor),
match prompts_list_result(prompts, next_cursor) {
Ok(result) => result,
Err(error) => return internal_jsonrpc_error(message, error),
},
),
),
response_mode,
@@ -525,7 +530,7 @@ pub(super) async fn handle_modern_request(
if let Err(response) = validate_modern_request_name(message, headers, &command.name) {
return *response;
}
let outcome = handle_prompts_command(
let outcome = super::rmcp_dispatch::handle_prompts_command(
state,
resource_service_context(path, credential, transport_correlation, message),
version,
@@ -542,7 +547,10 @@ pub(super) async fn handle_modern_request(
request_id(message),
crate::protocol::project_modern_result(
version,
prompt_get_result(description, messages),
match prompt_get_result(description, messages) {
Ok(result) => result,
Err(error) => return internal_jsonrpc_error(message, error),
},
),
),
response_mode,
@@ -51,9 +51,63 @@ pub(crate) struct CounterSet {
era_modern: AtomicUsize,
era_legacy: AtomicUsize,
tools_service: AtomicUsize,
sdk_tools_dispatch: AtomicUsize,
sdk_tools_list_result: AtomicUsize,
sdk_tools_call_result: AtomicUsize,
sdk_resources_dispatch: AtomicUsize,
sdk_resources_list_result: AtomicUsize,
sdk_resources_read_result: AtomicUsize,
sdk_resource_templates_list_result: AtomicUsize,
sdk_prompts_dispatch: AtomicUsize,
sdk_prompts_list_result: AtomicUsize,
sdk_prompts_get_result: AtomicUsize,
}
impl CounterSet {
pub(crate) fn sdk_prompts_dispatch(&self) -> usize {
self.sdk_prompts_dispatch.load(Ordering::SeqCst)
}
pub(crate) fn sdk_prompts_list_result(&self) -> usize {
self.sdk_prompts_list_result.load(Ordering::SeqCst)
}
pub(crate) fn sdk_prompts_get_result(&self) -> usize {
self.sdk_prompts_get_result.load(Ordering::SeqCst)
}
pub(crate) fn sdk_resources_dispatch(&self) -> usize {
self.sdk_resources_dispatch.load(Ordering::SeqCst)
}
pub(crate) fn sdk_resources_list_result(&self) -> usize {
self.sdk_resources_list_result.load(Ordering::SeqCst)
}
pub(crate) fn sdk_resources_read_result(&self) -> usize {
self.sdk_resources_read_result.load(Ordering::SeqCst)
}
pub(crate) fn sdk_resource_templates_list_result(&self) -> usize {
self.sdk_resource_templates_list_result
.load(Ordering::SeqCst)
}
/// SDK typed Tools dispatch entries, separate from the existing era/service snapshot.
pub(crate) fn sdk_tools_dispatch(&self) -> usize {
self.sdk_tools_dispatch.load(Ordering::SeqCst)
}
/// Successfully serialized SDK ListToolsResult values, not dispatch entries.
pub(crate) fn sdk_tools_list_result(&self) -> usize {
self.sdk_tools_list_result.load(Ordering::SeqCst)
}
/// Successfully serialized SDK CallToolResult values, not dispatch entries.
pub(crate) fn sdk_tools_call_result(&self) -> usize {
self.sdk_tools_call_result.load(Ordering::SeqCst)
}
/// Read the counters of one observed request as one comparable snapshot.
pub(crate) fn snapshot(&self) -> Snapshot {
Snapshot {
@@ -134,6 +188,64 @@ pub(crate) fn tools_service_enter() {
increment(|counters| &counters.tools_service);
}
/// `SDK_TOOLS_DISPATCH`: entered the real SDK typed Tools dispatch, not just admission.
pub(crate) fn sdk_tools_dispatch_enter() {
increment(|counters| &counters.sdk_tools_dispatch);
}
/// Mark only after serializing a real SDK ListToolsResult successfully.
pub(crate) fn sdk_tools_list_result_serialized() {
increment(|counters| &counters.sdk_tools_list_result);
}
/// Mark only after serializing a real SDK CallToolResult successfully.
pub(crate) fn sdk_tools_call_result_serialized() {
increment(|counters| &counters.sdk_tools_call_result);
}
/// Mark only after converting a Resources request through the real SDK typed path.
pub(crate) fn sdk_resources_dispatch_enter() {
increment(|counters| &counters.sdk_resources_dispatch);
}
/// Mark only after successfully serializing a real SDK ListResourcesResult.
pub(crate) fn sdk_resources_list_result_serialized() {
increment(|counters| &counters.sdk_resources_list_result);
}
/// Mark only after successfully serializing a real SDK ReadResourceResult.
pub(crate) fn sdk_resources_read_result_serialized() {
increment(|counters| &counters.sdk_resources_read_result);
}
/// Mark only after successfully serializing a real SDK ListResourceTemplatesResult.
pub(crate) fn sdk_resource_templates_list_result_serialized() {
increment(|counters| &counters.sdk_resource_templates_list_result);
}
#[cfg(test)]
#[path = "../rmcp_resources_runtime_tests.rs"]
mod rmcp_resources_runtime_tests;
/// 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);
}
/// Mark only after successfully serializing a real SDK ListPromptsResult.
pub(crate) fn sdk_prompts_list_result_serialized() {
increment(|counters| &counters.sdk_prompts_list_result);
}
/// Mark only after successfully serializing a real SDK GetPromptResult.
pub(crate) fn sdk_prompts_get_result_serialized() {
increment(|counters| &counters.sdk_prompts_get_result);
}
#[cfg(test)]
#[path = "../rmcp_prompts_runtime_tests.rs"]
mod rmcp_prompts_runtime_tests;
fn increment(counter: impl Fn(&CounterSet) -> &AtomicUsize) {
let _ = OBSERVER.try_with(|counters| {
counter(counters).fetch_add(1, Ordering::SeqCst);
@@ -153,3 +265,7 @@ pub(crate) mod support;
#[cfg(test)]
#[path = "../dispatch_observer_harness.rs"]
mod tests;
#[cfg(test)]
#[path = "../rmcp_runtime_tests.rs"]
mod rmcp_runtime_tests;
@@ -24,6 +24,9 @@ use super::response::{
resource_templates_list_result, resources_list_result, take_confirmation_token,
tools_list_result,
};
use super::rmcp_dispatch::{
handle_resources_command, handle_tools_command, list_resource_templates,
};
use super::{AgentRoutePath, AppState};
use crate::{
auth::VerifiedMachineCredential,
@@ -37,8 +40,7 @@ use crate::{
PromptsCommand, PromptsListCommand, PromptsOutcome, RequestIdentity, ResourceReadCommand,
ResourcesCommand, ResourcesListCommand, ResourcesOutcome, ServiceContext, SetLevelCommand,
ToolCallCommand, ToolsCommand, ToolsListCommand, ToolsOutcome, handle_completion_command,
handle_logging_command, handle_prompts_command, handle_resources_command,
handle_tools_command,
handle_logging_command,
},
tool_error::execution_locale,
transport::{ResponseMode, session_id_from_headers, transport_response},
@@ -143,13 +145,18 @@ pub(super) async fn handle_legacy_request(
)
.await;
match outcome {
ToolsOutcome::List { tools, next_cursor } => transport_response(
StatusCode::OK,
jsonrpc_result(request_id(message), tools_list_result(tools, next_cursor)),
response_mode,
None,
Some(&session.protocol_version),
),
ToolsOutcome::List { tools, next_cursor } => {
match tools_list_result(tools, next_cursor, &session.protocol_version) {
Ok(result) => transport_response(
StatusCode::OK,
jsonrpc_result(request_id(message), result),
response_mode,
None,
Some(&session.protocol_version),
),
Err(error) => internal_jsonrpc_error(message, error),
}
}
ToolsOutcome::InvalidParams(message_text) => transport_response(
StatusCode::OK,
jsonrpc_error(request_id(message), -32602, message_text),
@@ -278,7 +285,14 @@ pub(super) async fn handle_legacy_request(
StatusCode::OK,
jsonrpc_result(
request_id(message),
resources_list_result(resources, next_cursor),
match resources_list_result(
resources,
next_cursor,
&session.protocol_version,
) {
Ok(result) => result,
Err(error) => return internal_jsonrpc_error(message, error),
},
),
response_mode,
None,
@@ -335,7 +349,13 @@ pub(super) async fn handle_legacy_request(
match outcome {
ResourcesOutcome::Read { contents } => transport_response(
StatusCode::OK,
jsonrpc_result(request_id(message), resource_read_result(contents)),
jsonrpc_result(
request_id(message),
match resource_read_result(contents, &session.protocol_version) {
Ok(result) => result,
Err(error) => return internal_jsonrpc_error(message, error),
},
),
response_mode,
None,
Some(&session.protocol_version),
@@ -394,7 +414,7 @@ pub(super) async fn handle_legacy_request(
);
}
};
let (templates, next_cursor) = match crate::protocol::list_resource_templates(
let (templates, next_cursor) = match list_resource_templates(
&state,
&path.workspace_slug,
&path.agent_slug,
@@ -425,7 +445,14 @@ pub(super) async fn handle_legacy_request(
StatusCode::OK,
jsonrpc_result(
request_id(message),
resource_templates_list_result(templates, next_cursor),
match resource_templates_list_result(
templates,
next_cursor,
&session.protocol_version,
) {
Ok(result) => result,
Err(error) => return internal_jsonrpc_error(message, error),
},
),
response_mode,
None,
@@ -458,7 +485,7 @@ pub(super) async fn handle_legacy_request(
);
}
};
let outcome = handle_prompts_command(
let outcome = super::rmcp_dispatch::handle_prompts_command(
&state,
ServiceContext {
workspace_slug: &session.workspace_slug,
@@ -480,7 +507,10 @@ pub(super) async fn handle_legacy_request(
StatusCode::OK,
jsonrpc_result(
request_id(message),
prompts_list_result(prompts, next_cursor),
match prompts_list_result(prompts, next_cursor) {
Ok(result) => result,
Err(error) => return internal_jsonrpc_error(message, error),
},
),
response_mode,
None,
@@ -520,7 +550,7 @@ pub(super) async fn handle_legacy_request(
);
}
};
let outcome = handle_prompts_command(
let outcome = super::rmcp_dispatch::handle_prompts_command(
&state,
ServiceContext {
workspace_slug: &session.workspace_slug,
@@ -542,7 +572,10 @@ pub(super) async fn handle_legacy_request(
StatusCode::OK,
jsonrpc_result(
request_id(message),
prompt_get_result(description, messages),
match prompt_get_result(description, messages) {
Ok(result) => result,
Err(error) => return internal_jsonrpc_error(message, error),
},
),
response_mode,
None,
@@ -37,16 +37,14 @@ use futures_util::stream;
use serde_json::{Number, Value, json};
use tokio::sync::{mpsc, watch};
use super::rmcp_dispatch::handle_tools_command;
use super::{
AppState,
response::{ToolCommandPayload, tool_command_payload, tool_command_response},
};
use crate::{
jsonrpc::request_id,
protocol::{
ContinuationSupport, ServiceContext, ToolCallCommand, ToolsCommand, ToolsOutcome,
handle_tools_command,
},
protocol::{ContinuationSupport, ServiceContext, ToolCallCommand, ToolsCommand, ToolsOutcome},
transport::{ResponseMode, sse_response},
};
+442 -77
View File
@@ -1,9 +1,9 @@
use axum::{http::StatusCode, response::Response};
use rmcp::model::{CacheScope, CallToolResult, ContentBlock, ListToolsResult, ResultType, Tool};
use serde_json::{Value, json};
use crate::{
jsonrpc::{jsonrpc_result, request_id},
protocol::project_modern_result,
tool_error::{ToolErrorContract, tool_error_text, tool_error_value},
transport::{ResponseMode, transport_response},
};
@@ -30,22 +30,7 @@ pub(super) fn success_tool_payload(
protocol_version: &str,
output: Value,
) -> Value {
jsonrpc_result(
request_id(message),
project_modern_result(
protocol_version,
json!({
"content": [
{
"type": "text",
"text": serde_json::to_string_pretty(&output).unwrap_or_else(|_| "{}".to_owned())
}
],
"structuredContent": output,
"isError": false
}),
),
)
call_result_payload(message, protocol_version, sdk_success_tool_result(output))
}
#[cfg(test)]
@@ -69,85 +54,273 @@ pub(super) fn tool_error_payload(
protocol_version: &str,
error: ToolErrorContract,
) -> Value {
let error_message = tool_error_text(&error);
let error_value = tool_error_value(&error);
jsonrpc_result(
request_id(message),
project_modern_result(
protocol_version,
json!({
"content": [
{
"type": "text",
"text": error_message
}
],
"structuredContent": {
"error": error_value
},
"isError": true
}),
),
)
call_result_payload(message, protocol_version, sdk_error_tool_result(error))
}
/// The era-neutral `tools/list` result shape built from the shared command outcome. Object keys end
/// up byte-lexicographically ordered, exactly as before the extraction.
pub(super) fn tools_list_result(tools: Vec<Value>, next_cursor: Option<String>) -> Value {
let mut result = json!({ "tools": tools });
if let Some(next_cursor) = next_cursor {
result["nextCursor"] = Value::String(next_cursor);
}
pub(super) fn sdk_success_tool_result(output: Value) -> CallToolResult {
let text = serde_json::to_string_pretty(&output).expect("JSON value serializes");
let mut result = CallToolResult::success(vec![ContentBlock::text(text)]);
result.structured_content = Some(output);
result
}
/// The era-neutral `resources/list` result shape (Story 3.8). Same pagination wire keys as
/// `tools/list`; `nextCursor` is absent on the last page.
pub(super) fn resources_list_result(resources: Vec<Value>, next_cursor: Option<String>) -> Value {
let mut result = json!({ "resources": resources });
if let Some(next_cursor) = next_cursor {
result["nextCursor"] = Value::String(next_cursor);
}
pub(super) fn sdk_error_tool_result(error: ToolErrorContract) -> CallToolResult {
let mut result = CallToolResult::error(vec![ContentBlock::text(tool_error_text(&error))]);
result.structured_content = Some(json!({ "error": tool_error_value(&error) }));
result
}
/// The era-neutral `resources/read` result shape: exactly the typed `contents[]` the revision
/// converter produced.
pub(super) fn resource_read_result(contents: Value) -> Value {
json!({ "contents": contents })
fn call_result_payload(message: &Value, version: &str, mut result: CallToolResult) -> Value {
result.result_type =
(version == crate::jsonrpc::MODERN_PROTOCOL_VERSION).then_some(ResultType::COMPLETE);
let result = serde_json::to_value(result).expect("SDK call result contains JSON values");
#[cfg(test)]
super::dispatch_observer::sdk_tools_call_result_serialized();
jsonrpc_result(request_id(message), result)
}
pub(super) fn sdk_tools_list_result(
tools: &[Value],
next_cursor: Option<String>,
) -> Result<ListToolsResult, serde_json::Error> {
Ok(ListToolsResult {
tools: tools
.iter()
.cloned()
.map(serde_json::from_value::<Tool>)
.collect::<Result<Vec<_>, _>>()?,
next_cursor,
..Default::default()
})
}
/// Serialize the SDK model, preserving catalog extensions that pinned Tool serde cannot represent.
pub(super) fn tools_list_result(
tools: Vec<Value>,
next_cursor: Option<String>,
version: &str,
) -> Result<Value, serde_json::Error> {
let mut result = sdk_tools_list_result(&tools, next_cursor)?;
let modern = version == crate::jsonrpc::MODERN_PROTOCOL_VERSION;
result.result_type = modern.then_some(ResultType::COMPLETE);
result.ttl_ms = modern.then_some(0);
result.cache_scope = modern.then_some(CacheScope::Private);
let mut result = serde_json::to_value(result)?;
#[cfg(test)]
super::dispatch_observer::sdk_tools_list_result_serialized();
for (raw, serialized) in tools
.iter()
.zip(result["tools"].as_array_mut().expect("SDK tools array"))
{
let serialized = serialized.as_object_mut().expect("SDK Tool object");
for (key, value) in raw.as_object().expect("validated Tool object") {
if matches!(key.as_str(), "annotations" | "icons")
|| !matches!(
key.as_str(),
"name" | "title" | "description" | "inputSchema" | "outputSchema" | "_meta"
)
|| value.is_null()
{
serialized.insert(key.clone(), value.clone());
}
}
}
Ok(result)
}
/// SDK results are serialized before the minimal lossless projection of descriptor extensions.
pub(super) fn resources_list_result(
resources: Vec<Value>,
next_cursor: Option<String>,
version: &str,
) -> Result<Value, serde_json::Error> {
let modern = version == crate::jsonrpc::MODERN_PROTOCOL_VERSION;
let result = rmcp::model::ListResourcesResult {
resources: resources
.iter()
.cloned()
.map(serde_json::from_value)
.collect::<Result<_, _>>()?,
next_cursor,
result_type: modern.then_some(ResultType::COMPLETE),
ttl_ms: modern.then_some(0),
cache_scope: modern.then_some(CacheScope::Private),
meta: None,
};
let mut result = serde_json::to_value(result)?;
#[cfg(test)]
super::dispatch_observer::sdk_resources_list_result_serialized();
preserve_resource_fields(
&resources,
&mut result["resources"],
&[
"uri",
"name",
"title",
"description",
"mimeType",
"size",
"_meta",
],
);
Ok(result)
}
pub(super) fn resource_read_result(
contents: Value,
version: &str,
) -> Result<Value, serde_json::Error> {
let mut result =
rmcp::model::ReadResourceResult::new(serde_json::from_value(contents.clone())?);
let modern = version == crate::jsonrpc::MODERN_PROTOCOL_VERSION;
result.result_type = modern.then_some(ResultType::COMPLETE);
result.ttl_ms = modern.then_some(0);
result.cache_scope = modern.then_some(CacheScope::Private);
let mut result = serde_json::to_value(result)?;
#[cfg(test)]
super::dispatch_observer::sdk_resources_read_result_serialized();
preserve_resource_fields(
contents.as_array().expect("validated contents array"),
&mut result["contents"],
&["uri", "mimeType", "text", "blob", "_meta"],
);
Ok(result)
}
/// The era-neutral `resources/templates/list` result shape.
pub(super) fn resource_templates_list_result(
templates: Vec<Value>,
next_cursor: Option<String>,
) -> Value {
let mut result = json!({ "resourceTemplates": templates });
if let Some(cursor) = next_cursor {
result["nextCursor"] = Value::String(cursor);
}
result
version: &str,
) -> Result<Value, serde_json::Error> {
let modern = version == crate::jsonrpc::MODERN_PROTOCOL_VERSION;
let result = rmcp::model::ListResourceTemplatesResult {
resource_templates: templates
.iter()
.cloned()
.map(serde_json::from_value)
.collect::<Result<_, _>>()?,
next_cursor,
result_type: modern.then_some(ResultType::COMPLETE),
ttl_ms: modern.then_some(0),
cache_scope: modern.then_some(CacheScope::Private),
meta: None,
};
let mut result = serde_json::to_value(result)?;
#[cfg(test)]
super::dispatch_observer::sdk_resource_templates_list_result_serialized();
preserve_resource_fields(
&templates,
&mut result["resourceTemplates"],
&[
"uriTemplate",
"name",
"title",
"description",
"mimeType",
"_meta",
],
);
Ok(result)
}
/// The era-neutral `prompts/list` result shape (Story 3.14). Same pagination wire keys as
/// `resources/list`; `nextCursor` is absent on the last page.
pub(super) fn prompts_list_result(prompts: Vec<Value>, next_cursor: Option<String>) -> Value {
let mut result = json!({ "prompts": prompts });
if let Some(cursor) = next_cursor {
result["nextCursor"] = Value::String(cursor);
// 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());
}
}
}
result
}
/// The era-neutral `prompts/get` result shape: the rendered `messages[]` and the description of the
/// exact bound Published Prompt Version it came from.
pub(super) fn prompt_get_result(description: Option<String>, messages: Vec<Value>) -> Value {
let mut result = json!({ "messages": messages });
if let Some(description) = description {
result["description"] = Value::String(description);
/// 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"],
);
}
}
result
#[cfg(test)]
super::dispatch_observer::sdk_prompts_list_result_serialized();
Ok(result)
}
/// Preserve Crank's system role, which the pinned SDK's user/assistant Role cannot express.
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());
}
}
}
#[cfg(test)]
super::dispatch_observer::sdk_prompts_get_result_serialized();
Ok(result)
}
/// The era-neutral `completion/complete` result shape (Story 3.17): the bounded `values[]`, the
@@ -310,3 +483,195 @@ pub(super) fn internal_jsonrpc_error(message: &Value, _error: impl std::fmt::Dis
None,
)
}
#[cfg(test)]
mod sdk_result_tests {
use super::*;
use crate::jsonrpc::{LEGACY_PROTOCOL_VERSION, MODERN_PROTOCOL_VERSION};
#[test]
fn prompts_sdk_projection_preserves_typed_extensions_and_system_content() {
let prompt = json!({"name":"p", "description":null, "icons":null,
"x-prompt":{}, "arguments":[{"name":"count", "description":null,
"required":false, "schema":{"type":"integer"}, "default":7}]});
for cursor in [None, Some(String::new()), Some("opaque".to_owned())] {
let result = prompts_list_result(vec![prompt.clone()], cursor.clone()).unwrap();
assert_eq!(result["prompts"], json!([prompt]));
assert_eq!(result.get("nextCursor"), cursor.map(Value::String).as_ref());
assert!(result.get("resultType").is_none());
}
let messages = vec![
json!({"role":"system", "x-message":null,
"content":{"type":"text", "text":"\0é\n", "annotations":null, "x-content":[]}}),
json!({"role":"assistant", "content":{"type":"text", "text":""}}),
];
assert_eq!(
prompt_get_result(None, messages.clone()).unwrap(),
json!({"messages":messages})
);
assert_eq!(
prompts_list_result(vec![], None).unwrap(),
json!({"prompts":[]})
);
assert_eq!(
prompt_get_result(Some(String::new()), vec![]).unwrap(),
json!({"description":"", "messages":[]})
);
assert!(prompts_list_result(vec![json!({"name":42})], None).is_err());
assert!(
prompt_get_result(
None,
vec![json!({"role":"invalid", "content":{"type":"text", "text":"secret"}})]
)
.is_err()
);
}
#[test]
fn resources_sdk_projection_is_lossless_for_templates_contents_and_catalog() {
for version in [LEGACY_PROTOCOL_VERSION, MODERN_PROTOCOL_VERSION] {
for optional in [Value::Null, json!({}), json!({"x-extension":[null,{}]})] {
let raw = json!({"uri":"crank://r","name":"r","description":null,
"mimeType":"text/plain","_meta":optional,"x-resource":[],
"annotations":{"x-nested":null},"icons":[{"src":"icon","x-icon":{}}]});
for cursor in [None, Some(String::new()), Some("opaque".to_owned())] {
let list =
resources_list_result(vec![raw.clone()], cursor.clone(), version).unwrap();
assert_eq!(list["resources"], json!([raw]));
assert_eq!(
list.get("nextCursor"),
cursor.as_ref().map(|s| json!(s)).as_ref()
);
assert_eq!(
list.get("resultType").is_some(),
version == MODERN_PROTOCOL_VERSION
);
assert_eq!(
list.get("ttlMs").is_some(),
version == MODERN_PROTOCOL_VERSION
);
assert_eq!(
list.get("cacheScope").is_some(),
version == MODERN_PROTOCOL_VERSION
);
assert!(list.get("_meta").is_none());
let template = json!({"uriTemplate":"crank://r/{id}","name":"r",
"description":null,"mimeType":null,"_meta":optional,
"parameters":[{"name":"id","required":true,"opaque":null}],
"annotations":{"x-nested":[]},"icons":null});
let list = resource_templates_list_result(
vec![template.clone()],
cursor.clone(),
version,
)
.unwrap();
assert_eq!(list["resourceTemplates"], json!([template]));
assert_eq!(
list.get("nextCursor"),
cursor.as_ref().map(|s| json!(s)).as_ref()
);
}
let contents = json!([
{"uri":"crank://r","mimeType":null,"text":"\0é\n","_meta":optional,"x-content":[]},
{"uri":"crank://b","mimeType":"application/octet-stream","blob":"AP8=","_meta":null}
]);
assert_eq!(
resource_read_result(contents.clone(), version).unwrap()["contents"],
contents
);
}
assert_eq!(
resources_list_result(vec![], None, version).unwrap()["resources"],
json!([])
);
assert_eq!(
resource_templates_list_result(vec![], None, version).unwrap()["resourceTemplates"],
json!([])
);
assert_eq!(
resource_read_result(json!([]), version).unwrap()["contents"],
json!([])
);
assert!(resources_list_result(vec![json!({"uri":42})], None, version).is_err());
assert!(
resource_templates_list_result(vec![json!({"name":"r"})], None, version).is_err()
);
assert!(resource_read_result(json!([{"uri":"r"}]), version).is_err());
}
}
#[test]
fn catalog_projection_preserves_extensions_null_and_empty() {
let descriptor = json!({
"name":"tool", "title":"", "description":null,
"inputSchema":{"type":"object", "x-schema":{"nested":null}},
"outputSchema":{"type":"object", "x-output":[]},
"_meta":{"custom":{"empty":{}}}, "x-tool":{"nested":[]},
"annotations":{"readOnlyHint":true,"x-annotation":{"nested":null}},
"icons":[{"src":"https://example.test/icon", "x-icon":{"nested":[]}}]
});
for version in [LEGACY_PROTOCOL_VERSION, MODERN_PROTOCOL_VERSION] {
for raw in [
descriptor.clone(),
json!({"name":"tool","inputSchema":{},
"title":null,"description":"","outputSchema":null,"_meta":null,
"annotations":null,"icons":null}),
json!({"name":"tool","inputSchema":{},
"annotations":{},"icons":[]}),
] {
for cursor in [None, Some(String::new()), Some("next".to_owned())] {
let value =
tools_list_result(vec![raw.clone()], cursor.clone(), version).unwrap();
assert_eq!(value["tools"], json!([raw]));
assert_eq!(
value.get("nextCursor"),
cursor.as_ref().map(|s| Value::String(s.clone())).as_ref()
);
assert_eq!(
value.get("resultType").is_some(),
version == MODERN_PROTOCOL_VERSION
);
assert_eq!(
value.get("ttlMs").is_some(),
version == MODERN_PROTOCOL_VERSION
);
assert_eq!(
value.get("cacheScope").is_some(),
version == MODERN_PROTOCOL_VERSION
);
}
}
assert_eq!(
tools_list_result(vec![], None, version).unwrap()["tools"],
json!([])
);
assert!(tools_list_result(vec![json!({"name":42})], None, version).is_err());
}
}
#[test]
fn null_success_and_rpc_failures_keep_their_distinct_shapes() {
for version in [LEGACY_PROTOCOL_VERSION, MODERN_PROTOCOL_VERSION] {
let message = json!({"id":9007199254740993_u64});
let payload = success_tool_payload(&message, version, Value::Null);
assert_eq!(payload["id"], message["id"]);
assert_eq!(
payload["result"]["content"],
json!([{"type":"text","text":"null"}])
);
assert_eq!(
payload["result"].get("structuredContent"),
Some(&Value::Null)
);
assert_eq!(payload["result"]["isError"], false);
let correlation = CorrelationContext::generate();
let internal = tool_command_payload(
&message,
version,
&correlation,
ToolsOutcome::Call(ToolCallOutcome::InternalFailure),
);
assert!(matches!(internal, ToolCommandPayload::Internal(_)));
}
}
}
@@ -0,0 +1,140 @@
//! Runtime SDK dispatch; admission, lifecycle and response projection stay with the caller.
use std::sync::Arc;
use rmcp::model::{CallToolRequestParams, PaginatedRequestParams, ReadResourceRequestParams};
use serde_json::Value;
use super::{AppState, lifecycle::ToolCallLifecycle};
use crate::protocol::{
ServiceContext, ToolCallCommand, ToolCallOutcome, ToolsCommand, ToolsListCommand, ToolsOutcome,
};
// Crank extensions are not SDK fields and must survive the typed request boundary unchanged.
enum SdkToolsCommand {
List {
params: PaginatedRequestParams,
limit: Option<usize>,
},
Call {
params: CallToolRequestParams,
confirmation_token: Option<String>,
},
}
pub(super) async fn handle_tools_command(
state: &Arc<AppState>,
context: ServiceContext<'_>,
command: ToolsCommand,
lifecycle: Option<ToolCallLifecycle>,
) -> ToolsOutcome {
let request = match command {
ToolsCommand::List(list) => SdkToolsCommand::List {
params: PaginatedRequestParams::default().with_cursor(list.cursor),
limit: list.limit,
},
ToolsCommand::Call(call) => {
let Value::Object(arguments) = call.arguments else {
return ToolsOutcome::Call(ToolCallOutcome::InvalidParams(
"tool arguments must be an object".to_owned(),
));
};
SdkToolsCommand::Call {
params: CallToolRequestParams::new(call.tool_name).with_arguments(arguments),
confirmation_token: call.confirmation_token,
}
}
};
#[cfg(test)]
super::dispatch_observer::sdk_tools_dispatch_enter();
let command = match request {
SdkToolsCommand::List { params, limit } => ToolsCommand::List(ToolsListCommand {
cursor: params.cursor,
limit,
}),
SdkToolsCommand::Call {
params,
confirmation_token,
} => ToolsCommand::Call(ToolCallCommand {
tool_name: params.name.into_owned(),
arguments: Value::Object(params.arguments.unwrap_or_default()),
confirmation_token,
}),
};
crate::protocol::handle_tools_command(state, context, command, lifecycle).await
}
pub(super) async fn handle_prompts_command(
state: &Arc<AppState>,
context: ServiceContext<'_>,
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
}
pub(super) async fn handle_resources_command(
state: &Arc<AppState>,
context: ServiceContext<'_>,
revision: &str,
command: crate::protocol::ResourcesCommand,
) -> crate::protocol::ResourcesOutcome {
use crate::protocol::{ResourceReadCommand, ResourcesCommand};
let command = match command {
ResourcesCommand::List(list) => ResourcesCommand::List(sdk_resource_page(list)),
ResourcesCommand::Read(read) => {
let params = ReadResourceRequestParams::new(read.uri);
ResourcesCommand::Read(ResourceReadCommand { uri: params.uri })
}
};
#[cfg(test)]
super::dispatch_observer::sdk_resources_dispatch_enter();
crate::protocol::handle_resources_command(state, context, revision, command).await
}
pub(super) async fn list_resource_templates(
state: &Arc<AppState>,
workspace_slug: &str,
agent_slug: &str,
revision: &str,
command: crate::protocol::ResourcesListCommand,
) -> Result<(Vec<Value>, Option<String>), crate::protocol::ResourceTemplatesListError> {
let command = sdk_resource_page(command);
#[cfg(test)]
super::dispatch_observer::sdk_resources_dispatch_enter();
crate::protocol::list_resource_templates(state, workspace_slug, agent_slug, revision, command)
.await
}
fn sdk_resource_page(
list: crate::protocol::ResourcesListCommand,
) -> crate::protocol::ResourcesListCommand {
let params = PaginatedRequestParams::default().with_cursor(list.cursor);
// Crank's page limit is not an SDK field; retain its existing validation and clamping.
crate::protocol::ResourcesListCommand {
cursor: params.cursor,
limit: list.limit,
}
}
@@ -90,10 +90,7 @@ impl RmcpTools {
}
}
use rmcp::ErrorData as McpError;
use rmcp::model::{
CallToolRequestParams, CallToolResult, ContentBlock, ListToolsResult, PaginatedRequestParams,
Tool,
};
use rmcp::model::{CallToolRequestParams, ListToolsResult, PaginatedRequestParams};
use rmcp::service::RequestContext;
use rmcp::{RoleServer, ServerHandler};
@@ -138,18 +135,8 @@ impl ServerHandler for RmcpTools {
};
match self.list_tools(&identity, command, None).await {
crate::protocol::ToolsOutcome::List { tools, next_cursor } => {
let tools = tools
.into_iter()
.map(serde_json::from_value::<Tool>)
.collect::<Result<Vec<_>, _>>()
.map_err(|_| {
McpError::internal_error("invalid tool catalog entry", None)
})?;
Ok(ListToolsResult {
tools,
next_cursor,
..Default::default()
})
super::response::sdk_tools_list_result(&tools, next_cursor)
.map_err(|_| McpError::internal_error("invalid tool catalog entry", None))
}
crate::protocol::ToolsOutcome::InvalidParams(message) => {
Err(McpError::invalid_params(message, None))
@@ -223,27 +210,24 @@ impl ServerHandler for RmcpTools {
crate::protocol::ToolsOutcome::Call(outcome) => match outcome {
crate::protocol::ToolCallOutcome::Completed(value)
| crate::protocol::ToolCallOutcome::ApprovalPending(value) => {
let text = value.to_string();
let mut result = CallToolResult::default();
result.content = vec![ContentBlock::text(text)];
result.structured_content = if value.is_null() { None } else { Some(value) };
Ok(result.into())
Ok(super::response::sdk_success_tool_result(value).into())
}
crate::protocol::ToolCallOutcome::ApprovalUnavailable(_) => {
let mut result = CallToolResult::default();
result.is_error = Some(true);
result.content = vec![ContentBlock::text("approval elicitation not supported")];
Ok(result.into())
crate::protocol::ToolCallOutcome::ApprovalUnavailable(error) => {
Ok(super::response::sdk_error_tool_result(
crate::tool_error::control_tool_error_contract(
error,
identity.correlation.request_id().as_str(),
identity.correlation.trace_id().as_str(),
identity.locale,
),
)
.into())
}
crate::protocol::ToolCallOutcome::InvalidParams(message) => {
Err(McpError::invalid_params(message, None))
}
crate::protocol::ToolCallOutcome::Error(contract) => {
let text = serde_json::to_string(&contract).unwrap_or_default();
let mut result = CallToolResult::default();
result.is_error = Some(true);
result.content = vec![ContentBlock::text(text)];
Ok(result.into())
Ok(super::response::sdk_error_tool_result(contract).into())
}
crate::protocol::ToolCallOutcome::InternalFailure => {
Err(McpError::internal_error("tool execution failed", None))
@@ -0,0 +1,436 @@
//! #107 Prompts: existing wire GREEN and an independent SDK typed-path RED oracle.
use super::{CounterSet, observe, support::*};
use axum::{body::Body, response::Response};
use futures_util::{StreamExt, stream};
use serde_json::{Value, json};
use std::{sync::Arc, time::Duration};
#[path = "rmcp_prompts_test_support.rs"]
mod fixtures;
use fixtures::Endpoint;
fn observe_body(response: Response, counters: Arc<CounterSet>) -> Response {
let (parts, body) = response.into_parts();
let body = stream::unfold(
(body.into_data_stream(), counters),
|(mut body, counters)| async move {
observe(counters.clone(), body.next())
.await
.map(|chunk| (chunk, (body, counters)))
},
);
Response::from_parts(parts, Body::from_stream(body))
}
fn counts(c: &CounterSet) -> [usize; 3] {
[
c.sdk_prompts_dispatch(),
c.sdk_prompts_list_result(),
c.sdk_prompts_get_result(),
]
}
fn request(revision: &str, method: &str, mut params: Value) -> Value {
if revision == MODERN_REVISION {
params["_meta"] = modern_meta();
}
json!({"jsonrpc":"2.0","id":9007199254740993_u64,"method":method,"params":params})
}
async fn wire(response: reqwest::Response, id: &Value, sse: bool) -> Value {
assert_eq!(response.status(), 200);
assert_eq!(response.headers()["x-request-id"], "sdk-prompts-wire");
assert_eq!(
response.headers()["x-trace-id"],
"11111111111111111111111111111111"
);
let content_type = response.headers()["content-type"]
.to_str()
.unwrap()
.to_owned();
let text = tokio::time::timeout(Duration::from_secs(5), response.text())
.await
.unwrap()
.unwrap();
let body: Value = if sse {
assert!(
content_type.starts_with("text/event-stream"),
"{content_type}: {text}"
);
let frames: Vec<Value> = text
.lines()
.filter_map(|line| {
line.strip_prefix("data:")
.map(|s| serde_json::from_str(s.trim()).unwrap())
})
.collect();
let terminal: Vec<_> = frames.iter().filter(|f| f.get("id") == Some(id)).collect();
assert_eq!(terminal.len(), 1, "{frames:?}");
assert_eq!(frames.last(), Some(terminal[0]), "terminal must be last");
terminal[0].clone()
} else {
assert!(
content_type.starts_with("application/json"),
"{content_type}: {text}"
);
serde_json::from_str(&text).unwrap()
};
assert_eq!(body["jsonrpc"], "2.0");
assert_eq!(&body["id"], id);
body
}
fn era(result: &Value, revision: &str, method: &str) {
if revision == MODERN_REVISION {
assert_eq!(result["resultType"], "complete", "{result}");
if method == "prompts/list" {
assert_eq!(result["ttlMs"], 0);
assert_eq!(result["cacheScope"], "private");
} else {
assert!(result.get("ttlMs").is_none(), "{result}");
assert!(result.get("cacheScope").is_none(), "{result}");
}
} else {
for key in ["resultType", "ttlMs", "cacheScope"] {
assert!(result.get(key).is_none(), "{result}");
}
}
assert!(result.get("_meta").is_none(), "{result}");
}
async fn success(
h: &Endpoint,
revision: &str,
session: Option<&str>,
method: &str,
params: Value,
sse: bool,
) -> (Value, [usize; 3]) {
let req = request(revision, method, params);
let before = counts(&h.counters);
let body = wire(h.post(revision, session, &req, sse).await, &req["id"], sse).await;
assert!(body.get("error").is_none(), "{body}");
era(&body["result"], revision, method);
let after = counts(&h.counters);
(
body["result"].clone(),
std::array::from_fn(|i| after[i] - before[i]),
)
}
async fn control(revision: &str) -> 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 first_cursor = None;
// Both revisions' JSON contract, plus modern terminal SSE through the same normal app.
let modes: &[bool] = if revision == MODERN_REVISION {
&[false, true]
} else {
&[false]
};
for &sse in modes {
let mut cursor = None;
for (page, name) in ["greeting", "archived-prompt"].iter().enumerate() {
let mut params = json!({"limit":1});
if let Some(ref cursor) = cursor {
params["cursor"] = json!(cursor);
}
let (result, delta) = success(&h, revision, session, "prompts/list", params, sse).await;
let prompts = result["prompts"].as_array().unwrap();
assert_eq!(prompts.len(), 1, "{result}");
assert_eq!(
prompts[0],
json!({
"name":name, "description":format!("Published {name}"),
"arguments":[
{"name":"name","schema":{"type":"string"},"required":true},
{"name":"count","schema":{"type":"integer"},"required":false,"default":2},
{"name":"enabled","schema":{"type":"boolean"},"required":false,"default":true},
{"name":"tone","schema":{"type":"string","enum":["warm","dry"]},"required":false,"default":"warm"}
]
})
);
cursor = result
.get("nextCursor")
.map(|v| v.as_str().unwrap().to_owned());
assert_eq!(cursor.is_some(), page == 0, "{result}");
if page == 0 {
assert_ne!(cursor.as_deref(), Some("1"));
first_cursor = cursor.clone();
}
deltas.push((delta, [1, 1, 0]));
}
for (name, args, text) in [
(
"greeting",
json!({"name":"Ada"}),
"Hello Ada count=2 enabled=true tone=warm",
),
(
"greeting",
json!({"name":"Ada","count":7,"enabled":false,"tone":"dry"}),
"Hello Ada count=7 enabled=false tone=dry",
),
(
"archived-prompt",
json!({"name":"Ada"}),
"Hello Ada count=2 enabled=true tone=warm",
),
] {
let mut previous = None;
for _ in 0..2 {
let (result, delta) = success(
&h,
revision,
session,
"prompts/get",
json!({"name":name,"arguments":args}),
sse,
)
.await;
assert_eq!(result["description"], format!("Published {name}"));
assert_eq!(
result["messages"],
json!([
{"role":"system","content":{"type":"text","text":"Be brief."}},
{"role":"user","content":{"type":"text","text":text}}
])
);
if let Some(ref previous) = previous {
assert_eq!(&result, previous);
}
previous = Some(result);
deltas.push((delta, [1, 0, 1]));
}
}
for (arguments, reason, argument) in [
(json!({}), "missing_argument", "name"),
(
json!({"name":"Ada","extra":"x"}),
"unknown_argument",
"extra",
),
(json!({"name":5}), "argument_invalid", "name"),
(
json!({"name":"Ada","count":"7"}),
"argument_invalid",
"count",
),
(
json!({"name":"Ada","enabled":"false"}),
"argument_invalid",
"enabled",
),
(
json!({"name":"Ada","tone":"loud"}),
"argument_invalid",
"tone",
),
(
json!({"name":"x".repeat(crank_core::prompt::MAX_TEXT_BYTES + 1)}),
"argument_too_large",
"name",
),
] {
let req = request(
revision,
"prompts/get",
json!({"name":"greeting","arguments":arguments}),
);
let body = wire(h.post(revision, session, &req, sse).await, &req["id"], sse).await;
assert_eq!(body["error"]["code"], -32602, "{body}");
assert_eq!(body["error"]["data"]["reason"], reason, "{body}");
assert_eq!(body["error"]["data"]["argument"], argument);
assert!(body.get("result").is_none(), "{body}");
for leaked in [
"Be brief.",
"Hello ",
"Changed ",
"Published unbound-prompt",
] {
assert!(!body.to_string().contains(leaked), "{body}");
}
}
let mut unavailable = None;
for name in [
"draft-prompt",
"unbound-prompt",
"other-agent-prompt",
"never-existed",
"prm_a",
] {
let req = request(revision, "prompts/get", json!({"name":name}));
let body = wire(h.post(revision, session, &req, sse).await, &req["id"], sse).await;
assert_eq!(body["error"]["code"], -32602, "{body}");
assert_eq!(
body["error"]["message"],
"the requested prompt is not available"
);
assert!(body.get("result").is_none());
if let Some(ref previous) = unavailable {
assert_eq!(&body, previous);
}
unavailable = Some(body);
}
}
for params in [json!({"cursor":"invalid"}), json!({"limit":"invalid"})] {
let req = request(revision, "prompts/list", params);
let body = wire(
h.post(revision, session, &req, false).await,
&req["id"],
false,
)
.await;
assert_eq!(body["error"]["code"], -32602, "{body}");
}
let other = if revision == MODERN_REVISION {
LEGACY_REVISION
} else {
MODERN_REVISION
};
let other_session = h.session(other).await;
let req = request(
other,
"prompts/list",
json!({"cursor":first_cursor.unwrap()}),
);
let body = wire(
h.post(other, other_session.as_deref(), &req, false).await,
&req["id"],
false,
)
.await;
assert_eq!(
body["error"]["code"], -32602,
"cross-revision cursor: {body}"
);
// Archive keeps serving v1 above, but disallows new publications and bindings.
use crank_core::ids::PromptId;
use crank_registry::model::{
AgentPromptBinding, PublishPromptRequest, SaveAgentCatalogConfigRequest,
};
let publication = h
.registry
.publish_prompt_draft(PublishPromptRequest {
workspace_id: workspace_id(),
prompt_id: PromptId::new("prm_b"),
expected_updated_at: h.archived_at,
published_at: time::OffsetDateTime::now_utc(),
})
.await;
assert!(
matches!(
publication,
Err(crank_registry::RegistryError::PromptNotDraft { .. })
),
"{publication:?}"
);
let binding = h
.registry
.save_agent_catalog_config_editable_with_prompts(
SaveAgentCatalogConfigRequest {
workspace_id: &workspace_id(),
agent_id: &agent_id(),
agent_version: 1,
bindings: &[],
tool_selection_policy: &crank_core::ToolSelectionPolicy::default(),
resource_bindings: &[],
expected_state: None,
},
&[AgentPromptBinding {
prompt_id: PromptId::new("prm_b"),
prompt_version: 1,
}],
)
.await;
assert!(
matches!(
binding,
Err(crank_registry::RegistryError::PromptArchived { .. })
),
"{binding:?}"
);
h.registry
.revoke_platform_api_key(
&workspace_id(),
&crank_core::PlatformApiKeyId::new("pk_dispatch_observer"),
&time::OffsetDateTime::now_utc(),
)
.await
.unwrap();
for (method, params) in [
("prompts/list", json!({})),
(
"prompts/get",
json!({"name":"greeting","arguments":{"name":"Ada"}}),
),
] {
assert_eq!(
h.post(revision, session, &request(revision, method, params), false)
.await
.status(),
401
);
}
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:?}"
);
deltas
}
#[tokio::test]
async fn rmcp_prompts_wire_legacy() {
control(LEGACY_REVISION).await;
}
#[tokio::test]
async fn rmcp_prompts_wire_modern() {
control(MODERN_REVISION).await;
}
#[tokio::test]
async fn rmcp_prompts_sdk_legacy() {
let deltas = control(LEGACY_REVISION).await;
assert!(
deltas.iter().all(|(a, e)| a == e),
"SDK typed dispatch/result missing after successful HTTP: {deltas:?}"
);
}
#[tokio::test]
async fn rmcp_prompts_sdk_modern() {
let deltas = control(MODERN_REVISION).await;
assert!(
deltas.iter().all(|(a, e)| a == e),
"SDK typed dispatch/result missing after successful HTTP: {deltas:?}"
);
}
#[tokio::test]
async fn rmcp_prompts_observer_scope_control() {
use super::{
sdk_prompts_dispatch_enter, sdk_prompts_get_result_serialized,
sdk_prompts_list_result_serialized,
};
let a = Arc::new(CounterSet::default());
let b = Arc::new(CounterSet::default());
sdk_prompts_dispatch_enter();
assert_eq!(counts(&a), [0; 3]);
let snapshot = a.snapshot();
observe(a.clone(), async {
sdk_prompts_dispatch_enter();
sdk_prompts_list_result_serialized();
sdk_prompts_get_result_serialized();
})
.await;
observe(b.clone(), async {
sdk_prompts_get_result_serialized();
})
.await;
assert_eq!(counts(&a), [1; 3]);
assert_eq!(counts(&b), [0, 0, 1]);
assert_eq!(a.snapshot(), snapshot);
let body = Body::from_stream(stream::once(async {
sdk_prompts_list_result_serialized();
Ok::<_, std::convert::Infallible>("terminal")
}));
let response = observe_body(Response::new(body), b.clone());
assert_eq!(
&axum::body::to_bytes(response.into_body(), 100)
.await
.unwrap()[..],
b"terminal"
);
assert_eq!(counts(&b), [0, 1, 1]);
assert_eq!(counts(&a), [1; 3]);
}
@@ -0,0 +1,305 @@
//! Published Prompts fixture using the existing observed HTTP app and disposable PostgreSQL.
use super::*;
use crank_core::prompt::{PromptDefinition, PromptSensitivity};
use crank_core::{Agent, AgentStatus, AgentVersion, ToolSelectionPolicy, ids::PromptId};
use crank_registry::model::{
AgentPromptBinding, ArchivePromptRequest, CreatePromptDraftRequest, PublishPromptRequest,
SaveAgentCatalogConfigRequest, UpdatePromptDraftRequest,
};
use crank_registry::{CreateAgentRequest, PublishAgentRequest};
use crank_runtime::{
InMemoryCoordinationStateStore, RequestRateLimitConfig, RequestRateLimiter, SecretCrypto,
};
pub(super) fn definition(name: &str, content: &str) -> PromptDefinition {
PromptDefinition::parse(&json!({
"name":name, "description":format!("Published {name}"),
"arguments":[
{"name":"name","schema":{"type":"string"},"required":true},
{"name":"count","schema":{"type":"integer"},"required":false,"default":2},
{"name":"enabled","schema":{"type":"boolean"},"required":false,"default":true},
{"name":"tone","schema":{"type":"string","enum":["warm","dry"]},"required":false,"default":"warm"}
],
"messages":[{"role":"system","content":"Be brief."},{"role":"user","content":content}]
})).unwrap()
}
pub(super) struct Endpoint {
pub registry: crank_registry::PostgresRegistry,
pub counters: Arc<CounterSet>,
pub key: String,
pub url: String,
pub archived_at: time::OffsetDateTime,
server: tokio::task::JoinHandle<()>,
}
impl Drop for Endpoint {
fn drop(&mut self) {
self.server.abort();
}
}
impl Endpoint {
pub async fn started() -> Self {
crank_test_support::postgres_schema_url_for_task("prompts_owner", "t_160a763a").await;
let registry = test_registry().await;
let mut archived_at = test_time();
for (id, name, publish) in [
("prm_a", "greeting", true),
("prm_b", "archived-prompt", true),
("prm_c", "unbound-prompt", true),
("prm_d", "draft-prompt", false),
("prm_e", "other-agent-prompt", true),
] {
let row = registry
.create_prompt_draft(CreatePromptDraftRequest {
workspace_id: workspace_id(),
prompt_id: PromptId::new(id),
sensitivity: PromptSensitivity::Internal,
definition: definition(
name,
"Hello {{name}} count={{count}} enabled={{enabled}} tone={{tone}}",
),
created_at: time::OffsetDateTime::now_utc(),
})
.await
.unwrap();
if publish {
let row = registry
.publish_prompt_draft(PublishPromptRequest {
workspace_id: workspace_id(),
prompt_id: PromptId::new(id),
expected_updated_at: row.updated_at,
published_at: time::OffsetDateTime::now_utc(),
})
.await
.unwrap();
if id == "prm_b" {
archived_at = row.updated_at;
}
}
}
for (id, slug) in [
(agent_id(), AGENT_SLUG),
(
crank_core::AgentId::new("agent_other_prompts"),
"other-prompts",
),
] {
registry
.create_agent(CreateAgentRequest {
agent: &Agent {
id: id.clone(),
workspace_id: workspace_id(),
slug: slug.into(),
display_name: "SDK Prompts".into(),
description: String::new(),
status: AgentStatus::Draft,
current_draft_version: 1,
latest_published_version: None,
created_at: test_time(),
updated_at: test_time(),
published_at: None,
},
version: &AgentVersion {
agent_id: id,
version: 1,
status: AgentStatus::Draft,
instructions: json!({}),
tool_selection_policy: ToolSelectionPolicy::default(),
created_at: test_time(),
},
bindings: &[],
})
.await
.unwrap();
}
let other_agent = crank_core::AgentId::new("agent_other_prompts");
registry
.save_agent_catalog_config_editable_with_prompts(
SaveAgentCatalogConfigRequest {
workspace_id: &workspace_id(),
agent_id: &other_agent,
agent_version: 1,
bindings: &[],
tool_selection_policy: &ToolSelectionPolicy::default(),
resource_bindings: &[],
expected_state: None,
},
&[AgentPromptBinding {
prompt_id: PromptId::new("prm_e"),
prompt_version: 1,
}],
)
.await
.unwrap();
registry
.publish_agent(PublishAgentRequest {
workspace_id: &workspace_id(),
agent_id: &other_agent,
version: 1,
published_at: &test_time(),
published_by: Some("alice"),
expected_state: None,
})
.await
.unwrap();
registry
.save_agent_catalog_config_editable_with_prompts(
SaveAgentCatalogConfigRequest {
workspace_id: &workspace_id(),
agent_id: &agent_id(),
agent_version: 1,
bindings: &[],
tool_selection_policy: &ToolSelectionPolicy::default(),
resource_bindings: &[],
expected_state: None,
},
&[
AgentPromptBinding {
prompt_id: PromptId::new("prm_a"),
prompt_version: 1,
},
AgentPromptBinding {
prompt_id: PromptId::new("prm_b"),
prompt_version: 1,
},
],
)
.await
.unwrap();
registry
.publish_agent(PublishAgentRequest {
workspace_id: &workspace_id(),
agent_id: &agent_id(),
version: 1,
published_at: &test_time(),
published_by: Some("alice"),
expected_state: None,
})
.await
.unwrap();
let archived_at = registry
.archive_prompt_draft(ArchivePromptRequest {
workspace_id: workspace_id(),
prompt_id: PromptId::new("prm_b"),
expected_updated_at: archived_at,
archived_at: time::OffsetDateTime::now_utc(),
})
.await
.unwrap()
.updated_at;
// A mutable v2 draft must not change the bound v1 rendering or discovery metadata.
let draft = registry
.get_prompt_draft(&workspace_id(), &PromptId::new("prm_a"))
.await
.unwrap();
registry
.update_prompt_draft(UpdatePromptDraftRequest {
workspace_id: workspace_id(),
prompt_id: PromptId::new("prm_a"),
sensitivity: PromptSensitivity::Internal,
definition: definition("changed-draft", "Changed {{name}}"),
expected_updated_at: draft.updated_at,
updated_at: time::OffsetDateTime::now_utc(),
})
.await
.unwrap();
let key = create_api_key(&registry).await;
let counters = Arc::new(CounterSet::default());
let app = crate::build_app(
registry.clone(),
Duration::ZERO,
None,
SecretCrypto::new("test-master-key-00000000000000000000000000000000").unwrap(),
crank_runtime::community_with_outbound_policy(
crank_runtime::OutboundHttpPolicy::allowing_hosts(["127.0.0.1"]),
)
.build(),
RequestRateLimiter::new(RequestRateLimitConfig::new(10_000, 10_000).unwrap()),
Arc::new(InMemoryCoordinationStateStore::default()),
Arc::new(crate::session::InMemorySessionStore::default()),
Arc::new(crate::auth::CommunityMachineCredentialVerifier),
);
let app = observe_requests(app, counters.clone(), None).layer(axum::middleware::from_fn({
let counters = counters.clone();
move |request: axum::extract::Request, next: axum::middleware::Next| {
let counters = counters.clone();
async move { observe_body(next.run(request).await, counters) }
}
}));
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let url = format!(
"http://{}/v1/{WORKSPACE_SLUG}/{AGENT_SLUG}",
listener.local_addr().unwrap()
);
let server = tokio::spawn(async move {
axum::serve(listener, app).await.unwrap();
});
Self {
registry,
counters,
key,
url,
archived_at,
server,
}
}
pub async fn post(
&self,
revision: &str,
session: Option<&str>,
body: &Value,
sse: bool,
) -> reqwest::Response {
let mut request = reqwest::Client::new()
.post(&self.url)
.bearer_auth(&self.key)
.header(
"Accept",
if sse {
"text/event-stream, application/json"
} else {
"application/json"
},
)
.header("x-request-id", "sdk-prompts-wire")
.header(
"traceparent",
"00-11111111111111111111111111111111-2222222222222222-01",
)
.header("MCP-Protocol-Version", revision);
if let Some(session) = session {
request = request.header("MCP-Session-Id", session);
}
if revision == MODERN_REVISION {
request = request.header("Mcp-Method", body["method"].as_str().unwrap());
if let Some(name) = body["params"]["name"].as_str() {
request = request.header("Mcp-Name", name);
}
}
request.json(body).send().await.unwrap()
}
pub async fn session(&self, revision: &str) -> Option<String> {
if revision == MODERN_REVISION {
return None;
}
let response = self
.post(revision, None, &legacy_initialize(1), false)
.await;
assert_eq!(response.status(), 200);
let session = response.headers()["MCP-Session-Id"]
.to_str()
.unwrap()
.to_owned();
assert_eq!(
json_body(response).await["result"]["protocolVersion"],
revision
);
assert_eq!(
self.post(revision, Some(&session), &initialized_notification(), false)
.await
.status(),
202
);
Some(session)
}
}
@@ -0,0 +1,287 @@
//! #107 Resources: existing wire GREEN is independent of the missing SDK typed-path oracle.
use super::{CounterSet, observe, support::*};
use axum::{body::Body, response::Response};
use futures_util::{StreamExt, stream};
use serde_json::{Value, json};
use std::{sync::Arc, time::Duration};
#[path = "rmcp_resources_test_support.rs"]
mod fixtures;
use fixtures::{Endpoint, TEXT, URI};
// As in rmcp_result_runtime_tests: deferred body polling keeps this request's observer.
fn observe_body(response: Response, counters: Arc<CounterSet>) -> Response {
let (parts, body) = response.into_parts();
let body = stream::unfold(
(body.into_data_stream(), counters),
|(mut body, counters)| async move {
observe(counters.clone(), body.next())
.await
.map(|chunk| (chunk, (body, counters)))
},
);
Response::from_parts(parts, Body::from_stream(body))
}
fn counts(c: &CounterSet) -> [usize; 4] {
[
c.sdk_resources_dispatch(),
c.sdk_resources_list_result(),
c.sdk_resources_read_result(),
c.sdk_resource_templates_list_result(),
]
}
fn request(revision: &str, method: &str, mut params: Value) -> Value {
if revision == MODERN_REVISION {
params["_meta"] = modern_meta();
}
json!({"jsonrpc":"2.0", "id":9007199254740993_u64, "method":method, "params":params})
}
async fn wire(response: reqwest::Response, id: &Value, sse: bool) -> Value {
assert_eq!(response.status(), 200);
assert_eq!(response.headers()["x-request-id"], "sdk-resources-wire");
assert_eq!(
response.headers()["x-trace-id"],
"11111111111111111111111111111111"
);
let content_type = response.headers()["content-type"]
.to_str()
.unwrap()
.to_owned();
let text = tokio::time::timeout(Duration::from_secs(5), response.text())
.await
.unwrap()
.unwrap();
let body: Value = if sse {
assert!(
content_type.starts_with("text/event-stream"),
"{content_type}: {text}"
);
let frames: Vec<Value> = text
.lines()
.filter_map(|line| {
line.strip_prefix("data:")
.map(|s| serde_json::from_str(s.trim()).unwrap())
})
.collect();
let terminal: Vec<_> = frames.iter().filter(|f| f.get("id") == Some(id)).collect();
assert_eq!(terminal.len(), 1, "{frames:?}");
assert_eq!(frames.last(), Some(terminal[0]), "terminal must be last");
terminal[0].clone()
} else {
assert!(
content_type.starts_with("application/json"),
"{content_type}: {text}"
);
serde_json::from_str(&text).unwrap()
};
assert_eq!(body["jsonrpc"], "2.0");
assert_eq!(&body["id"], id);
body
}
fn era(result: &Value, revision: &str) {
if revision == MODERN_REVISION {
assert_eq!(result["resultType"], "complete", "{result}");
assert_eq!(result["ttlMs"], 0);
assert_eq!(result["cacheScope"], "private");
} else {
for key in ["resultType", "ttlMs", "cacheScope"] {
assert!(result.get(key).is_none(), "{result}");
}
}
assert!(result.get("_meta").is_none(), "{result}");
}
async fn success(
h: &Endpoint,
revision: &str,
session: Option<&str>,
method: &str,
params: Value,
sse_accept: bool,
) -> (Value, [usize; 4]) {
let req = request(revision, method, params);
let before = counts(&h.counters);
let body = wire(
h.post(revision, session, &req, sse_accept).await,
&req["id"],
sse_accept,
)
.await;
assert!(body.get("error").is_none(), "{body}");
era(&body["result"], revision);
let after = counts(&h.counters);
(
body["result"].clone(),
std::array::from_fn(|i| after[i] - before[i]),
)
}
async fn control(revision: &str) -> Vec<([usize; 4], [usize; 4])> {
let h = Endpoint::started().await;
let session = h.session(revision).await;
let session = session.as_deref();
let mut deltas = Vec::new();
// Preference order negotiates JSON or terminal SSE in both Resources revisions.
for sse in [false, true] {
let mut cursor = None;
let mut names = Vec::new();
for page in 0..2 {
let mut params = json!({"limit":1});
if let Some(ref cursor) = cursor {
params["cursor"] = json!(cursor);
}
let (result, delta) =
success(&h, revision, session, "resources/list", params, sse).await;
let resources = result["resources"].as_array().unwrap();
assert_eq!(resources.len(), 1, "{result}");
let item = &resources[0];
assert_eq!(item["mimeType"], "text/plain");
assert!(
item.get("description").is_none(),
"static descriptors omit description: {item}"
);
names.push((item["name"].clone(), item["uri"].clone()));
cursor = result
.get("nextCursor")
.map(|v| v.as_str().unwrap().to_owned());
assert_eq!(cursor.is_some(), page == 0, "{result}");
if let Some(ref cursor) = cursor {
assert_ne!(cursor, "1", "opaque cursor required");
}
deltas.push((delta, [1, 1, 0, 0]));
}
names.sort_by_key(|n| n.0.as_str().unwrap().to_owned());
assert_eq!(
names,
vec![
(json!("sdk_a"), json!(URI)),
(json!("sdk_b"), json!("crank://resources/sdk-b"))
]
);
let (result, delta) = success(
&h,
revision,
session,
"resources/read",
json!({"uri":URI}),
sse,
)
.await;
assert_eq!(
result["contents"],
json!([{"uri":URI,"mimeType":"text/plain","text":TEXT}])
);
deltas.push((delta, [1, 0, 1, 0]));
let (result, delta) = success(
&h,
revision,
session,
"resources/templates/list",
json!({}),
sse,
)
.await;
assert_eq!(result["resourceTemplates"], json!([]));
assert!(result.get("nextCursor").is_none());
deltas.push((delta, [1, 0, 0, 1]));
}
// Malformed parameters/cursors and indistinguishable unavailable URIs remain command errors.
for (method, params) in [
("resources/list", json!({"cursor":"invalid"})),
("resources/list", json!({"limit":"invalid"})),
("resources/templates/list", json!({"cursor":"invalid"})),
("resources/templates/list", json!({"limit":"invalid"})),
("resources/read", json!({"uri":"crank://resources/unbound"})),
] {
let req = request(revision, method, params);
let body = wire(
h.post(revision, session, &req, false).await,
&req["id"],
false,
)
.await;
assert_eq!(body["error"]["code"], -32602, "{body}");
assert!(body.get("result").is_none(), "{body}");
}
// An existing session does not preserve revoked authorization.
h.registry
.revoke_platform_api_key(
&workspace_id(),
&crank_core::PlatformApiKeyId::new("pk_dispatch_observer"),
&time::OffsetDateTime::now_utc(),
)
.await
.unwrap();
for (method, params) in [
("resources/list", json!({})),
("resources/read", json!({"uri":URI})),
("resources/templates/list", json!({})),
] {
let req = request(revision, method, params);
assert_eq!(h.post(revision, session, &req, false).await.status(), 401);
}
eprintln!(
"existing GREEN Resources wire {revision}: pagination, exact content URI/bytes, empty templates, JSON/SSE negotiation, InvalidParams, revoked401; actual/expected SDK deltas={deltas:?}"
);
deltas
}
#[tokio::test]
async fn rmcp_resources_wire_legacy() {
control(LEGACY_REVISION).await;
}
#[tokio::test]
async fn rmcp_resources_wire_modern() {
control(MODERN_REVISION).await;
}
#[tokio::test]
async fn rmcp_resources_sdk_legacy() {
let deltas = control(LEGACY_REVISION).await;
assert!(
deltas.iter().all(|(actual, expected)| actual == expected),
"SDK typed dispatch/result missing after successful HTTP: {deltas:?}"
);
}
#[tokio::test]
async fn rmcp_resources_sdk_modern() {
let deltas = control(MODERN_REVISION).await;
assert!(
deltas.iter().all(|(actual, expected)| actual == expected),
"SDK typed dispatch/result missing after successful HTTP: {deltas:?}"
);
}
#[tokio::test]
async fn rmcp_resources_observer_scope_control() {
use super::{
sdk_resource_templates_list_result_serialized, sdk_resources_dispatch_enter,
sdk_resources_list_result_serialized, sdk_resources_read_result_serialized,
};
let a = Arc::new(CounterSet::default());
let b = Arc::new(CounterSet::default());
sdk_resources_dispatch_enter();
assert_eq!(counts(&a), [0; 4]);
let snapshot = a.snapshot();
observe(a.clone(), async {
sdk_resources_dispatch_enter();
sdk_resources_list_result_serialized();
sdk_resources_read_result_serialized();
sdk_resource_templates_list_result_serialized();
})
.await;
observe(b.clone(), async {
sdk_resources_read_result_serialized();
})
.await;
assert_eq!(counts(&a), [1; 4]);
assert_eq!(counts(&b), [0, 0, 1, 0]);
assert_eq!(a.snapshot(), snapshot, "old Snapshot stays unchanged");
let body = Body::from_stream(stream::once(async {
sdk_resource_templates_list_result_serialized();
Ok::<_, std::convert::Infallible>("terminal")
}));
let response = observe_body(Response::new(body), b.clone());
assert_eq!(
&axum::body::to_bytes(response.into_body(), 100)
.await
.unwrap()[..],
b"terminal"
);
assert_eq!(counts(&b), [0, 0, 1, 1]);
assert_eq!(counts(&a), [1; 4]);
}
@@ -0,0 +1,227 @@
//! Small Resources fixture: existing observer helpers, exact artifact publications, normal app.
use super::*;
use crank_artifacts::ArtifactStore;
use crank_core::{Agent, AgentStatus, AgentVersion, ToolSelectionPolicy, ids::ResourceId};
use crank_registry::{
AgentResourceBinding, CreateAgentRequest, PublishAgentRequest, SaveAgentCatalogConfigRequest,
};
use crank_runtime::{
InMemoryCoordinationStateStore, RequestRateLimitConfig, RequestRateLimiter, SecretCrypto,
};
use sha2::{Digest, Sha256};
pub(super) const URI: &str = "crank://resources/sdk-a";
pub(super) const TEXT: &str = "published v1\n";
pub(super) struct Endpoint {
pub registry: crank_registry::PostgresRegistry,
pub counters: Arc<CounterSet>,
pub key: String,
pub url: String,
server: tokio::task::JoinHandle<()>,
root: std::path::PathBuf,
}
impl Drop for Endpoint {
fn drop(&mut self) {
self.server.abort();
let _ = std::fs::remove_dir_all(&self.root);
}
}
impl Endpoint {
pub async fn started() -> Self {
crank_test_support::postgres_schema_url_for_task("resources_owner", "t_73561633").await;
let registry = test_registry().await;
let root = std::env::temp_dir().join(format!("rmcp-resources-{}", uuid::Uuid::now_v7()));
std::fs::create_dir(&root).unwrap();
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).unwrap();
let store = ArtifactStore::open(&root).unwrap();
// Same immutable row shapes and real ArtifactStore::put as static_resources/fixtures.rs.
for (id, uri, name, bytes) in [
("res_sdk_a", URI, "sdk_a", TEXT),
(
"res_sdk_b",
"crank://resources/sdk-b",
"sdk_b",
"second published resource\n",
),
] {
let stored = store.put(bytes.as_bytes()).unwrap();
let digest = format!("{:x}", Sha256::digest(bytes.as_bytes()));
let source = format!("src_{id}");
sqlx::query("insert into artifact_blobs (digest, artifact_ref, size_bytes, storage_lifecycle, created_at, updated_at) values ($1,$2,$3,'available',now(),now())")
.bind(&digest).bind(format!("sha256:{digest}")).bind(stored.size_bytes as i64).execute(registry.pool()).await.unwrap();
sqlx::query("insert into artifact_sources (workspace_id,source_id,blob_digest,mime_type,sensitivity,lifecycle,created_at,updated_at) values ('ws_default',$1,$2,'text/plain','internal','active',now(),now())")
.bind(&source).bind(&digest).execute(registry.pool()).await.unwrap();
sqlx::query("insert into resources (workspace_id,resource_id,uri,name,description,status,kind,current_draft_version,created_at,updated_at) values ('ws_default',$1,$2,$3,'','published','text',1,now(),now())")
.bind(id).bind(uri).bind(name).execute(registry.pool()).await.unwrap();
sqlx::query("insert into resource_versions (workspace_id,resource_id,version,kind,mime_type,size_bytes,digest,sensitivity,artifact_source_id,created_at,superseded_at) values ('ws_default',$1,1,'text','text/plain',$2,$3,'internal',$4,now(),null)")
.bind(id).bind(stored.size_bytes as i64).bind(&digest).bind(&source).execute(registry.pool()).await.unwrap();
sqlx::query("insert into resource_publications (workspace_id,resource_id,version,uri,name,description,kind,mime_type,size_bytes,digest,sensitivity,artifact_source_id,published_at) values ('ws_default',$1,1,$2,$3,'','text','text/plain',$4,$5,'internal',$6,now())")
.bind(id).bind(uri).bind(name).bind(stored.size_bytes as i64).bind(&digest).bind(&source).execute(registry.pool()).await.unwrap();
}
registry
.create_agent(CreateAgentRequest {
agent: &Agent {
id: agent_id(),
workspace_id: workspace_id(),
slug: AGENT_SLUG.into(),
display_name: "SDK Resources".into(),
description: String::new(),
status: AgentStatus::Draft,
current_draft_version: 1,
latest_published_version: None,
created_at: test_time(),
updated_at: test_time(),
published_at: None,
},
version: &AgentVersion {
agent_id: agent_id(),
version: 1,
status: AgentStatus::Draft,
instructions: json!({}),
tool_selection_policy: ToolSelectionPolicy::default(),
created_at: test_time(),
},
bindings: &[],
})
.await
.unwrap();
registry
.save_agent_catalog_config(SaveAgentCatalogConfigRequest {
workspace_id: &workspace_id(),
agent_id: &agent_id(),
agent_version: 1,
bindings: &[],
tool_selection_policy: &ToolSelectionPolicy::default(),
resource_bindings: &[
AgentResourceBinding {
resource_id: ResourceId::new("res_sdk_a"),
resource_version: 1,
},
AgentResourceBinding {
resource_id: ResourceId::new("res_sdk_b"),
resource_version: 1,
},
],
expected_state: None,
})
.await
.unwrap();
registry
.publish_agent(PublishAgentRequest {
workspace_id: &workspace_id(),
agent_id: &agent_id(),
version: 1,
published_at: &test_time(),
published_by: Some("alice"),
expected_state: None,
})
.await
.unwrap();
let key = create_api_key(&registry).await;
let counters = Arc::new(CounterSet::default());
// Normal build_app composition with its sanctioned artifact root, not the isolated SDK router.
let app = crate::build_app_with_artifacts(
registry.clone(),
Duration::ZERO,
None,
SecretCrypto::new("test-master-key-00000000000000000000000000000000").unwrap(),
crank_runtime::community_with_outbound_policy(
crank_runtime::OutboundHttpPolicy::allowing_hosts(["127.0.0.1"]),
)
.build(),
RequestRateLimiter::new(RequestRateLimitConfig::new(10_000, 10_000).unwrap()),
Arc::new(InMemoryCoordinationStateStore::default()),
Arc::new(crate::session::InMemorySessionStore::default()),
Arc::new(crate::auth::CommunityMachineCredentialVerifier),
16,
store,
);
let app = observe_requests(app, counters.clone(), None).layer(axum::middleware::from_fn({
let counters = counters.clone();
move |request: axum::extract::Request, next: axum::middleware::Next| {
let counters = counters.clone();
async move {
let response = next.run(request).await;
observe_body(response, counters)
}
}
}));
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let url = format!(
"http://{}/v1/{WORKSPACE_SLUG}/{AGENT_SLUG}",
listener.local_addr().unwrap()
);
let server = tokio::spawn(async move {
axum::serve(listener, app).await.unwrap();
});
Self {
registry,
counters,
key,
url,
server,
root,
}
}
pub async fn post(
&self,
revision: &str,
session: Option<&str>,
body: &Value,
sse: bool,
) -> reqwest::Response {
let mut request = reqwest::Client::new()
.post(&self.url)
.bearer_auth(&self.key)
.header(
"Accept",
if sse {
"text/event-stream, application/json"
} else {
"application/json"
},
)
.header("x-request-id", "sdk-resources-wire")
.header(
"traceparent",
"00-11111111111111111111111111111111-2222222222222222-01",
)
.header("MCP-Protocol-Version", revision);
if let Some(session) = session {
request = request.header("MCP-Session-Id", session);
}
if revision == MODERN_REVISION {
request = request.header("Mcp-Method", body["method"].as_str().unwrap());
if let Some(uri) = body["params"]["uri"].as_str() {
request = request.header("Mcp-Name", uri);
}
}
request.json(body).send().await.unwrap()
}
pub async fn session(&self, revision: &str) -> Option<String> {
if revision == MODERN_REVISION {
return None;
}
let response = self
.post(revision, None, &legacy_initialize(1), false)
.await;
assert_eq!(response.status(), 200);
let session = response.headers()["MCP-Session-Id"]
.to_str()
.unwrap()
.to_owned();
assert_eq!(
json_body(response).await["result"]["protocolVersion"],
revision
);
assert_eq!(
self.post(revision, Some(&session), &initialized_notification(), false)
.await
.status(),
202
);
Some(session)
}
}
@@ -0,0 +1,437 @@
//! #107 result serialization: wire controls run independently of the structural SDK oracle.
use super::*;
use axum::{
Json,
body::Body,
extract::State,
http::StatusCode,
response::{IntoResponse, Response},
};
use futures_util::{StreamExt, stream};
const ERROR_EMAIL: &str = "upstream-error@example.test";
const REQUEST_ID: &str = "sdk-result-wire";
const TRACE_ID: &str = "11111111111111111111111111111111";
pub(super) async fn upstream(state: State<Arc<AtomicUsize>>, payload: Json<Value>) -> Response {
if payload.0["email"] == ERROR_EMAIL {
state.0.fetch_add(1, Ordering::SeqCst);
return (
StatusCode::UNPROCESSABLE_ENTITY,
Json(json!({"error":"fixture rejection"})),
)
.into_response();
}
create_lead(state, payload).await.into_response()
}
// The HTTP body is polled after next.run returns. Carry only the test observer, not a new lifecycle.
pub(super) fn observe_body(response: Response, counters: Arc<CounterSet>) -> Response {
let (parts, body) = response.into_parts();
let body = stream::unfold(
(body.into_data_stream(), counters),
|(mut body, counters)| async move {
observe(counters.clone(), body.next())
.await
.map(|chunk| (chunk, (body, counters)))
},
);
Response::from_parts(parts, Body::from_stream(body))
}
#[tokio::test]
async fn rmcp_result_http_pagination_both_revisions() {
let h = Endpoint::started().await;
let mut operation = test_operation(&h._upstream.1);
operation.id = crank_core::OperationId::new("op_second_lead");
operation.name = "second_lead".to_owned();
h.registry
.create_operation(&workspace_id(), &operation, Some("alice"))
.await
.unwrap();
h.registry
.publish_operation(PublishRequest {
workspace_id: &workspace_id(),
operation_id: &operation.id,
version: 1,
published_at: &test_time(),
published_by: Some("alice"),
})
.await
.unwrap();
let now = time::OffsetDateTime::now_utc();
h.registry
.create_agent_draft_version(CreateAgentDraftVersionRequest {
workspace_id: &workspace_id(),
agent_id: &agent_id(),
version: &AgentVersion {
agent_id: agent_id(),
version: 2,
status: AgentStatus::Draft,
instructions: json!({}),
tool_selection_policy: ToolSelectionPolicy::default(),
created_at: now,
},
bindings: &[
AgentOperationBinding {
operation_id: crank_core::OperationId::new("op_create_lead"),
operation_version: 1,
tool_name: TOOL_NAME.into(),
tool_title: "Create Lead".into(),
tool_description_override: None,
enabled: true,
},
AgentOperationBinding {
operation_id: operation.id,
operation_version: 1,
tool_name: "second_lead".into(),
tool_title: "Second Lead".into(),
tool_description_override: None,
enabled: true,
},
],
updated_at: &now,
})
.await
.unwrap();
h.registry
.publish_agent(PublishAgentRequest {
workspace_id: &workspace_id(),
agent_id: &agent_id(),
version: 2,
published_at: &now,
published_by: Some("alice"),
expected_state: None,
})
.await
.unwrap();
for revision in [LEGACY_REVISION, MODERN_REVISION] {
let session = h.session(revision).await;
let mut names = Vec::new();
for (cursor, expected_next, expected_len) in [
(None, Some("1"), 1),
(Some("1"), None, 1),
(Some("2"), None, 0),
] {
let id = json!(format!("page-{cursor:?}"));
let mut request =
json!({"jsonrpc":"2.0","id":id,"method":"tools/list","params":{"limit":1}});
if let Some(cursor) = cursor {
request["params"]["cursor"] = json!(cursor);
}
if revision == MODERN_REVISION {
request["params"]["_meta"] = modern_meta();
}
let before = h.counters.sdk_tools_list_result();
let body = wire_body(
h.post(revision, session.as_deref(), &request).await,
&id,
false,
)
.await;
assert_era(&body["result"], revision, true);
assert_eq!(
body["result"].get("nextCursor"),
expected_next.map(|s| json!(s)).as_ref()
);
let tools = body["result"]["tools"].as_array().unwrap();
assert_eq!(tools.len(), expected_len);
names.extend(
tools
.iter()
.map(|tool| tool["name"].as_str().unwrap().to_owned()),
);
assert_eq!(h.counters.sdk_tools_list_result() - before, 1);
}
names.sort();
let mut expected = vec![TOOL_NAME.to_owned(), "second_lead".to_owned()];
expected.sort();
assert_eq!(names, expected);
}
assert_eq!(h.calls.load(Ordering::SeqCst), 0);
}
fn assert_era(result: &Value, revision: &str, list: bool) {
if revision == MODERN_REVISION {
assert_eq!(result["resultType"], "complete", "{result}");
if list {
assert_eq!(result["ttlMs"], 0);
assert_eq!(result["cacheScope"], "private");
}
} else {
assert!(result.get("resultType").is_none(), "{result}");
assert!(result.get("ttlMs").is_none(), "{result}");
assert!(result.get("cacheScope").is_none(), "{result}");
}
assert!(result.get("_meta").is_none(), "{result}");
}
async fn wire_body(response: reqwest::Response, id: &Value, sse: bool) -> Value {
assert_eq!(response.status(), 200);
assert_eq!(response.headers()["x-request-id"], REQUEST_ID);
assert_eq!(response.headers()["x-trace-id"], TRACE_ID);
let content_type = response.headers()["content-type"]
.to_str()
.unwrap()
.to_owned();
let text = tokio::time::timeout(Duration::from_secs(5), response.text())
.await
.unwrap()
.unwrap();
let body: Value = if sse {
assert!(
content_type.starts_with("text/event-stream"),
"{content_type}"
);
let frames: Vec<Value> = text
.lines()
.filter_map(|line| {
line.strip_prefix("data:")
.map(|data| serde_json::from_str(data.trim()).unwrap())
})
.collect();
let terminal: Vec<_> = frames
.iter()
.filter(|frame| frame.get("id") == Some(id))
.collect();
assert_eq!(terminal.len(), 1, "{frames:?}");
assert_eq!(frames.last(), Some(terminal[0]), "terminal must be last");
assert!(
frames
.iter()
.any(|frame| frame["method"] == "notifications/progress"
&& frame["params"]["progressToken"] == "result-progress"),
"{frames:?}"
);
terminal[0].clone()
} else {
assert!(
content_type.starts_with("application/json"),
"{content_type}"
);
serde_json::from_str(&text).unwrap()
};
assert_eq!(body["jsonrpc"], "2.0");
assert_eq!(&body["id"], id);
body
}
fn assert_call_result(body: &Value, revision: &str, email: &str) {
assert!(body.get("error").is_none(), "{body}");
let result = &body["result"];
assert_era(result, revision, false);
let (output, text, is_error) = if email == ERROR_EMAIL {
let contract = crate::tool_error::tool_error_contract_from_runtime(
&crank_runtime::RuntimeError::ProtocolAdapter(
crank_core::ProtocolAdapterError::UnexpectedStatus {
status: 422,
dispatch: crank_core::DispatchEvidence::MayHaveDispatched,
},
),
REQUEST_ID,
TRACE_ID,
crank_core::ExecutionLocale::En,
);
(
json!({"error":crate::tool_error::tool_error_value(&contract)}),
crate::tool_error::tool_error_text(&contract),
true,
)
} else {
let output = json!({"id":format!("lead_for_{email}")});
let text = serde_json::to_string_pretty(&output).unwrap();
(output, text, false)
};
assert_eq!(result["structuredContent"], output, "{body}");
assert_eq!(result["content"], json!([{"type":"text", "text":text}]));
assert_eq!(result["isError"], is_error);
assert_eq!(
result.as_object().unwrap().len(),
if revision == MODERN_REVISION { 4 } else { 3 },
"no unexpected optional fields: {result}"
);
}
async fn result_control(revision: &str) -> Vec<usize> {
let h = Endpoint::started().await;
let session = h.session(revision).await;
let session = session.as_deref();
let mut counts = Vec::new();
// Actual published descriptor and schema, then the empty page at the catalog boundary.
for (cursor, expected_tools, id) in [
(
None,
json!([{"name":TOOL_NAME,"title":"Create Lead","description":"Creates a CRM lead","inputSchema":{"type":"object","properties":{"email":{"type":"string"}},"required":["email"]}}]),
json!("list-string-id"),
),
(Some("1"), json!([]), json!(9007199254740993_u64)),
] {
let mut request =
json!({"jsonrpc":"2.0","id":id,"method":"tools/list","params":{"limit":1}});
if revision == MODERN_REVISION {
request["params"]["_meta"] = modern_meta();
}
if let Some(cursor) = cursor {
request["params"]["cursor"] = json!(cursor);
}
let before = h.counters.sdk_tools_list_result();
let before_call = h.counters.sdk_tools_call_result();
let before_dispatch = h.counters.sdk_tools_dispatch();
let body = wire_body(h.post(revision, session, &request).await, &id, false).await;
assert!(body.get("error").is_none(), "{body}");
assert_eq!(body["result"]["tools"], expected_tools);
assert!(body["result"].get("nextCursor").is_none(), "{body}");
assert_era(&body["result"], revision, true);
assert_eq!(h.counters.sdk_tools_call_result(), before_call);
assert_eq!(h.counters.sdk_tools_dispatch() - before_dispatch, 1);
counts.push(h.counters.sdk_tools_list_result() - before);
}
assert_eq!(h.calls.load(Ordering::SeqCst), 0);
for (email, id, sse) in [
(
"result-success@example.test",
json!(9007199254740993_u64),
false,
),
(ERROR_EMAIL, json!("tool-error-string-id"), false),
("result-sse@example.test", json!("sse-string-id"), true),
(ERROR_EMAIL, json!(92), true),
] {
if sse && revision != MODERN_REVISION {
continue;
}
let mut request = if revision == MODERN_REVISION {
modern_tool_call(90, email)
} else {
legacy_tool_call(90, email)
};
request["id"] = id.clone();
if sse {
request["params"]["_meta"]["progressToken"] = json!("result-progress");
}
let before = h.counters.sdk_tools_call_result();
let before_list = h.counters.sdk_tools_list_result();
let before_dispatch = h.counters.sdk_tools_dispatch();
let arrivals = h.calls.load(Ordering::SeqCst);
let response = h
.post_accept(
revision,
session,
&request,
if sse {
"application/json, text/event-stream"
} else {
"application/json"
},
)
.await;
let body = wire_body(response, &id, sse).await;
assert_call_result(&body, revision, email);
assert_eq!(h.calls.load(Ordering::SeqCst) - arrivals, 1);
assert_eq!(h.counters.sdk_tools_list_result(), before_list);
assert_eq!(h.counters.sdk_tools_dispatch() - before_dispatch, 1);
counts.push(h.counters.sdk_tools_call_result() - before);
}
// Unknown tool is a command InvalidParams, not an execution tool-error result.
let mut invalid = if revision == MODERN_REVISION {
modern_tool_call(93, "unused@example.test")
} else {
legacy_tool_call(93, "unused@example.test")
};
invalid["params"]["name"] = json!("missing_tool");
invalid["id"] = json!("invalid-params-id");
let before = h.counters.sdk_tools_call_result();
let arrivals = h.calls.load(Ordering::SeqCst);
let body = wire_body(
h.post(revision, session, &invalid).await,
&invalid["id"],
false,
)
.await;
assert_eq!(body["error"]["code"], -32602, "{body}");
assert!(body.get("result").is_none(), "{body}");
assert_eq!(body["error"]["data"]["request_id"], REQUEST_ID);
assert_eq!(body["error"]["data"]["trace_id"], TRACE_ID);
assert_eq!(h.counters.sdk_tools_call_result(), before);
assert_eq!(h.calls.load(Ordering::SeqCst), arrivals);
eprintln!(
"existing GREEN result wire {revision}: published list/schema + empty page, exact success/error JSON{}; InvalidParams/no result/no marker/no outbound; SDK result deltas={counts:?}",
if revision == MODERN_REVISION {
" + success/error terminal SSE"
} else {
" (legacy JSON-only)"
}
);
counts
}
#[tokio::test]
async fn rmcp_result_wire_modern() {
result_control(MODERN_REVISION).await;
}
#[tokio::test]
async fn rmcp_result_wire_legacy() {
result_control(LEGACY_REVISION).await;
}
#[tokio::test]
async fn rmcp_result_sdk_serialization_modern() {
assert_eq!(
result_control(MODERN_REVISION).await,
vec![1; 6],
"structural oracle: SDK list/final-empty/success/error/SSE-success/SSE-error must each serialize once after successful real HTTP wire controls"
);
}
#[tokio::test]
async fn rmcp_result_sdk_serialization_legacy() {
assert_eq!(
result_control(LEGACY_REVISION).await,
vec![1; 4],
"structural oracle: SDK list/final-empty/success/error must each serialize once after successful real HTTP wire controls"
);
}
#[tokio::test]
async fn rmcp_result_observer_scope_control() {
use crate::app::dispatch_observer::{
sdk_tools_call_result_serialized, sdk_tools_list_result_serialized,
};
let a = Arc::new(CounterSet::default());
let b = Arc::new(CounterSet::default());
sdk_tools_list_result_serialized();
sdk_tools_call_result_serialized();
assert_eq!(
(a.sdk_tools_list_result(), a.sdk_tools_call_result()),
(0, 0)
);
observe(a.clone(), async {
sdk_tools_list_result_serialized();
sdk_tools_call_result_serialized();
})
.await;
// A different request cannot alter a's result counters.
observe(b.clone(), async {
sdk_tools_list_result_serialized();
})
.await;
assert_eq!(
(a.sdk_tools_list_result(), a.sdk_tools_call_result()),
(1, 1)
);
assert_eq!(
(b.sdk_tools_list_result(), b.sdk_tools_call_result()),
(1, 0)
);
// Prove the stream-body scope actually records deferred work after the header scope ended.
let stream_counters = b.clone();
let body = Body::from_stream(stream::once(async move {
sdk_tools_call_result_serialized();
Ok::<_, std::convert::Infallible>("terminal")
}));
let response = observe_body(Response::new(body), stream_counters);
let bytes = axum::body::to_bytes(response.into_body(), 100)
.await
.unwrap();
assert_eq!(&bytes[..], b"terminal");
assert_eq!(b.sdk_tools_call_result(), 1);
assert_eq!(a.sdk_tools_call_result(), 1);
}
@@ -0,0 +1,385 @@
//! #107: real build_app endpoint controls plus a separate SDK structural seam oracle.
//! No SDK transport router is used. The structural oracle alone does not prove wire parity.
use std::{
sync::{
Arc,
atomic::{AtomicUsize, Ordering},
},
time::Duration,
};
use axum::{Router, routing::post};
use crank_core::{
AgentOperationBinding, AgentStatus, AgentVersion, PlatformApiKeyId, ToolSelectionPolicy,
};
use crank_registry::{
CreateAgentDraftVersionRequest, PostgresRegistry, PublishAgentRequest, PublishRequest,
};
use crank_runtime::{
InMemoryCoordinationStateStore, RequestRateLimitConfig, RequestRateLimiter, SecretCrypto,
};
use serde_json::{Value, json};
use super::{CounterSet, observe, sdk_tools_dispatch_enter, support::*};
#[path = "rmcp_result_runtime_tests.rs"]
mod result_serialization;
struct Server(tokio::task::JoinHandle<()>, String);
impl Drop for Server {
fn drop(&mut self) {
self.0.abort();
}
}
async fn serve(app: Router) -> Server {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
Server(
tokio::spawn(async move {
axum::serve(listener, app).await.unwrap();
}),
format!("http://{address}"),
)
}
struct Endpoint {
server: Server,
_upstream: Server,
registry: PostgresRegistry,
key: String,
counters: Arc<CounterSet>,
calls: Arc<AtomicUsize>,
}
impl Endpoint {
async fn started() -> Self {
// First caller owns the process-wide fixture and its atexit cleanup, including RED panics.
let _ =
crank_test_support::postgres_schema_url_for_task("rmcp_runtime_owner", "t_c559abb1")
.await;
let registry = test_registry().await;
let calls = Arc::new(AtomicUsize::new(0));
let upstream = serve(
Router::new()
.route("/crm/leads", post(result_serialization::upstream))
.with_state(calls.clone()),
)
.await;
let operation = test_operation(&upstream.1);
registry
.create_operation(&workspace_id(), &operation, Some("alice"))
.await
.unwrap();
registry
.publish_operation(PublishRequest {
workspace_id: &workspace_id(),
operation_id: &operation.id,
version: 1,
published_at: &test_time(),
published_by: Some("alice"),
})
.await
.unwrap();
publish_agent(&registry, &operation).await;
let key = create_api_key(&registry).await;
let counters = Arc::new(CounterSet::default());
let app = crate::build_app(
registry.clone(),
Duration::ZERO,
Some("https://crank.example.com".into()),
SecretCrypto::new("test-master-key-00000000000000000000000000000000").unwrap(),
crank_runtime::community_with_outbound_policy(
crank_runtime::OutboundHttpPolicy::allowing_hosts(["127.0.0.1"]),
)
.build(),
RequestRateLimiter::new(RequestRateLimitConfig::new(10_000, 10_000).unwrap()),
Arc::new(InMemoryCoordinationStateStore::default()),
Arc::new(crate::session::InMemorySessionStore::default()),
Arc::new(crate::auth::CommunityMachineCredentialVerifier),
);
let app = observe_requests(app, counters.clone(), None).layer(axum::middleware::from_fn({
let counters = counters.clone();
move |request: axum::extract::Request, next: axum::middleware::Next| {
let counters = counters.clone();
async move {
let response = next.run(request).await;
result_serialization::observe_body(response, counters)
}
}
}));
let server = serve(app).await;
Self {
server,
_upstream: upstream,
registry,
key,
counters,
calls,
}
}
async fn post(&self, revision: &str, session: Option<&str>, body: &Value) -> reqwest::Response {
self.post_accept(revision, session, body, "application/json")
.await
}
async fn post_accept(
&self,
revision: &str,
session: Option<&str>,
body: &Value,
accept: &str,
) -> reqwest::Response {
let mut request = reqwest::Client::new()
.post(format!(
"{}/v1/{WORKSPACE_SLUG}/{AGENT_SLUG}",
self.server.1
))
.bearer_auth(&self.key)
// Also guards the legacy JSON-only contract; no SSE parsing fallback here.
.header("Accept", accept)
.header("x-request-id", "sdk-result-wire")
.header(
"traceparent",
"00-11111111111111111111111111111111-2222222222222222-01",
)
.header("MCP-Protocol-Version", revision);
if let Some(session) = session {
request = request.header("MCP-Session-Id", session);
}
if revision == MODERN_REVISION {
request = request.header("Mcp-Method", body["method"].as_str().unwrap());
if let Some(name) = body["params"]["name"].as_str() {
request = request.header("Mcp-Name", name);
}
}
request.json(body).send().await.unwrap()
}
async fn session(&self, revision: &str) -> Option<String> {
if revision == MODERN_REVISION {
return None;
}
let response = self.post(revision, None, &legacy_initialize(1)).await;
assert_eq!(response.status(), 200);
let session = response.headers()["MCP-Session-Id"]
.to_str()
.unwrap()
.to_owned();
let body = json_body(response).await;
assert_eq!(body["result"]["protocolVersion"], revision);
assert!(body["result"]["capabilities"]["tools"].is_object());
let response = self
.post(revision, Some(&session), &initialized_notification())
.await;
assert_eq!(response.status(), 202);
Some(session)
}
async fn list(&self, revision: &str, session: Option<&str>, expected_name: &str) -> usize {
let before = self.counters.sdk_tools_dispatch();
let mut body = json!({"jsonrpc":"2.0", "id":10, "method":"tools/list", "params":{}});
if revision == MODERN_REVISION {
body["params"]["_meta"] = modern_meta();
}
let calls = self.calls.load(Ordering::SeqCst);
let response = self.post(revision, session, &body).await;
assert_eq!(response.status(), 200);
assert!(
response.headers()["content-type"]
.to_str()
.unwrap()
.starts_with("application/json")
);
let body = json_body(response).await;
assert_eq!(body["id"], 10);
assert_eq!(body["result"]["tools"].as_array().unwrap().len(), 1);
assert_eq!(body["result"]["tools"][0]["name"], expected_name);
assert!(body["error"].is_null(), "{body}");
assert_eq!(
self.calls.load(Ordering::SeqCst),
calls,
"listing must not execute upstream"
);
self.counters.sdk_tools_dispatch() - before
}
async fn call(&self, revision: &str, session: Option<&str>, name: &str, email: &str) -> usize {
let before = self.counters.sdk_tools_dispatch();
let arrivals = self.calls.load(Ordering::SeqCst);
let mut body = if revision == MODERN_REVISION {
modern_tool_call(11, email)
} else {
legacy_tool_call(11, email)
};
body["params"]["name"] = json!(name);
let response = self.post(revision, session, &body).await;
assert_eq!(response.status(), 200);
assert!(
response.headers()["content-type"]
.to_str()
.unwrap()
.starts_with("application/json")
);
let body = json_body(response).await;
assert_eq!(body["id"], 11);
assert!(body["error"].is_null(), "{body}");
assert_ne!(body["result"]["isError"], true, "{body}");
assert_scoped_output(revision, &body, email);
if revision == MODERN_REVISION {
assert_eq!(body["result"]["resultType"], "complete");
}
assert_eq!(self.calls.load(Ordering::SeqCst) - arrivals, 1);
self.counters.sdk_tools_dispatch() - before
}
async fn publish_renamed_tool(&self) {
let now = time::OffsetDateTime::now_utc();
let version = AgentVersion {
agent_id: agent_id(),
version: 2,
status: AgentStatus::Draft,
instructions: json!({}),
tool_selection_policy: ToolSelectionPolicy::default(),
created_at: now,
};
let bindings = [AgentOperationBinding {
operation_id: crank_core::OperationId::new("op_create_lead"),
operation_version: 1,
tool_name: "new_publication_tool".into(),
tool_title: "New Tool".into(),
tool_description_override: None,
enabled: true,
}];
self.registry
.create_agent_draft_version(CreateAgentDraftVersionRequest {
workspace_id: &workspace_id(),
agent_id: &agent_id(),
version: &version,
bindings: &bindings,
updated_at: &now,
})
.await
.unwrap();
self.registry
.publish_agent(PublishAgentRequest {
workspace_id: &workspace_id(),
agent_id: &agent_id(),
version: 2,
published_at: &now,
published_by: Some("alice"),
expected_state: None,
})
.await
.unwrap();
}
}
async fn endpoint_control(revision: &str) -> [usize; 2] {
let h = Endpoint::started().await;
let session = h.session(revision).await;
let session = session.as_deref();
let list_dispatches = h.list(revision, session, TOOL_NAME).await;
let call_dispatches = h
.call(
revision,
session,
TOOL_NAME,
&format!("{revision}@example.test"),
)
.await;
// A fresh publication must be visible without reinitialize or a new endpoint.
h.publish_renamed_tool().await;
h.list(revision, session, "new_publication_tool").await;
h.call(
revision,
session,
"new_publication_tool",
"new-publication@example.test",
)
.await;
h.registry
.revoke_platform_api_key(
&workspace_id(),
&PlatformApiKeyId::new("pk_dispatch_observer"),
&time::OffsetDateTime::now_utc(),
)
.await
.unwrap();
let before_sdk = h.counters.sdk_tools_dispatch();
let arrivals = h.calls.load(Ordering::SeqCst);
let mut denied = if revision == MODERN_REVISION {
modern_tool_call(12, "denied@example.test")
} else {
legacy_tool_call(12, "denied@example.test")
};
denied["params"]["name"] = json!("new_publication_tool");
assert_eq!(h.post(revision, session, &denied).await.status(), 401);
assert_eq!(
h.calls.load(Ordering::SeqCst),
arrivals,
"revoked credential must not execute upstream"
);
assert_eq!(
h.counters.sdk_tools_dispatch(),
before_sdk,
"revocation must reject before SDK dispatch"
);
eprintln!(
"existing GREEN {revision}: JSON list/call, scoped output, upstream=2, publication refresh, revoked=401/no outbound; SDK list/call deltas={:?}",
[list_dispatches, call_dispatches]
);
[list_dispatches, call_dispatches]
}
#[tokio::test]
async fn rmcp_runtime_existing_wire_modern() {
endpoint_control(MODERN_REVISION).await;
}
#[tokio::test]
async fn rmcp_runtime_existing_wire_legacy() {
endpoint_control(LEGACY_REVISION).await;
}
#[tokio::test]
async fn rmcp_runtime_sdk_dispatch_modern() {
let counts = endpoint_control(MODERN_REVISION).await;
assert_eq!(
counts,
[1, 1],
"real endpoint tools/list and tools/call must each enter SDK typed dispatch once (structural seam oracle)"
);
}
#[tokio::test]
async fn rmcp_runtime_sdk_dispatch_legacy() {
let counts = endpoint_control(LEGACY_REVISION).await;
assert_eq!(
counts,
[1, 1],
"real endpoint tools/list and tools/call must each enter SDK typed dispatch once (structural seam oracle)"
);
}
#[tokio::test]
async fn rmcp_runtime_observer_is_request_scoped() {
let counters = Arc::new(CounterSet::default());
sdk_tools_dispatch_enter();
assert_eq!(counters.sdk_tools_dispatch(), 0);
observe(counters.clone(), async {
sdk_tools_dispatch_enter();
})
.await;
assert_eq!(counters.sdk_tools_dispatch(), 1);
let other = Arc::new(CounterSet::default());
observe(other.clone(), async {
sdk_tools_dispatch_enter();
})
.await;
assert_eq!(other.sdk_tools_dispatch(), 1);
assert_eq!(counters.sdk_tools_dispatch(), 1);
}
+7 -1
View File
@@ -1,6 +1,6 @@
# Переход Crank на официальный MCP SDK rmcp
Статус: планирование одобрено владельцем 27.10.2026; 05.11.2026 отдельно разрешён только изолированный опыт этапа 1 (#106). Этапы 2/3 (#107/#108), новая реализация 4.7 и production-переключение этим разрешением не запускаются. Исполняемый кандидат и конкретные несовместимости: [rmcp106-tools-adapter.md](rmcp106-tools-adapter.md); это не завершённая миграция. Владелец очереди — hermes_tl; реализация — hermes_dev; независимая проверка — hermes_qa; Git/CI/релизы — hermes_devops. ARC подключается к конкретному техническому затруднению, не как обязательный новый этап. Business reconciliation 4.6 отменена решением владельца и [issue #34](https://git.itexp.me/bsodfather/crank/issues/34); она не prerequisite SDK. Input/unknown safety и остальные защитные ограничения сохраняются.
Статус: планирование одобрено владельцем 27.10.2026; 05.11.2026 разрешён изолированный опыт этапа 1 (#106), поставленный в v0.4.0-rc.15. [Решением владельца 08.11.2026](https://git.itexp.me/bsodfather/crank/issues/107#issuecomment-2463) разрешён первый Tools-срез этапа 2 (#107) в действующем endpoint без смены transport. #108, новая реализация 4.7 и production-переключение этим разрешением не запускаются. Исполняемый кандидат и конкретные несовместимости: [rmcp106-tools-adapter.md](rmcp106-tools-adapter.md); это не завершённая миграция. Владелец очереди — hermes_tl; реализация — hermes_dev; независимая проверка — hermes_qa; Git/CI/релизы — hermes_devops. ARC подключается к конкретному техническому затруднению, не как обязательный новый этап. Business reconciliation 4.6 отменена решением владельца и [issue #34](https://git.itexp.me/bsodfather/crank/issues/34); она не prerequisite SDK. Input/unknown safety и остальные защитные ограничения сохраняются.
## Результат
@@ -31,6 +31,12 @@
Подключить SDK к действующему пути и перенести стандартные envelopes, dispatch, lifecycle и transport. Порядок переноса устанавливается по результату первого опыта, без параллельных writers одних MCP-файлов.
Первый срез #107: `build_app` направляет `tools/list` обеих revisions и `tools/call` через `app/rmcp_dispatch.rs`. Параметры rmcp=3.7.0 (`PaginatedRequestParams`/`CallToolRequestParams`) определяют команду существующего shared Tools service; расширения Crank `limit`/confirmation сохраняются отдельно. Потребитель — штатный MCP HTTP клиент, не изолированный router #106. Текущие admission, свежая identity, lifecycle, era-specific ответы и PostgreSQL sessions остаются у прежнего transport; SDK HTTP transport не подключён. В следующем Tools response-срезе `app/response.rs` строит и сериализует настоящие rmcp `ListToolsResult`/`Tool` и `CallToolResult`/`ContentBlock`; эти builders используют оба HTTP dispatch и общий JSON/SSE terminal, а изолированный `rmcp_tools` переиспользует typed builders. Явная проекция сохраняет revision defaults, pretty text, tool-error contract, `isError` и present-null `structuredContent`; после SDK list serialization сохраняются исходные top-level extensions/optional null и непрозрачные annotations/icons. Штатный producer публикует name/title/description/inputSchema: расширения защищены локальной builder-регрессией, а не объявлены новыми runtime-полями. HTTP-тесты проверяют обе revisions, success/tool errors/InvalidParams, ID/correlation, modern SSE terminal и несколько страниц опубликованного каталога. JSON-RPC envelope/status остаются прежней внешней границей; остальные handlers, transport и lifecycle ещё не перенесены. Полный #107 не завершён; проверки #106 не являются доказательством завершения миграции.
Следующий Resources-срез #107 подключает `resources/list`, `resources/read` и `resources/templates/list` обеих revisions к тому же `app/rmcp_dispatch.rs`: `PaginatedRequestParams`/`ReadResourceRequestParams` передают cursor/URI прежнему shared Resources service, а Crank `limit` сохраняется отдельно. `app/response.rs` сериализует rmcp `ListResourcesResult`/`Resource`, `ReadResourceResult`/`ResourceContents` и `ListResourceTemplatesResult`/`ResourceTemplate` с прежними revision-specific cache defaults. Минимальная lossless-проекция сохраняет Crank template `parameters`, extensions/optional null и непрозрачные annotations/icons. Штатные producers по-прежнему публикуют прежние поля; builder-регрессия не добавляет runtime-возможностей. Потребитель — действующий `build_app` HTTP JSON/SSE terminal. Реальные HTTP-тесты отдельно подтверждают SDK request/result seam и сохранение wire; существующая Resources-матрица проверяет заполненные templates, exact-version binding, text/JSON/blob, scope/revocation и cursors. Handwritten builders этих трёх результатов заменены; domain/storage/auth, envelopes, transport и lifecycle не меняются. Subscribe/unsubscribe/notifications остаются прежними и не объявляются перенесёнными; остальные handlers и полный #107 ещё не завершены.
Prompts-срез #107 подключает `prompts/list` и `prompts/get` обеих revisions к `app/rmcp_dispatch.rs`: реальные `PaginatedRequestParams`/`GetPromptRequestParams` передают cursor/name и JSON-значения аргументов прежнему shared Prompts service; Crank `limit` сохраняется отдельно. `app/response.rs` сериализует rmcp `ListPromptsResult`/`Prompt` и `GetPromptResult`/`PromptMessage`/`ContentBlock`, используемые штатным `build_app` HTTP JSON/SSE. Lossless-проекция сохраняет typed argument schemas/defaults, extensions/optional null и существующую роль `system`, которую pinned SDK Role не представляет; она восстанавливается после SDK serialization, не меняя опубликованные message boundaries. Прежний dispatch сохраняет revision-specific result/cache projections и ошибки. HTTP ATDD проверяет wire обеих revisions и реальный SDK request/result seam отдельно; affected Prompts/composition regression — exact binding, archive, typed rendering, pinned static/dynamic Resource content и fail-closed dependency errors. Handwritten list/get builders заменены; domain/storage/auth/envelopes/transport/lifecycle не меняются. Completion, notifications/subscriptions/progress/cancel/logging не объявляются перенесёнными. Полный #107 и feature qualification (UI/full/load/p95) этим срезом не завершены.
Проверяемый результат:
- Через SDK проходят действующие Tools, Resources, Prompts, completion, уведомления и подписки в применимых revisions, а также progress/cancel и существующая logging policy.
+84
View File
@@ -0,0 +1,84 @@
#!/usr/bin/env python3
"""Fail-closed detector for release-tooling-only CI changes."""
from __future__ import annotations
import os
import re
import subprocess
import sys
from pathlib import Path
_SHA = re.compile(r"[0-9a-fA-F]{40}\Z")
_ALLOWED = {
".gitea/workflows/release.yml",
"scripts/scan-images.sh",
"scripts/check-image-scan.py",
"scripts/ci-release-assets.py",
"scripts/ci-release-resume.py",
"tests/unit/test_scan_images.py",
"tests/unit/test_check_image_scan.py",
"tests/unit/test_ci_release_assets.py",
"tests/unit/test_ci_release_resume.py",
}
_ALLOWED_BYTES = {path.encode("utf-8") for path in _ALLOWED}
def _git(repo: Path, *args: str) -> subprocess.CompletedProcess[bytes] | None:
try:
return subprocess.run(
["git", "-C", str(repo), *args],
check=False,
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
)
except OSError:
return None
def release_tooling_only(
repo: Path, event_name: str, before_sha: str, pr_base_sha: str, force_full: str
) -> bool:
if force_full.lower() != "false" or event_name not in {"push", "pull_request"}:
return False
raw_base = before_sha if event_name == "push" else pr_base_sha
if not _SHA.fullmatch(raw_base):
return False
available = _git(repo, "cat-file", "-e", f"{raw_base}^{{commit}}")
if available is None or available.returncode != 0:
return False
if event_name == "pull_request":
merge_base = _git(repo, "merge-base", "HEAD", raw_base)
if merge_base is None or merge_base.returncode != 0:
return False
raw_base = merge_base.stdout.decode("ascii", errors="ignore").strip()
if not _SHA.fullmatch(raw_base):
return False
diff = _git(repo, "diff", "--no-renames", "--name-only", "-z", raw_base, "HEAD")
if diff is None or diff.returncode != 0:
return False
paths = diff.stdout.split(b"\0")
paths = [path for path in paths if path]
return bool(paths) and all(path in _ALLOWED_BYTES for path in paths)
def main() -> int:
env = os.environ
ci_only = release_tooling_only(
Path.cwd(),
env.get("GITEA_EVENT_NAME", ""),
env.get("GITEA_EVENT_BEFORE", ""),
env.get("GITEA_PR_BASE_SHA", ""),
env.get("FORCE_FULL", ""),
)
output = env.get("GITHUB_OUTPUT")
if not output:
print("Release-tooling CI scope unavailable; using full Rust checks.")
return 0
with open(output, "a", encoding="utf-8") as stream:
stream.write(f"ci_only={'true' if ci_only else 'false'}\n")
print("Release-tooling-only change detected." if ci_only else "Full Rust checks required.")
return 0
if __name__ == "__main__":
raise SystemExit(main())
+35 -7
View File
@@ -1,8 +1,8 @@
#!/bin/sh
# Scan the built Crank server images with a pinned Trivy and fail closed.
#
# The wrapper downloads and checksum-verifies one fixed Trivy release, downloads
# one fresh vulnerability database, then scans every requested image by its
# The wrapper loads or downloads and checksum-verifies one fixed Trivy release,
# downloads one fresh vulnerability database, then scans every requested image by its
# immutable Docker id with a fully pinned policy. It never trusts a local
# trivy.yaml, .trivyignore, VEX file or skip list: --config and --ignorefile
# point at /dev/null and every inherited TRIVY_* variable is removed before
@@ -14,6 +14,7 @@
#
# db/metadata.json copy of the actual downloaded Trivy DB metadata
# db-download.log database download log
# scanner-cache-source.log archive source provenance
# scanner.json pinned scanner version and scan policy receipt
# <NN-slug>.json raw Trivy JSON report per image
# <NN-slug>.scan.log Trivy scan log per image
@@ -45,6 +46,10 @@ trivy_version="0.70.0"
archive="trivy_${trivy_version}_Linux-64bit.tar.gz"
expected_sha256="8b4376d5d6befe5c24d503f10ff136d9e0c49f9127a4279fd110b727929a5aa9"
download_url="https://github.com/aquasecurity/trivy/releases/download/v${trivy_version}/${archive}"
# Fixed GitHub asset ID for the Trivy 0.70.0 Linux 64-bit release archive.
asset_api_url="https://api.github.com/repos/aquasecurity/trivy/releases/assets/398381981"
tool_cache_root="${RUNNER_TOOL_CACHE:-/opt/hostedtoolcache}"
cached_archive="$tool_cache_root/trivy/$trivy_version/$archive"
db_repository_primary="ghcr.io/aquasecurity/trivy-db:2"
db_repository_fallback="mirror.gcr.io/aquasec/trivy-db:2"
@@ -102,11 +107,34 @@ PY
exit 2
}
# Download and checksum-verify the pinned scanner exactly once.
if ! curl --fail --silent --show-error --location --max-time 300 \
"$download_url" --output "$temp_dir/$archive" \
>"$output_dir/scanner-download.log" 2>&1; then
fail_all "could not download pinned Trivy ${trivy_version}"
# Load the exact-version archive from the runner cache when preinstalled;
# otherwise use the bounded network routes. The shared cache is read-only here.
cache_source_log="$output_dir/scanner-cache-source.log"
: > "$cache_source_log"
if [ -f "$cached_archive" ]; then
printf 'archive_source=runner-tool-cache\n' > "$cache_source_log"
if ! cp "$cached_archive" "$temp_dir/$archive"; then
fail_all "could not copy the pinned Trivy archive from runner tool cache"
fi
else
printf 'archive_source=network\n' > "$cache_source_log"
if ! curl --fail --silent --show-error --location --max-time 300 \
"$download_url" --output "$temp_dir/$archive" \
>"$output_dir/scanner-download.log" 2>&1; then
rm -f "$temp_dir/$archive"
if ! curl --fail --silent --show-error --location --max-time 300 \
--header 'Accept: application/octet-stream' \
"$asset_api_url" --output "$temp_dir/$archive" \
>"$output_dir/scanner-api-download.log" 2>&1; then
printf 'network_download=failed\n' >> "$cache_source_log"
fail_all "could not download pinned Trivy ${trivy_version} from release URL or GitHub asset API"
fi
printf 'archive_source=github-release-asset-api\n' > "$cache_source_log"
printf 'Downloaded pinned Trivy %s from GitHub release asset API.\n' "$trivy_version" \
>>"$output_dir/scanner-api-download.log"
else
printf 'archive_source=github-release-download\n' > "$cache_source_log"
fi
fi
if ! printf '%s %s\n' "$expected_sha256" "$temp_dir/$archive" \
| sha256sum --check --status; then
+140
View File
@@ -0,0 +1,140 @@
from __future__ import annotations
import subprocess
import tempfile
import unittest
import importlib.util
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
SCRIPT = ROOT / "scripts" / "ci-release-tooling-scope.py"
spec = importlib.util.spec_from_file_location("ci_release_tooling_scope", SCRIPT)
assert spec and spec.loader
scope = importlib.util.module_from_spec(spec)
spec.loader.exec_module(scope)
WORKFLOW = ROOT / ".gitea/workflows/ci.yml"
_FALSE = "false"
class ReleaseToolingScopeTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.repo = Path(self.temp.name)
self.git("init", "-q")
self.git("config", "user.email", "ci-scope@example.test")
self.git("config", "user.name", "CI Scope Test")
self.write("src/lib.rs", "pub fn initial() {}\n")
self.write("scripts/scan-images.sh", "#!/bin/sh\nexit 0\n")
self.write("tests/unit/test_scan_images.py", "# initial\n")
self.git("add", ".")
self.git("commit", "-qm", "baseline")
self.base = self.head()
def git(self, *args: str) -> str:
result = subprocess.run(
["git", "-C", str(self.repo), *args],
check=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
)
return result.stdout.strip()
def head(self) -> str:
return self.git("rev-parse", "HEAD")
def write(self, relative: str, content: str) -> None:
path = self.repo / relative
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(content, encoding="utf-8")
def commit(self, message: str = "change") -> None:
self.git("add", "-A")
self.git("commit", "-qm", message)
def classify(self, event="push", before=None, base=None, force=_FALSE) -> bool:
return scope.release_tooling_only(
self.repo,
event,
self.base if before is None else before,
self.base if base is None else base,
force,
)
def test_release_only_diff_is_safe_for_push_and_pull_request(self):
self.write(".gitea/workflows/release.yml", "# release tooling update\n")
self.write("scripts/scan-images.sh", "#!/bin/sh\n# scanner update\n")
self.commit()
self.assertTrue(self.classify("push", before=self.base))
self.assertTrue(self.classify("pull_request", base=self.base))
def test_rust_or_mixed_diff_requires_full_ci(self):
self.write("src/lib.rs", "pub fn changed() {}\n")
self.commit("Rust change")
self.assertFalse(self.classify("push", before=self.base))
self.write("scripts/scan-images.sh", "#!/bin/sh\n# tooling change\n")
self.write("src/lib.rs", "pub fn changed_again() {}\n")
self.commit("mixed change")
self.assertFalse(self.classify("push", before=self.base))
def test_rename_from_rust_into_allowlist_is_not_safe(self):
(self.repo / ".gitea/workflows").mkdir(parents=True)
self.git("mv", "src/lib.rs", ".gitea/workflows/release.yml")
self.commit("rename Rust source into release path")
self.assertFalse(self.classify("push", before=self.base))
def test_unavailable_zero_empty_and_missing_bases_require_full_ci(self):
self.write("scripts/scan-images.sh", "#!/bin/sh\n# allowed\n")
self.commit()
self.assertFalse(self.classify("push", before=""))
self.assertFalse(self.classify("push", before="0" * 40))
self.assertFalse(self.classify("push", before="1" * 40))
self.assertFalse(self.classify("push", before=self.head()))
self.assertFalse(self.classify("pull_request", base=""))
def test_manual_feature_and_unknown_force_metadata_require_full_ci(self):
self.write("scripts/scan-images.sh", "#!/bin/sh\n# allowed\n")
self.commit()
self.assertFalse(self.classify("workflow_dispatch", before=self.base))
self.assertFalse(self.classify("push", before=self.base, force="true"))
self.assertFalse(self.classify("push", before=self.base, force=""))
def test_non_allowlisted_ci_self_change_requires_full_ci(self):
self.write(".gitea/workflows/ci.yml", "# detector workflow change\n")
self.commit()
self.assertFalse(self.classify("push", before=self.base))
class WorkflowScopeTests(unittest.TestCase):
def test_only_four_heavy_rust_steps_are_skippable(self):
workflow = WORKFLOW.read_text(encoding="utf-8")
self.assertIn("run: python3 scripts/ci-release-tooling-scope.py", workflow)
self.assertIn("FORCE_FULL: ${{ inputs.validation_level == 'feature' || contains(gitea.event.pull_request.labels.*.name, 'feature-ready') }}", workflow)
conditional = "if: steps.release_tooling.outputs.ci_only != 'true'"
for name in (
"Check typed runtime configuration contract",
"Check canonical migration contract",
"Check typed metrics contract",
"Run Crank story ATDD",
):
start = workflow.index(f"- name: {name}")
self.assertIn(conditional, workflow[start : start + 180])
for name in (
"Install Rust toolchain",
"Run tooling unit tests",
"Check formatting",
"Check Rust boundaries",
"Check OpenAPI matrix and corpus compatibility versions",
):
start = workflow.index(f"- name: {name}")
self.assertNotIn("if:", workflow[start : start + 160])
self.assertIn("name: Rust Checks", workflow)
self.assertIn("name: UI Checks", workflow)
self.assertIn("name: Required Checks", workflow)
if __name__ == "__main__":
unittest.main()
+94 -4
View File
@@ -27,9 +27,18 @@ import os
import sys
args = sys.argv[1:]
if os.environ.get("FAKE_CURL_FAIL") == "1":
sys.stderr.write("curl: (7) failed to connect\\n")
url = next((value for value in args if value.startswith("https://")), "")
api_download = url == "https://api.github.com/repos/aquasecurity/trivy/releases/assets/398381981"
failed = os.environ.get("FAKE_CURL_FAIL") == "1"
failed = failed or (not api_download and os.environ.get("FAKE_CURL_DIRECT_FAIL") == "1")
failed = failed or (api_download and os.environ.get("FAKE_CURL_API_FAIL") == "1")
if failed:
sys.stderr.write("curl: (22) fixture download failure for " + url + "\\n")
sys.exit(7)
if api_download:
if "--header" not in args or args[args.index("--header") + 1] != "Accept: application/octet-stream":
sys.stderr.write("curl: missing octet-stream Accept header\\n")
sys.exit(2)
output = None
for index, value in enumerate(args):
if value in ("--output", "-o"):
@@ -37,7 +46,8 @@ for index, value in enumerate(args):
if output is None:
sys.stderr.write("curl: missing --output\\n")
sys.exit(2)
with open(os.environ["FAKE_CURL_ARCHIVE"], "rb") as source:
archive_path = os.environ.get("FAKE_CURL_API_ARCHIVE", os.environ["FAKE_CURL_ARCHIVE"]) if api_download else os.environ["FAKE_CURL_ARCHIVE"]
with open(archive_path, "rb") as source:
payload = source.read()
with open(output, "wb") as target:
target.write(payload)
@@ -176,6 +186,10 @@ class ScanImagesWrapperTests(unittest.TestCase):
images=(VULN_TAG, CLEAN_TAG),
trivy_fail_id=None,
curl_fail=False,
curl_direct_fail=False,
curl_api_fail=False,
api_checksum_mismatch=False,
cache_archive=None,
extra_env=None,
workdir_files=None,
run_in_workdir=False,
@@ -214,6 +228,13 @@ class ScanImagesWrapperTests(unittest.TestCase):
archive_path = root / "trivy-fixture.tar.gz"
archive_path.write_bytes(fixture_archive)
api_archive_path = root / "trivy-api-fixture.tar.gz"
api_archive_path.write_bytes(fixture_archive + b"tampered" if api_checksum_mismatch else fixture_archive)
tool_cache = root / "runner-tool-cache"
if cache_archive is not None:
cached_path = tool_cache / "trivy" / "0.70.0" / "trivy_0.70.0_Linux-64bit.tar.gz"
cached_path.parent.mkdir(parents=True)
cached_path.write_bytes(fixture_archive if cache_archive == "valid" else b"invalid archive")
reports = root / "reports"
reports.mkdir()
@@ -246,8 +267,10 @@ class ScanImagesWrapperTests(unittest.TestCase):
env.update(
{
"PATH": f"{bin_dir}:{env['PATH']}",
"RUNNER_TOOL_CACHE": str(tool_cache),
"CRANK_IMAGE_SCAN_OUTPUT_DIR": str(evidence),
"FAKE_CURL_ARCHIVE": str(archive_path),
"FAKE_CURL_API_ARCHIVE": str(api_archive_path),
"FAKE_IMAGE_MAP": str(image_map),
"FAKE_REPORT_DIR": str(reports),
"FAKE_DOCKER_LOG": str(docker_log),
@@ -258,6 +281,10 @@ class ScanImagesWrapperTests(unittest.TestCase):
env["FAKE_TRIVY_FAIL_ID"] = trivy_fail_id
if curl_fail:
env["FAKE_CURL_FAIL"] = "1"
if curl_direct_fail:
env["FAKE_CURL_DIRECT_FAIL"] = "1"
if curl_api_fail:
env["FAKE_CURL_API_FAIL"] = "1"
if extra_env:
env.update(extra_env)
@@ -442,6 +469,68 @@ class ScanImagesWrapperTests(unittest.TestCase):
self.assertEqual(docker_calls, [])
self.assertEqual(trivy_calls, [])
def test_pinned_asset_api_fallback_downloads_and_verifies_same_archive(self):
result, _, evidence, receipt, _, trivy_calls = self.run_scan(
images=(CLEAN_TAG,), curl_direct_fail=True
)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(receipt["overall"]["status"], "pass")
self.assertIn("fixture download failure", (evidence / "scanner-download.log").read_text())
self.assertIn("GitHub release asset API", (evidence / "scanner-api-download.log").read_text())
self.assertTrue(any("--download-db-only" in call["args"] for call in trivy_calls))
scanner = json.loads((evidence / "scanner.json").read_text(encoding="utf-8"))
self.assertEqual(scanner["expected_version"], "0.70.0")
def test_pinned_asset_api_fallback_failure_fails_closed_with_both_logs(self):
result, _, evidence, receipt, _, trivy_calls = self.run_scan(
images=(CLEAN_TAG,), curl_direct_fail=True, curl_api_fail=True
)
self.assertEqual(result.returncode, 2)
self.assertEqual(receipt["overall"]["status"], "error")
self.assertIn("fixture download failure", (evidence / "scanner-download.log").read_text())
self.assertIn("fixture download failure", (evidence / "scanner-api-download.log").read_text())
self.assertEqual(trivy_calls, [])
def test_pinned_asset_api_fallback_checksum_mismatch_never_executes_trivy(self):
result, _, evidence, receipt, _, trivy_calls = self.run_scan(
images=(CLEAN_TAG,), curl_direct_fail=True, api_checksum_mismatch=True
)
self.assertEqual(result.returncode, 2)
self.assertEqual(receipt["overall"]["status"], "error")
self.assertIn("checksum mismatch", result.stderr)
self.assertEqual(trivy_calls, [])
def test_preloaded_pinned_archive_runs_without_network(self):
result, root, evidence, receipt, _, trivy_calls = self.run_scan(
images=(CLEAN_TAG,), cache_archive="valid", curl_fail=True
)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(receipt["overall"]["status"], "pass")
self.assertEqual(
(evidence / "scanner-cache-source.log").read_text(),
"archive_source=runner-tool-cache\n",
)
self.assertFalse((evidence / "scanner-download.log").exists())
self.assertFalse((evidence / "scanner-api-download.log").exists())
cached = root / "runner-tool-cache" / "trivy" / "0.70.0" / "trivy_0.70.0_Linux-64bit.tar.gz"
self.assertEqual(cached.read_bytes(), (root / "trivy-fixture.tar.gz").read_bytes())
self.assertTrue(any("--download-db-only" in call["args"] for call in trivy_calls))
def test_preloaded_archive_hash_mismatch_fails_before_network_or_execution(self):
result, _, evidence, receipt, _, trivy_calls = self.run_scan(
images=(CLEAN_TAG,), cache_archive="bad", curl_fail=True
)
self.assertEqual(result.returncode, 2)
self.assertEqual(receipt["overall"]["status"], "error")
self.assertIn("checksum mismatch", result.stderr)
self.assertEqual(
(evidence / "scanner-cache-source.log").read_text(),
"archive_source=runner-tool-cache\n",
)
self.assertFalse((evidence / "scanner-download.log").exists())
self.assertFalse((evidence / "scanner-api-download.log").exists())
self.assertEqual(trivy_calls, [])
def test_unknown_image_is_error_and_is_never_scanned(self):
missing = "crank/missing:ci"
result, _, _, receipt, _, trivy_calls = self.run_scan(images=(missing, CLEAN_TAG))
@@ -457,7 +546,8 @@ class ScanImagesWrapperTests(unittest.TestCase):
result, _, evidence, receipt, _, _ = self.run_scan(curl_fail=True)
self.assertEqual(result.returncode, 2, result.stderr)
self.assertEqual(receipt["overall"]["status"], "error")
self.assertIn("failed to connect", (evidence / "scanner-download.log").read_text())
self.assertIn("fixture download failure", (evidence / "scanner-download.log").read_text())
self.assertIn("fixture download failure", (evidence / "scanner-api-download.log").read_text())
def test_evidence_kept_even_when_gate_is_red(self):
_, _, evidence, receipt, _, _ = self.run_scan()