Compare commits
5
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
541b135baf | ||
|
|
835947e9fc | ||
|
|
2b36add550 | ||
|
|
4832878468 | ||
|
|
5bf4e3e9bf |
No files matched your search
@@ -40,6 +40,7 @@ mod rmcp_http;
|
||||
#[cfg(test)]
|
||||
#[path = "rmcp_http_tests.rs"]
|
||||
mod rmcp_http_tests;
|
||||
mod rmcp_progress_cancel;
|
||||
#[cfg(test)]
|
||||
mod rmcp_session_tests;
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -63,9 +63,34 @@ pub(crate) struct CounterSet {
|
||||
sdk_prompts_get_result: AtomicUsize,
|
||||
sdk_completion_dispatch: AtomicUsize,
|
||||
sdk_completion_result: AtomicUsize,
|
||||
sdk_logging_dispatch: AtomicUsize,
|
||||
sdk_logging_level: AtomicUsize,
|
||||
sdk_logging_notification: AtomicUsize,
|
||||
sdk_progress_notification: AtomicUsize,
|
||||
sdk_cancelled_params: AtomicUsize,
|
||||
}
|
||||
|
||||
impl CounterSet {
|
||||
pub(crate) fn sdk_progress_notification(&self) -> usize {
|
||||
self.sdk_progress_notification.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_cancelled_params(&self) -> usize {
|
||||
self.sdk_cancelled_params.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_logging_dispatch(&self) -> usize {
|
||||
self.sdk_logging_dispatch.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_logging_level(&self) -> usize {
|
||||
self.sdk_logging_level.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_logging_notification(&self) -> usize {
|
||||
self.sdk_logging_notification.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
pub(crate) fn sdk_completion_dispatch(&self) -> usize {
|
||||
self.sdk_completion_dispatch.load(Ordering::SeqCst)
|
||||
}
|
||||
@@ -269,6 +294,37 @@ pub(crate) fn sdk_completion_result_serialized() {
|
||||
#[path = "../rmcp_completion_runtime_tests.rs"]
|
||||
mod rmcp_completion_runtime_tests;
|
||||
|
||||
/// Mark only after constructing the real SDK typed legacy logging request.
|
||||
pub(crate) fn sdk_logging_dispatch_enter() {
|
||||
increment(|counters| &counters.sdk_logging_dispatch);
|
||||
}
|
||||
|
||||
/// Mark only after successfully decoding a real SDK LoggingLevel at either input.
|
||||
pub(crate) fn sdk_logging_level_parsed() {
|
||||
increment(|counters| &counters.sdk_logging_level);
|
||||
}
|
||||
|
||||
/// Mark only after serializing real SDK LoggingMessageNotificationParam params, not an envelope.
|
||||
pub(crate) fn sdk_logging_notification_serialized() {
|
||||
increment(|counters| &counters.sdk_logging_notification);
|
||||
}
|
||||
|
||||
#[path = "../rmcp_logging_runtime_tests.rs"]
|
||||
mod rmcp_logging_runtime_tests;
|
||||
|
||||
/// Mark only after successfully serializing real SDK ProgressNotificationParam params.
|
||||
pub(crate) fn sdk_progress_notification_serialized() {
|
||||
increment(|counters| &counters.sdk_progress_notification);
|
||||
}
|
||||
|
||||
/// Mark successful SDK CancelledNotificationParam decoding, not successful cancellation.
|
||||
pub(crate) fn sdk_cancelled_params_decoded() {
|
||||
increment(|counters| &counters.sdk_cancelled_params);
|
||||
}
|
||||
|
||||
#[path = "../rmcp_progress_cancel_runtime_tests.rs"]
|
||||
mod rmcp_progress_cancel_runtime_tests;
|
||||
|
||||
fn increment(counter: impl Fn(&CounterSet) -> &AtomicUsize) {
|
||||
let _ = OBSERVER.try_with(|counters| {
|
||||
counter(counters).fetch_add(1, Ordering::SeqCst);
|
||||
|
||||
@@ -799,27 +799,24 @@ async fn handle_cancelled_notification(
|
||||
message: &Value,
|
||||
credential: &VerifiedMachineCredential,
|
||||
) -> Response {
|
||||
let request_id = params(message).get("requestId").cloned();
|
||||
let request_id = super::rmcp_progress_cancel::decode_cancelled_request_id(¶ms(message));
|
||||
let session_id = session_id_from_headers(headers).ok().flatten();
|
||||
if let (Some(request_id), Some(session_id)) = (request_id, session_id) {
|
||||
// Only a string or a number is a pinned `RequestId`; anything else cannot name a call.
|
||||
if matches!(request_id, Value::String(_) | Value::Number(_)) {
|
||||
let owned_by_session = match state.sessions.get(&session_id).await {
|
||||
Ok(Some(session)) => {
|
||||
session.workspace_slug == path.workspace_slug
|
||||
&& session.agent_slug == path.agent_slug
|
||||
}
|
||||
_ => false,
|
||||
};
|
||||
if owned_by_session {
|
||||
state.in_flight.cancel(
|
||||
&crate::app::lifecycle::InFlightScope {
|
||||
session_id,
|
||||
owner: in_flight_owner(credential),
|
||||
},
|
||||
&request_id,
|
||||
);
|
||||
let owned_by_session = match state.sessions.get(&session_id).await {
|
||||
Ok(Some(session)) => {
|
||||
session.workspace_slug == path.workspace_slug
|
||||
&& session.agent_slug == path.agent_slug
|
||||
}
|
||||
_ => false,
|
||||
};
|
||||
if owned_by_session {
|
||||
state.in_flight.cancel(
|
||||
&crate::app::lifecycle::InFlightScope {
|
||||
session_id,
|
||||
owner: in_flight_owner(credential),
|
||||
},
|
||||
&request_id,
|
||||
);
|
||||
}
|
||||
}
|
||||
StatusCode::ACCEPTED.into_response()
|
||||
|
||||
@@ -34,6 +34,7 @@ use axum::{
|
||||
};
|
||||
use crank_core::{CorrelationContext, ExecutionLocale, VerifiedMachineCredential};
|
||||
use futures_util::stream;
|
||||
use rmcp::model::{NumberOrString, ProgressNotificationParam};
|
||||
use serde_json::{Number, Value, json};
|
||||
use tokio::sync::{mpsc, watch};
|
||||
|
||||
@@ -82,10 +83,13 @@ impl ProgressToken {
|
||||
}
|
||||
}
|
||||
|
||||
fn as_value(&self) -> Value {
|
||||
fn sdk_token(&self) -> NumberOrString {
|
||||
match self {
|
||||
Self::Text(text) => Value::String(text.clone()),
|
||||
Self::Number(number) => Value::Number(number.clone()),
|
||||
Self::Text(text) => NumberOrString::String(text.clone().into()),
|
||||
Self::Number(number) => number.as_i64().map_or_else(
|
||||
|| NumberOrString::String(number.to_string().into()),
|
||||
NumberOrString::Number,
|
||||
),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -132,14 +136,24 @@ pub(crate) struct ProgressEvent {
|
||||
/// The pinned `notifications/progress` frame. Both supported revisions declare the same parameters,
|
||||
/// so the projection is shared; the token is echoed verbatim and never validated as a credential.
|
||||
pub(super) fn progress_frame(token: &ProgressToken, event: &ProgressEvent) -> Value {
|
||||
let sdk_params = ProgressNotificationParam::new(
|
||||
rmcp::model::ProgressToken(token.sdk_token()),
|
||||
event.progress as f64,
|
||||
)
|
||||
.with_message(event.message);
|
||||
let mut params = serde_json::to_value(sdk_params)
|
||||
.expect("finite progress and string/number token are serializable SDK params");
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_progress_notification_serialized();
|
||||
// SDK uses i64 tokens and f64 progress; restore the original JSON numbers before wire delivery.
|
||||
if let ProgressToken::Number(number) = token {
|
||||
params["progressToken"] = Value::Number(number.clone());
|
||||
}
|
||||
params["progress"] = Value::from(event.progress);
|
||||
json!({
|
||||
"jsonrpc": "2.0",
|
||||
"method": "notifications/progress",
|
||||
"params": {
|
||||
"progressToken": token.as_value(),
|
||||
"progress": event.progress,
|
||||
"message": event.message,
|
||||
}
|
||||
"params": params,
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
@@ -7,6 +7,44 @@ fn token(value: Value) -> Option<ProgressToken> {
|
||||
progress_token(&json!({ "_meta": { "progressToken": value } }))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rmcp_progress_cancel_frame_preserves_serialized_numbers_and_omissions() {
|
||||
for wire_token in [
|
||||
"\"token\"",
|
||||
"-7",
|
||||
"1.5",
|
||||
"1.0",
|
||||
"-0.0",
|
||||
"18446744073709551615",
|
||||
] {
|
||||
let value: Value = serde_json::from_str(wire_token).unwrap();
|
||||
for progress in [2, 9_007_199_254_740_993, u64::MAX] {
|
||||
let frame = progress_frame(
|
||||
&token(value.clone()).unwrap(),
|
||||
&ProgressEvent {
|
||||
progress,
|
||||
message: "execution_dispatched",
|
||||
},
|
||||
);
|
||||
assert_eq!(frame["params"]["progressToken"].to_string(), wire_token);
|
||||
assert_eq!(
|
||||
frame["params"]["progress"].to_string(),
|
||||
progress.to_string()
|
||||
);
|
||||
assert_eq!(
|
||||
frame["params"],
|
||||
json!({
|
||||
"progressToken": value, "progress": progress, "message": "execution_dispatched"
|
||||
})
|
||||
);
|
||||
assert!(frame["params"].get("total").is_none());
|
||||
assert!(frame["params"].get("_meta").is_none());
|
||||
assert_eq!(frame["jsonrpc"], "2.0");
|
||||
assert_eq!(frame["method"], "notifications/progress");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_pinned_progress_token_is_a_bounded_string_or_a_number() {
|
||||
assert_eq!(
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
//! Lossless projection of legacy cancellation targets through the pinned SDK.
|
||||
|
||||
use rmcp::model::CancelledNotificationParam;
|
||||
use serde_json::{Map, Value};
|
||||
|
||||
pub(super) fn decode_cancelled_request_id(params: &Value) -> Option<Value> {
|
||||
let mut projection = Map::new();
|
||||
let original_id = params.get("requestId");
|
||||
if let Some(id) = original_id {
|
||||
// SDK IDs use i64; the temporary string never reaches the in-flight lookup.
|
||||
let projected = match id {
|
||||
Value::Number(number) if number.as_i64().is_none() => Value::String(number.to_string()),
|
||||
_ => id.clone(),
|
||||
};
|
||||
projection.insert("requestId".to_owned(), projected);
|
||||
}
|
||||
// Only requestId names a target; reason, _meta and extensions retain their ignore semantics.
|
||||
let decoded =
|
||||
serde_json::from_value::<CancelledNotificationParam>(Value::Object(projection)).ok()?;
|
||||
#[cfg(test)]
|
||||
super::dispatch_observer::sdk_cancelled_params_decoded();
|
||||
let id = decoded.request_id?;
|
||||
Some(match original_id {
|
||||
Some(Value::Number(number)) => Value::Number(number.clone()),
|
||||
_ => id.into_json_value(),
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "rmcp_progress_cancel_tests.rs"]
|
||||
mod tests;
|
||||
@@ -0,0 +1,52 @@
|
||||
use super::decode_cancelled_request_id;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
#[test]
|
||||
fn rmcp_progress_cancel_decoder_preserves_exact_ids_and_ignores_other_fields() {
|
||||
for wire_id in [
|
||||
"\"7\"",
|
||||
"7",
|
||||
"-7",
|
||||
"1.5",
|
||||
"1.0",
|
||||
"-0.0",
|
||||
"18446744073709551615",
|
||||
"\"\"",
|
||||
"\"line\\nbreak\"",
|
||||
] {
|
||||
let id: Value = serde_json::from_str(wire_id).unwrap();
|
||||
let params = json!({
|
||||
"requestId": id, "reason": 42, "_meta": [], "unknown": {"nested": [true]}
|
||||
});
|
||||
let decoded = decode_cancelled_request_id(¶ms).unwrap();
|
||||
assert_eq!(decoded.to_string(), wire_id);
|
||||
}
|
||||
let long_id = Value::String("x".repeat(1024));
|
||||
assert_eq!(
|
||||
decode_cancelled_request_id(&json!({"requestId": long_id})),
|
||||
Some(long_id)
|
||||
);
|
||||
assert_ne!(
|
||||
decode_cancelled_request_id(&json!({"requestId": "7"})),
|
||||
decode_cancelled_request_id(&json!({"requestId": 7}))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rmcp_progress_cancel_decoder_has_no_target_for_invalid_or_missing_ids() {
|
||||
for params in [
|
||||
json!(null),
|
||||
json!(true),
|
||||
json!(7),
|
||||
json!("requestId"),
|
||||
json!([]),
|
||||
json!({}),
|
||||
json!({"requestId": null}),
|
||||
json!({"requestId": true}),
|
||||
json!({"requestId": []}),
|
||||
json!({"requestId": {}}),
|
||||
json!({"reason": "ignored", "_meta": []}),
|
||||
] {
|
||||
assert_eq!(decode_cancelled_request_id(¶ms), None, "{params}");
|
||||
}
|
||||
}
|
||||
@@ -41,6 +41,9 @@ use std::{
|
||||
sync::{Mutex, MutexGuard},
|
||||
};
|
||||
|
||||
// Both pinned revisions still require logging despite the SDK's SEP-2577 deprecation.
|
||||
#[allow(deprecated)]
|
||||
use rmcp::model::{LoggingLevel, LoggingMessageNotificationParam, SetLevelRequestParams};
|
||||
use serde::Deserialize;
|
||||
use serde_json::{Value, json};
|
||||
use tokio::task_local;
|
||||
@@ -61,7 +64,8 @@ pub(crate) enum LogLevel {
|
||||
}
|
||||
|
||||
impl LogLevel {
|
||||
/// The exact wire literal of this level.
|
||||
/// The exact wire literal of this level (contract assertions only; runtime uses SDK serde).
|
||||
#[cfg(test)]
|
||||
pub(crate) const fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Self::Debug => "debug",
|
||||
@@ -80,17 +84,47 @@ impl LogLevel {
|
||||
/// Nothing is coerced: no case folding, no aliases (`warn`), no numeric severities. A value that
|
||||
/// is not one of the pinned strings is malformed, which is what the pinned `LoggingLevel` type
|
||||
/// says and what `InvalidParamsError` is for.
|
||||
#[allow(deprecated)]
|
||||
pub(crate) fn parse(value: &str) -> Option<Self> {
|
||||
match value {
|
||||
"debug" => Some(Self::Debug),
|
||||
"info" => Some(Self::Info),
|
||||
"notice" => Some(Self::Notice),
|
||||
"warning" => Some(Self::Warning),
|
||||
"error" => Some(Self::Error),
|
||||
"critical" => Some(Self::Critical),
|
||||
"alert" => Some(Self::Alert),
|
||||
"emergency" => Some(Self::Emergency),
|
||||
_ => None,
|
||||
if value.len() > MAX_LEVEL_BYTES {
|
||||
return None;
|
||||
}
|
||||
let level: LoggingLevel = serde_json::from_value(Value::String(value.to_owned())).ok()?;
|
||||
#[cfg(test)]
|
||||
crate::app::dispatch_observer::sdk_logging_level_parsed();
|
||||
Some(level.into())
|
||||
}
|
||||
}
|
||||
|
||||
// Keep domain severity ordering independent of SDK enum discriminants (which have no Ord).
|
||||
#[allow(deprecated)]
|
||||
impl From<LoggingLevel> for LogLevel {
|
||||
fn from(level: LoggingLevel) -> Self {
|
||||
match level {
|
||||
LoggingLevel::Debug => Self::Debug,
|
||||
LoggingLevel::Info => Self::Info,
|
||||
LoggingLevel::Notice => Self::Notice,
|
||||
LoggingLevel::Warning => Self::Warning,
|
||||
LoggingLevel::Error => Self::Error,
|
||||
LoggingLevel::Critical => Self::Critical,
|
||||
LoggingLevel::Alert => Self::Alert,
|
||||
LoggingLevel::Emergency => Self::Emergency,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(deprecated)]
|
||||
impl From<LogLevel> for LoggingLevel {
|
||||
fn from(level: LogLevel) -> Self {
|
||||
match level {
|
||||
LogLevel::Debug => Self::Debug,
|
||||
LogLevel::Info => Self::Info,
|
||||
LogLevel::Notice => Self::Notice,
|
||||
LogLevel::Warning => Self::Warning,
|
||||
LogLevel::Error => Self::Error,
|
||||
LogLevel::Critical => Self::Critical,
|
||||
LogLevel::Alert => Self::Alert,
|
||||
LogLevel::Emergency => Self::Emergency,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -135,11 +169,20 @@ pub(crate) struct SetLevelCommand {
|
||||
impl SetLevelCommand {
|
||||
/// The bounded input contract of AC2: the level is length-bounded and compared exactly, so a
|
||||
/// malformed or oversized value is refused with bounded work and one safe detail.
|
||||
pub(crate) fn validate(&self) -> Result<LogLevel, &'static str> {
|
||||
#[allow(deprecated)]
|
||||
pub(crate) fn validate(&self) -> Result<SetLevelRequestParams, &'static str> {
|
||||
if self.level.is_empty() || self.level.len() > MAX_LEVEL_BYTES {
|
||||
return Err(INVALID_LEVEL);
|
||||
}
|
||||
LogLevel::parse(&self.level).ok_or(INVALID_LEVEL)
|
||||
// Only level was part of the old command: unknown members (including _meta) stay ignored.
|
||||
let request =
|
||||
serde_json::from_value(json!({"level": self.level})).map_err(|_| INVALID_LEVEL)?;
|
||||
#[cfg(test)]
|
||||
{
|
||||
crate::app::dispatch_observer::sdk_logging_level_parsed();
|
||||
crate::app::dispatch_observer::sdk_logging_dispatch_enter();
|
||||
}
|
||||
Ok(request)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -282,19 +325,22 @@ pub(crate) fn take_notifications() -> Vec<Value> {
|
||||
}
|
||||
std::mem::take(&mut log.pending)
|
||||
.into_iter()
|
||||
.map(|event| {
|
||||
json!({
|
||||
.filter_map(|event| {
|
||||
#[allow(deprecated)]
|
||||
let params = LoggingMessageNotificationParam::new(
|
||||
event.level.into(),
|
||||
json!({"event": event.event, "outcome": event.outcome}),
|
||||
)
|
||||
.with_logger(LOGGER_NAME);
|
||||
// Logging remains best-effort: a serialization failure drops only this event.
|
||||
let params = serde_json::to_value(params).ok()?;
|
||||
#[cfg(test)]
|
||||
crate::app::dispatch_observer::sdk_logging_notification_serialized();
|
||||
Some(json!({
|
||||
"jsonrpc": "2.0",
|
||||
"method": "notifications/message",
|
||||
"params": {
|
||||
"level": event.level.as_str(),
|
||||
"logger": LOGGER_NAME,
|
||||
"data": {
|
||||
"event": event.event,
|
||||
"outcome": event.outcome,
|
||||
}
|
||||
}
|
||||
})
|
||||
"params": params,
|
||||
}))
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
@@ -354,7 +400,9 @@ pub(crate) fn handle_logging_command(
|
||||
command: SetLevelCommand,
|
||||
) -> LoggingOutcome {
|
||||
match command.validate() {
|
||||
Ok(level) => {
|
||||
Ok(request) => {
|
||||
#[allow(deprecated)]
|
||||
let level = request.level.into();
|
||||
store.set(session_id, level);
|
||||
LoggingOutcome::Applied(level)
|
||||
}
|
||||
|
||||
@@ -10,7 +10,8 @@ use super::*;
|
||||
/// is malformed (which the adapter answers with the same safe detail).
|
||||
fn validate(level: &str) -> Option<Result<LogLevel, &'static str>> {
|
||||
let command: SetLevelCommand = serde_json::from_value(json!({ "level": level })).ok()?;
|
||||
Some(command.validate())
|
||||
#[allow(deprecated)]
|
||||
Some(command.validate().map(|request| request.level.into()))
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -291,8 +292,11 @@ fn the_modern_level_is_read_from_the_pinned_meta_key_only() {
|
||||
fn the_command_records_the_level_of_its_own_session_only() {
|
||||
let store = LogLevelStore::new();
|
||||
store.set("other-session", LogLevel::Debug);
|
||||
let command: SetLevelCommand =
|
||||
serde_json::from_value(json!({ "level": "critical" })).expect("a pinned level parses");
|
||||
// Unknown members were ignored by the legacy command; SDK metadata must not narrow that wire.
|
||||
let command: SetLevelCommand = serde_json::from_value(json!({
|
||||
"level": "critical", "_meta": 7, "unknown": {"private": "ignored"}
|
||||
}))
|
||||
.expect("a pinned level parses regardless of unknown members");
|
||||
let outcome = handle_logging_command(&store, "this-session", command);
|
||||
assert!(matches!(
|
||||
outcome,
|
||||
|
||||
@@ -0,0 +1,258 @@
|
||||
//! #107 logging: existing HTTP wire control before the independent SDK marker assertions.
|
||||
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_logging_test_support.rs"]
|
||||
mod fixtures;
|
||||
use fixtures::Endpoint;
|
||||
const LEVEL: &str = "io.modelcontextprotocol/logLevel";
|
||||
|
||||
fn counts(c: &CounterSet) -> [usize; 3] {
|
||||
[
|
||||
c.sdk_logging_dispatch(),
|
||||
c.sdk_logging_level(),
|
||||
c.sdk_logging_notification(),
|
||||
]
|
||||
}
|
||||
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, c)| async move {
|
||||
observe(c.clone(), body.next())
|
||||
.await
|
||||
.map(|chunk| (chunk, (body, c)))
|
||||
},
|
||||
);
|
||||
Response::from_parts(parts, Body::from_stream(body))
|
||||
}
|
||||
fn notification(level: &str, event: &str, outcome: &str) -> Value {
|
||||
json!({"jsonrpc":"2.0","method":"notifications/message","params":{
|
||||
"level":level,"logger":"crank-mcp-server","data":{"event":event,"outcome":outcome}}})
|
||||
}
|
||||
async fn reply(response: reqwest::Response) -> (Value, Vec<Value>, String) {
|
||||
let status = response.status();
|
||||
assert!(
|
||||
status == 200 || status == 404,
|
||||
"unexpected HTTP status {status}"
|
||||
);
|
||||
let sse = response.headers()["content-type"]
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.starts_with("text/event-stream");
|
||||
let raw = tokio::time::timeout(Duration::from_secs(5), response.text())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let mut frames: Vec<Value> = if sse {
|
||||
raw.lines()
|
||||
.filter_map(|line| {
|
||||
line.strip_prefix("data:")
|
||||
.map(|s| serde_json::from_str(s.trim()).unwrap())
|
||||
})
|
||||
.collect()
|
||||
} else {
|
||||
vec![serde_json::from_str(&raw).unwrap()]
|
||||
};
|
||||
let terminal = frames.pop().expect("one terminal response");
|
||||
assert_eq!(terminal["jsonrpc"], "2.0");
|
||||
assert_eq!(terminal["id"], 51);
|
||||
assert_eq!(
|
||||
status.as_u16(),
|
||||
if terminal["error"]["code"] == -32601 {
|
||||
404
|
||||
} else {
|
||||
200
|
||||
}
|
||||
);
|
||||
if !frames.is_empty() {
|
||||
assert!(sse, "notifications require SSE");
|
||||
}
|
||||
assert!(frames.iter().all(|f| f.get("id").is_none()));
|
||||
(terminal, frames, raw)
|
||||
}
|
||||
fn opted(level: Value) -> Value {
|
||||
let mut meta = modern_meta();
|
||||
meta[LEVEL] = level;
|
||||
json!({"_meta":meta})
|
||||
}
|
||||
async fn control(revision: &str) -> [usize; 3] {
|
||||
let h = Endpoint::started().await;
|
||||
let session = h.session(revision).await;
|
||||
let session = session.as_deref();
|
||||
// Negative opt-in controls precede any accepted level; a silent response is not enough alone.
|
||||
let (body, events, _) = reply(h.post(revision, session, "tools/list", json!({})).await).await;
|
||||
assert!(body["result"]["tools"].is_array());
|
||||
assert!(events.is_empty());
|
||||
assert_eq!(counts(&h.counters), [0; 3]);
|
||||
if revision == MODERN_REVISION {
|
||||
for value in [
|
||||
json!("verbose"),
|
||||
json!(7),
|
||||
json!(null),
|
||||
json!("CANARY".repeat(1000)),
|
||||
] {
|
||||
let (body, events, _) =
|
||||
reply(h.post(revision, session, "tools/list", opted(value)).await).await;
|
||||
assert!(body["result"]["tools"].is_array());
|
||||
assert!(events.is_empty());
|
||||
assert_eq!(counts(&h.counters), [0; 3]);
|
||||
}
|
||||
let (body, events, _) = reply(
|
||||
h.post(
|
||||
revision,
|
||||
session,
|
||||
"logging/setLevel",
|
||||
json!({"level":"notice"}),
|
||||
)
|
||||
.await,
|
||||
)
|
||||
.await;
|
||||
assert_eq!(body["error"]["code"], -32601);
|
||||
assert!(events.is_empty());
|
||||
assert_eq!(counts(&h.counters), [0; 3]);
|
||||
} else {
|
||||
for params in [
|
||||
json!({}),
|
||||
json!({"level":7}),
|
||||
json!({"level":"CANARY".repeat(1000)}),
|
||||
] {
|
||||
let (body, events, raw) =
|
||||
reply(h.post(revision, session, "logging/setLevel", params).await).await;
|
||||
assert_eq!(body["error"]["code"], -32602);
|
||||
assert_eq!(body["error"]["message"], "invalid logging level");
|
||||
assert!(body.get("result").is_none());
|
||||
assert!(!raw.contains("CANARY"));
|
||||
assert!(raw.len() < 4096);
|
||||
assert!(events.is_empty());
|
||||
assert_eq!(h.counters.sdk_logging_level(), 0);
|
||||
assert_eq!(h.counters.sdk_logging_notification(), 0);
|
||||
}
|
||||
}
|
||||
let before = counts(&h.counters);
|
||||
let (method, params, expected) = if revision == LEGACY_REVISION {
|
||||
(
|
||||
"logging/setLevel",
|
||||
json!({"level":"notice"}),
|
||||
notification("notice", "mcp.logging.level_applied", "applied"),
|
||||
)
|
||||
} else {
|
||||
(
|
||||
"tools/list",
|
||||
opted(json!("info")),
|
||||
notification("info", "mcp.request.served", "ok"),
|
||||
)
|
||||
};
|
||||
let (body, events, raw) = reply(h.post(revision, session, method, params).await).await;
|
||||
assert!(body.get("error").is_none(), "{body}");
|
||||
if revision == LEGACY_REVISION {
|
||||
assert_eq!(body["result"], json!({}));
|
||||
} else {
|
||||
assert!(body["result"]["tools"].is_array());
|
||||
}
|
||||
assert_eq!(events, vec![expected]);
|
||||
assert!(raw.len() < 4096);
|
||||
let after = counts(&h.counters);
|
||||
let delta = std::array::from_fn(|i| after[i] - before[i]);
|
||||
// Legacy severity persists, modern opt-in does not leak into the next request.
|
||||
let (body, events, _) = reply(h.post(revision, session, "tools/list", json!({})).await).await;
|
||||
assert!(body["result"]["tools"].is_array());
|
||||
assert!(events.is_empty());
|
||||
h.registry
|
||||
.revoke_platform_api_key(
|
||||
&workspace_id(),
|
||||
&crank_core::PlatformApiKeyId::new("pk_dispatch_observer"),
|
||||
&time::OffsetDateTime::now_utc(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let before = counts(&h.counters);
|
||||
let era = h.counters.snapshot();
|
||||
let response = h
|
||||
.post(
|
||||
revision,
|
||||
session,
|
||||
method,
|
||||
if revision == LEGACY_REVISION {
|
||||
json!({"level":"notice"})
|
||||
} else {
|
||||
opted(json!("info"))
|
||||
},
|
||||
)
|
||||
.await;
|
||||
assert_eq!(response.status(), 401);
|
||||
let raw = response.text().await.unwrap();
|
||||
assert!(!raw.contains("notifications/message"));
|
||||
assert_eq!(counts(&h.counters), before);
|
||||
let after = h.counters.snapshot();
|
||||
assert_eq!(after.era_modern, era.era_modern);
|
||||
assert_eq!(after.era_legacy, era.era_legacy);
|
||||
eprintln!(
|
||||
"existing GREEN logging HTTP {revision}: safe SSE, result, opt-in/invalid/era/auth controls passed; SDK positive delta={delta:?}"
|
||||
);
|
||||
delta
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_logging_wire_legacy() {
|
||||
control(LEGACY_REVISION).await;
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_logging_wire_modern() {
|
||||
control(MODERN_REVISION).await;
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_logging_sdk_legacy() {
|
||||
assert_eq!(
|
||||
control(LEGACY_REVISION).await,
|
||||
[1, 1, 1],
|
||||
"missing SDK legacy request/level/notification after successful HTTP wire assertions"
|
||||
);
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_logging_sdk_modern() {
|
||||
assert_eq!(
|
||||
control(MODERN_REVISION).await,
|
||||
[0, 1, 1],
|
||||
"missing SDK modern level/notification after successful HTTP wire assertions"
|
||||
);
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_logging_observer_scope_control() {
|
||||
use super::{
|
||||
sdk_logging_dispatch_enter, sdk_logging_level_parsed, sdk_logging_notification_serialized,
|
||||
};
|
||||
let a = Arc::new(CounterSet::default());
|
||||
let b = Arc::new(CounterSet::default());
|
||||
sdk_logging_dispatch_enter();
|
||||
sdk_logging_level_parsed();
|
||||
sdk_logging_notification_serialized();
|
||||
assert_eq!(counts(&a), [0; 3]);
|
||||
tokio::join!(
|
||||
observe(a.clone(), async {
|
||||
sdk_logging_dispatch_enter();
|
||||
tokio::task::yield_now().await;
|
||||
sdk_logging_level_parsed();
|
||||
}),
|
||||
observe(b.clone(), async {
|
||||
sdk_logging_notification_serialized();
|
||||
})
|
||||
);
|
||||
assert_eq!(counts(&a), [1, 1, 0]);
|
||||
assert_eq!(counts(&b), [0, 0, 1]);
|
||||
let body = Body::from_stream(stream::once(async {
|
||||
sdk_logging_notification_serialized();
|
||||
Ok::<_, std::convert::Infallible>("data: terminal\n\n")
|
||||
}));
|
||||
let response = observe_body(Response::new(body), a.clone());
|
||||
assert_eq!(counts(&a), [1, 1, 0]);
|
||||
assert_eq!(
|
||||
&axum::body::to_bytes(response.into_body(), 100)
|
||||
.await
|
||||
.unwrap()[..],
|
||||
b"data: terminal\n\n"
|
||||
);
|
||||
assert_eq!(counts(&a), [1, 1, 1]);
|
||||
assert_eq!(counts(&b), [0, 0, 1]);
|
||||
}
|
||||
@@ -0,0 +1,143 @@
|
||||
//! Minimal logging HTTP fixture; shared registry/auth/lifecycle fixtures remain authoritative.
|
||||
use super::*;
|
||||
use crank_runtime::{
|
||||
InMemoryCoordinationStateStore, RequestRateLimitConfig, RequestRateLimiter, SecretCrypto,
|
||||
};
|
||||
|
||||
pub(super) struct Endpoint {
|
||||
pub registry: crank_registry::PostgresRegistry,
|
||||
pub counters: Arc<CounterSet>,
|
||||
key: String,
|
||||
url: String,
|
||||
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("logging_owner", "t_c28c3800").await;
|
||||
let registry = test_registry().await;
|
||||
let operation = test_operation("http://127.0.0.1:9");
|
||||
registry
|
||||
.create_operation(&workspace_id(), &operation, Some("alice"))
|
||||
.await
|
||||
.unwrap();
|
||||
registry
|
||||
.publish_operation(crank_registry::PublishRequest {
|
||||
workspace_id: &workspace_id(),
|
||||
operation_id: &operation.id,
|
||||
version: 1,
|
||||
published_at: &test_time(),
|
||||
published_by: Some("alice"),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
publish_agent(®istry, &operation).await;
|
||||
let key = create_api_key(®istry).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 scope = counters.clone();
|
||||
let app = app.layer(axum::middleware::from_fn(
|
||||
move |request: axum::extract::Request, next: axum::middleware::Next| {
|
||||
let counters = scope.clone();
|
||||
async move {
|
||||
let response = observe(counters.clone(), 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,
|
||||
}
|
||||
}
|
||||
pub async fn post(
|
||||
&self,
|
||||
revision: &str,
|
||||
session: Option<&str>,
|
||||
method: &str,
|
||||
mut params: Value,
|
||||
) -> reqwest::Response {
|
||||
let mut request = reqwest::Client::new()
|
||||
.post(&self.url)
|
||||
.bearer_auth(&self.key)
|
||||
.header("Accept", "text/event-stream, application/json")
|
||||
.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", method);
|
||||
if params.get("_meta").is_none() {
|
||||
params["_meta"] = modern_meta();
|
||||
}
|
||||
}
|
||||
request
|
||||
.json(&json!({"jsonrpc":"2.0", "id":51, "method":method, "params":params}))
|
||||
.send()
|
||||
.await
|
||||
.unwrap()
|
||||
}
|
||||
pub async fn session(&self, revision: &str) -> Option<String> {
|
||||
if revision == MODERN_REVISION {
|
||||
return None;
|
||||
}
|
||||
let response = self
|
||||
.post(
|
||||
revision,
|
||||
None,
|
||||
"initialize",
|
||||
json!({"protocolVersion":revision,"capabilities":{}}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(response.status(), 200);
|
||||
let session = response.headers()["MCP-Session-Id"]
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.to_owned();
|
||||
assert_eq!(
|
||||
reply(response).await.0["result"]["protocolVersion"],
|
||||
revision
|
||||
);
|
||||
let response = reqwest::Client::new()
|
||||
.post(&self.url)
|
||||
.bearer_auth(&self.key)
|
||||
.header("Accept", "application/json, text/event-stream")
|
||||
.header("MCP-Protocol-Version", revision)
|
||||
.header("MCP-Session-Id", &session)
|
||||
.json(&initialized_notification())
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 202);
|
||||
response.bytes().await.unwrap();
|
||||
Some(session)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,290 @@
|
||||
//! Narrow #107 HTTP fixture; registry/catalog/auth data reuse the dispatch observer support.
|
||||
use super::*;
|
||||
use crank_runtime::{
|
||||
InMemoryCoordinationStateStore, RequestRateLimitConfig, RequestRateLimiter, SecretCrypto,
|
||||
};
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use tokio::sync::Semaphore;
|
||||
|
||||
pub(super) struct Endpoint {
|
||||
pub registry: crank_registry::PostgresRegistry,
|
||||
pub counters: Arc<CounterSet>,
|
||||
pub key: String,
|
||||
pub other_key: String,
|
||||
pub gate: Arc<Semaphore>,
|
||||
pub started: Arc<AtomicUsize>,
|
||||
url: String,
|
||||
servers: Vec<tokio::task::JoinHandle<()>>,
|
||||
}
|
||||
impl Drop for Endpoint {
|
||||
fn drop(&mut self) {
|
||||
for server in &self.servers {
|
||||
server.abort();
|
||||
}
|
||||
}
|
||||
}
|
||||
impl Endpoint {
|
||||
pub async fn started() -> Self {
|
||||
crank_test_support::postgres_schema_url_for_task("progress_owner", "t_d65dd129").await;
|
||||
let registry = test_registry().await;
|
||||
let gate = Arc::new(Semaphore::new(0));
|
||||
let started = Arc::new(AtomicUsize::new(0));
|
||||
let (g, s) = (gate.clone(), started.clone());
|
||||
let upstream = axum::Router::new().route(
|
||||
"/crm/leads",
|
||||
axum::routing::post(move || {
|
||||
let (g, s) = (g.clone(), s.clone());
|
||||
async move {
|
||||
s.fetch_add(1, Ordering::SeqCst);
|
||||
g.acquire().await.unwrap().forget();
|
||||
axum::Json(json!({"id":"lead_progress"}))
|
||||
}
|
||||
}),
|
||||
);
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let base = format!("http://{}", listener.local_addr().unwrap());
|
||||
let upstream_server = tokio::spawn(async move {
|
||||
axum::serve(listener, upstream).await.unwrap();
|
||||
});
|
||||
let mut operation = test_operation(&base);
|
||||
operation.execution_config.timeout_ms = 30_000;
|
||||
registry
|
||||
.create_operation(&workspace_id(), &operation, Some("alice"))
|
||||
.await
|
||||
.unwrap();
|
||||
registry
|
||||
.publish_operation(crank_registry::PublishRequest {
|
||||
workspace_id: &workspace_id(),
|
||||
operation_id: &operation.id,
|
||||
version: 1,
|
||||
published_at: &test_time(),
|
||||
published_by: Some("alice"),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
publish_agent(®istry, &operation).await;
|
||||
let key = create_api_key(®istry).await;
|
||||
let other_key = format!("crk_test_{}", uuid::Uuid::now_v7().simple());
|
||||
let other = crank_core::PlatformApiKey {
|
||||
id: crank_core::PlatformApiKeyId::new("pk_progress_other"),
|
||||
workspace_id: workspace_id(),
|
||||
agent_id: Some(agent_id()),
|
||||
key_kind: crank_core::PlatformApiKeyKind::McpClient,
|
||||
name: "progress-other".into(),
|
||||
prefix: other_key.chars().take(16).collect(),
|
||||
scopes: vec![
|
||||
crank_core::PlatformApiKeyScope::Read,
|
||||
crank_core::PlatformApiKeyScope::Write,
|
||||
],
|
||||
status: crank_core::PlatformApiKeyStatus::Active,
|
||||
created_at: test_time(),
|
||||
last_used_at: None,
|
||||
expires_at: None,
|
||||
allowed_origins: vec![],
|
||||
};
|
||||
registry
|
||||
.create_platform_api_key(crank_registry::CreatePlatformApiKeyRequest {
|
||||
api_key: &other,
|
||||
secret_hash: &hash_access_secret(&other_key),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
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 scope = counters.clone();
|
||||
let app = app.layer(axum::middleware::from_fn(
|
||||
move |request: axum::extract::Request, next: axum::middleware::Next| {
|
||||
let c = scope.clone();
|
||||
async move {
|
||||
let response = observe(c.clone(), next.run(request)).await;
|
||||
observe_body(response, c)
|
||||
}
|
||||
},
|
||||
));
|
||||
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,
|
||||
other_key,
|
||||
gate,
|
||||
started,
|
||||
url,
|
||||
servers: vec![server, upstream_server],
|
||||
}
|
||||
}
|
||||
pub fn request(
|
||||
&self,
|
||||
revision: &str,
|
||||
session: Option<&str>,
|
||||
key: &str,
|
||||
accept: &str,
|
||||
payload: Value,
|
||||
) -> reqwest::RequestBuilder {
|
||||
let mut request = reqwest::Client::new()
|
||||
.post(&self.url)
|
||||
.bearer_auth(key)
|
||||
.header("Accept", accept)
|
||||
.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", payload["method"].as_str().unwrap())
|
||||
.header("Mcp-Name", TOOL_NAME);
|
||||
}
|
||||
request.json(&payload)
|
||||
}
|
||||
pub fn call(
|
||||
&self,
|
||||
revision: &str,
|
||||
session: Option<&str>,
|
||||
id: Value,
|
||||
token: Option<Value>,
|
||||
accept: &str,
|
||||
) -> reqwest::RequestBuilder {
|
||||
let mut meta = if revision == MODERN_REVISION {
|
||||
modern_meta()
|
||||
} else {
|
||||
json!({})
|
||||
};
|
||||
if let Some(token) = token {
|
||||
meta["progressToken"] = token;
|
||||
}
|
||||
self.request(
|
||||
revision,
|
||||
session,
|
||||
&self.key,
|
||||
accept,
|
||||
json!({"jsonrpc":"2.0","id":id,"method":"tools/call",
|
||||
"params":{"name":TOOL_NAME,"arguments":{"email":"progress@example.com"},"_meta":meta}}),
|
||||
)
|
||||
}
|
||||
pub async fn session(&self, revision: &str) -> Option<String> {
|
||||
if revision == MODERN_REVISION {
|
||||
return None;
|
||||
}
|
||||
let response = self
|
||||
.request(
|
||||
revision,
|
||||
None,
|
||||
&self.key,
|
||||
"application/json",
|
||||
legacy_initialize(1),
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
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
|
||||
);
|
||||
let response = self
|
||||
.request(
|
||||
revision,
|
||||
Some(&session),
|
||||
&self.key,
|
||||
"application/json",
|
||||
initialized_notification(),
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 202);
|
||||
assert!(response.bytes().await.unwrap().is_empty());
|
||||
Some(session)
|
||||
}
|
||||
pub async fn cancel(&self, key: &str, session: &str, params: Value) {
|
||||
let shape = match params.get("requestId") {
|
||||
None => "missing",
|
||||
Some(Value::Null) => "null",
|
||||
Some(Value::Bool(_)) => "bool",
|
||||
Some(Value::Array(_)) => "array",
|
||||
Some(Value::Object(_)) => "object",
|
||||
Some(Value::Number(_)) => "number",
|
||||
Some(Value::String(_)) => "string",
|
||||
};
|
||||
let response = self
|
||||
.request(
|
||||
LEGACY_REVISION,
|
||||
Some(session),
|
||||
key,
|
||||
"application/json",
|
||||
json!({"jsonrpc":"2.0","method":"notifications/cancelled","params":params}),
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
let status = response.status();
|
||||
let body = response.bytes().await.unwrap();
|
||||
if status != 202 {
|
||||
let error: Value = serde_json::from_slice(&body).unwrap_or(Value::Null);
|
||||
panic!(
|
||||
"cancel target shape={shape}, HTTP {status}, code={}, message={}, details={}",
|
||||
error["error"]["code"],
|
||||
error["error"]["message"],
|
||||
error["error"]["data"]["details"]
|
||||
);
|
||||
}
|
||||
assert!(body.is_empty(), "ack must disclose nothing");
|
||||
}
|
||||
pub async fn wait_started(&self, count: usize) {
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while self.started.load(Ordering::SeqCst) < count {
|
||||
tokio::time::sleep(Duration::from_millis(5)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.expect("actual outbound dispatch before cancellation");
|
||||
}
|
||||
pub async fn history(&self, request: &str) -> Vec<crank_core::InvocationLog> {
|
||||
self.registry
|
||||
.list_invocation_logs(crank_registry::ListInvocationLogsQuery {
|
||||
workspace_id: &workspace_id(),
|
||||
level: None,
|
||||
status: None,
|
||||
outcome_group: None,
|
||||
search_text: None,
|
||||
source: Some(crank_core::InvocationSource::AgentToolCall),
|
||||
operation_id: Some(&crank_core::OperationId::new(format!("op_{TOOL_NAME}"))),
|
||||
agent_id: None,
|
||||
created_after: None,
|
||||
created_before: None,
|
||||
cursor_created_at: None,
|
||||
cursor_id: None,
|
||||
limit: 50,
|
||||
})
|
||||
.await
|
||||
.unwrap()
|
||||
.into_iter()
|
||||
.map(|row| row.log)
|
||||
.filter(|log| log.request_id.as_deref() == Some(request))
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,457 @@
|
||||
//! #107: real HTTP wire controls first; SDK participation is an independent migration 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_progress_cancel_http_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, c)| async move {
|
||||
observe(c.clone(), body.next())
|
||||
.await
|
||||
.map(|chunk| (chunk, (body, c)))
|
||||
},
|
||||
);
|
||||
Response::from_parts(parts, Body::from_stream(body))
|
||||
}
|
||||
async fn frames(response: reqwest::Response) -> Vec<Value> {
|
||||
assert_eq!(response.status(), 200);
|
||||
let sse = response.headers()["content-type"]
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.starts_with("text/event-stream");
|
||||
let raw = tokio::time::timeout(Duration::from_secs(5), response.text())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
if sse {
|
||||
raw.lines()
|
||||
.filter_map(|line| {
|
||||
line.strip_prefix("data:")
|
||||
.map(|data| serde_json::from_str(data.trim()).unwrap())
|
||||
})
|
||||
.collect()
|
||||
} else if raw.is_empty() {
|
||||
vec![]
|
||||
} else {
|
||||
vec![serde_json::from_str(&raw).unwrap()]
|
||||
}
|
||||
}
|
||||
fn terminal(frames: &[Value], revision: &str, id: Value) -> Value {
|
||||
let last = frames.last().expect("terminal result");
|
||||
assert_eq!(last["jsonrpc"], "2.0");
|
||||
assert_eq!(last["id"], id);
|
||||
assert!(last.get("method").is_none());
|
||||
assert!(last.get("error").is_none());
|
||||
assert_eq!(last["result"]["isError"], false);
|
||||
assert_eq!(
|
||||
last["result"]["structuredContent"],
|
||||
json!({"id":"lead_progress"})
|
||||
);
|
||||
if revision == MODERN_REVISION {
|
||||
assert_eq!(last["result"]["resultType"], "complete");
|
||||
}
|
||||
last["result"].clone()
|
||||
}
|
||||
async fn progress_control(revision: &str) -> usize {
|
||||
let h = Endpoint::started().await;
|
||||
let session = h.session(revision).await;
|
||||
// Establish the unchanged successful execution independently of any notification/marker.
|
||||
h.gate.add_permits(1);
|
||||
let plain = frames(
|
||||
h.call(
|
||||
revision,
|
||||
session.as_deref(),
|
||||
json!(51),
|
||||
None,
|
||||
"application/json",
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap(),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(plain.len(), 1);
|
||||
let expected = terminal(&plain, revision, json!(51));
|
||||
assert_eq!(h.counters.sdk_progress_notification(), 0);
|
||||
let mut sdk_positive = usize::MAX;
|
||||
for token in [
|
||||
json!("opaque-token"),
|
||||
json!(-7),
|
||||
json!(1.5),
|
||||
json!(1.0),
|
||||
json!(-0.0),
|
||||
json!(u64::MAX),
|
||||
] {
|
||||
let before = h.counters.sdk_progress_notification();
|
||||
h.gate.add_permits(1);
|
||||
let reply = h
|
||||
.call(
|
||||
revision,
|
||||
session.as_deref(),
|
||||
json!(51),
|
||||
Some(token.clone()),
|
||||
"application/json, text/event-stream",
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(
|
||||
reply.headers()["content-type"]
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.starts_with("text/event-stream")
|
||||
);
|
||||
let reply = frames(reply).await;
|
||||
assert_eq!(reply.len(), 4, "three bounded real steps and one terminal");
|
||||
for (index, message) in [
|
||||
"tool_resolved",
|
||||
"authorization_resolved",
|
||||
"execution_dispatched",
|
||||
]
|
||||
.iter()
|
||||
.enumerate()
|
||||
{
|
||||
let expected_frame = json!({"jsonrpc":"2.0","method":"notifications/progress","params":{
|
||||
"progressToken":token,"progress":index+1,"message":message}});
|
||||
// Stringify too: float-form tokens must not silently become integers/strings.
|
||||
assert_eq!(reply[index].to_string(), expected_frame.to_string());
|
||||
assert!(reply[index]["params"]["progress"].as_u64().is_some());
|
||||
}
|
||||
assert_eq!(terminal(&reply, revision, json!(51)), expected);
|
||||
sdk_positive = sdk_positive.min(h.counters.sdk_progress_notification() - before);
|
||||
}
|
||||
for token in [
|
||||
None,
|
||||
Some(json!(null)),
|
||||
Some(json!(true)),
|
||||
Some(json!({})),
|
||||
Some(json!([])),
|
||||
Some(json!("")),
|
||||
Some(json!("bad\ntoken")),
|
||||
Some(json!("x".repeat(129))),
|
||||
] {
|
||||
h.gate.add_permits(1);
|
||||
let before = h.counters.sdk_progress_notification();
|
||||
let reply = frames(
|
||||
h.call(
|
||||
revision,
|
||||
session.as_deref(),
|
||||
json!(51),
|
||||
token,
|
||||
"text/event-stream",
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap(),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(reply.len(), 1, "invalid/absent token is silent");
|
||||
assert_eq!(terminal(&reply, revision, json!(51)), expected);
|
||||
assert_eq!(h.counters.sdk_progress_notification(), before);
|
||||
}
|
||||
h.gate.add_permits(1);
|
||||
let before = h.counters.sdk_progress_notification();
|
||||
let reply = frames(
|
||||
h.call(
|
||||
revision,
|
||||
session.as_deref(),
|
||||
json!(51),
|
||||
Some(json!(u64::MAX)),
|
||||
"application/json",
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap(),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(reply.len(), 1, "no SSE means no progress");
|
||||
assert_eq!(terminal(&reply, revision, json!(51)), expected);
|
||||
assert_eq!(h.counters.sdk_progress_notification(), before);
|
||||
eprintln!(
|
||||
"existing GREEN progress HTTP {revision}: exact token forms, bounded integer steps, unchanged result and silent negatives; minimum per-token SDK delta={sdk_positive}"
|
||||
);
|
||||
sdk_positive
|
||||
}
|
||||
async fn cancel_control(with_meta: bool) -> usize {
|
||||
let h = Endpoint::started().await;
|
||||
let session = h.session(LEGACY_REVISION).await.unwrap();
|
||||
let foreign = h.session(LEGACY_REVISION).await.unwrap();
|
||||
let request = h
|
||||
.call(
|
||||
LEGACY_REVISION,
|
||||
Some(&session),
|
||||
json!(u64::MAX),
|
||||
Some(json!("cancel-token")),
|
||||
"text/event-stream",
|
||||
)
|
||||
.header("x-request-id", "progress-cancel-owner");
|
||||
let mut call = tokio::spawn(async move { frames(request.send().await.unwrap()).await });
|
||||
h.wait_started(1).await;
|
||||
// All no-ops target this active call while its upstream response is held, not a completed call.
|
||||
for params in [
|
||||
json!({"requestId":u64::MAX.to_string()}),
|
||||
json!({"requestId":999}),
|
||||
json!({}),
|
||||
json!({"requestId":null}),
|
||||
json!({"requestId":true}),
|
||||
json!({"requestId":[]}),
|
||||
json!({"requestId":{}}),
|
||||
] {
|
||||
h.cancel(&h.key, &session, params).await;
|
||||
}
|
||||
eprintln!("cancel diagnostic: malformed/unknown/lookalike controls passed");
|
||||
h.cancel(&h.other_key, &session, json!({"requestId":u64::MAX}))
|
||||
.await;
|
||||
h.cancel(&h.key, &foreign, json!({"requestId":u64::MAX}))
|
||||
.await;
|
||||
eprintln!("cancel diagnostic: foreign ownership controls passed");
|
||||
assert!(
|
||||
tokio::time::timeout(Duration::from_millis(100), &mut call)
|
||||
.await
|
||||
.is_err(),
|
||||
"no-op targets must leave the owned call running"
|
||||
);
|
||||
// Now let exactly that call finish: this proves no-op, rather than just delayed cancellation.
|
||||
h.gate.add_permits(1);
|
||||
let reply = call.await.unwrap();
|
||||
terminal(&reply, LEGACY_REVISION, json!(u64::MAX));
|
||||
let history = h.history("progress-cancel-owner").await;
|
||||
assert_eq!(history.len(), 1);
|
||||
assert_eq!(history[0].status, crank_core::InvocationStatus::Ok);
|
||||
h.cancel(&h.key, &session, json!({"requestId":u64::MAX}))
|
||||
.await;
|
||||
assert_eq!(
|
||||
h.history("progress-cancel-owner").await.len(),
|
||||
1,
|
||||
"late cancel adds no outcome"
|
||||
);
|
||||
|
||||
let request = h
|
||||
.call(
|
||||
LEGACY_REVISION,
|
||||
Some(&session),
|
||||
json!(u64::MAX),
|
||||
Some(json!("cancel-token")),
|
||||
"text/event-stream",
|
||||
)
|
||||
.header("x-request-id", "progress-cancel-stop");
|
||||
let call = tokio::spawn(async move { frames(request.send().await.unwrap()).await });
|
||||
h.wait_started(2).await;
|
||||
let before = h.counters.sdk_cancelled_params();
|
||||
let mut params = json!({"requestId":u64::MAX,"reason":42,"unknown":{"nested":true}});
|
||||
if with_meta {
|
||||
params["_meta"] = json!({});
|
||||
}
|
||||
h.cancel(&h.key, &session, params).await;
|
||||
let delta = h.counters.sdk_cancelled_params() - before;
|
||||
let reply = tokio::time::timeout(Duration::from_secs(1), call)
|
||||
.await
|
||||
.expect("cancel releases call while upstream is still held")
|
||||
.unwrap();
|
||||
assert_eq!(reply.len(), 3);
|
||||
assert!(
|
||||
reply
|
||||
.iter()
|
||||
.all(|f| f["method"] == "notifications/progress"),
|
||||
"no false terminal result"
|
||||
);
|
||||
assert!(h.history("progress-cancel-stop").await.is_empty());
|
||||
// Releasing an abandoned upstream cannot turn the cancelled execution into completed history.
|
||||
h.gate.add_permits(2);
|
||||
let reply = frames(
|
||||
h.call(
|
||||
LEGACY_REVISION,
|
||||
Some(&session),
|
||||
json!(u64::MAX),
|
||||
None,
|
||||
"application/json",
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap(),
|
||||
)
|
||||
.await;
|
||||
terminal(&reply, LEGACY_REVISION, json!(u64::MAX));
|
||||
assert!(h.history("progress-cancel-stop").await.is_empty());
|
||||
assert_eq!(
|
||||
h.started.load(std::sync::atomic::Ordering::SeqCst),
|
||||
3,
|
||||
"no automatic write retry"
|
||||
);
|
||||
eprintln!(
|
||||
"existing GREEN cancel HTTP legacy: active no-ops, numeric owner stop with ignored fields, released/reused id and no false history; SDK delta={delta}"
|
||||
);
|
||||
delta
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_progress_cancel_wire_legacy() {
|
||||
progress_control(LEGACY_REVISION).await;
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_progress_cancel_wire_modern() {
|
||||
progress_control(MODERN_REVISION).await;
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_progress_cancel_wire_cancellation() {
|
||||
cancel_control(false).await;
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_progress_cancel_sdk_legacy() {
|
||||
assert!(
|
||||
progress_control(LEGACY_REVISION).await > 0,
|
||||
"missing SDK progress serialization after successful HTTP controls"
|
||||
);
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_progress_cancel_sdk_modern() {
|
||||
assert!(
|
||||
progress_control(MODERN_REVISION).await > 0,
|
||||
"missing SDK progress serialization after successful HTTP controls"
|
||||
);
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_progress_cancel_sdk_cancellation() {
|
||||
assert!(
|
||||
cancel_control(false).await > 0,
|
||||
"missing SDK cancelled params decode after successful HTTP stop controls"
|
||||
);
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_progress_cancel_wire_modern_stream_close() {
|
||||
let h = Endpoint::started().await;
|
||||
let response = h
|
||||
.call(
|
||||
MODERN_REVISION,
|
||||
None,
|
||||
json!(52),
|
||||
Some(json!("disconnect")),
|
||||
"text/event-stream",
|
||||
)
|
||||
.header("x-request-id", "progress-modern-stop")
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 200);
|
||||
h.wait_started(1).await;
|
||||
drop(response);
|
||||
tokio::time::sleep(Duration::from_millis(250)).await;
|
||||
// Match the existing lifecycle grace; an un-stopped future would complete after gate release.
|
||||
h.gate.add_permits(2);
|
||||
tokio::time::sleep(Duration::from_millis(2500)).await;
|
||||
assert!(
|
||||
h.history("progress-modern-stop").await.is_empty(),
|
||||
"closed stream must not reach completed history"
|
||||
);
|
||||
let reply = frames(
|
||||
h.call(MODERN_REVISION, None, json!(52), None, "application/json")
|
||||
.send()
|
||||
.await
|
||||
.unwrap(),
|
||||
)
|
||||
.await;
|
||||
terminal(&reply, MODERN_REVISION, json!(52));
|
||||
assert_eq!(
|
||||
h.started.load(std::sync::atomic::Ordering::SeqCst),
|
||||
2,
|
||||
"no retry after disconnect"
|
||||
);
|
||||
assert!(h.history("progress-modern-stop").await.is_empty());
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_progress_cancel_admitted_meta_cancellation() {
|
||||
assert!(cancel_control(true).await > 0);
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_progress_cancel_malformed_meta_rejected_before_decode() {
|
||||
let h = Endpoint::started().await;
|
||||
let session = h.session(LEGACY_REVISION).await.unwrap();
|
||||
let request = h
|
||||
.call(
|
||||
LEGACY_REVISION,
|
||||
Some(&session),
|
||||
json!(u64::MAX),
|
||||
Some(json!("meta-boundary")),
|
||||
"text/event-stream",
|
||||
)
|
||||
.header("x-request-id", "progress-meta-rejected");
|
||||
let mut call = tokio::spawn(async move { frames(request.send().await.unwrap()).await });
|
||||
h.wait_started(1).await;
|
||||
let before = h.counters.sdk_cancelled_params();
|
||||
let response = h
|
||||
.request(
|
||||
LEGACY_REVISION,
|
||||
Some(&session),
|
||||
&h.key,
|
||||
"application/json",
|
||||
json!({"jsonrpc":"2.0","method":"notifications/cancelled","params":{
|
||||
"requestId":u64::MAX,"reason":42,"_meta":[],"unknown":{"nested":true}}}),
|
||||
)
|
||||
.send()
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), 400);
|
||||
let error = json_body(response).await;
|
||||
assert_eq!(error["error"]["code"], -32020);
|
||||
assert_eq!(error["error"]["message"], "protocol identity mismatch");
|
||||
assert_eq!(
|
||||
error["error"]["data"]["details"],
|
||||
"request _meta must be an object"
|
||||
);
|
||||
assert_eq!(h.counters.sdk_cancelled_params(), before);
|
||||
assert!(
|
||||
tokio::time::timeout(Duration::from_millis(100), &mut call)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
h.gate.add_permits(1);
|
||||
let reply = call.await.unwrap();
|
||||
terminal(&reply, LEGACY_REVISION, json!(u64::MAX));
|
||||
let history = h.history("progress-meta-rejected").await;
|
||||
assert_eq!(history.len(), 1);
|
||||
assert_eq!(history[0].status, crank_core::InvocationStatus::Ok);
|
||||
assert_eq!(h.started.load(std::sync::atomic::Ordering::SeqCst), 1);
|
||||
assert_eq!(h.counters.sdk_cancelled_params(), before);
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn rmcp_progress_cancel_observer_scope_control() {
|
||||
use super::{sdk_cancelled_params_decoded, sdk_progress_notification_serialized};
|
||||
let a = Arc::new(CounterSet::default());
|
||||
let b = Arc::new(CounterSet::default());
|
||||
sdk_cancelled_params_decoded();
|
||||
sdk_progress_notification_serialized();
|
||||
assert_eq!(a.sdk_cancelled_params(), 0);
|
||||
tokio::join!(
|
||||
observe(a.clone(), async {
|
||||
sdk_cancelled_params_decoded();
|
||||
}),
|
||||
observe(b.clone(), async {
|
||||
sdk_progress_notification_serialized();
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
[a.sdk_cancelled_params(), a.sdk_progress_notification()],
|
||||
[1, 0]
|
||||
);
|
||||
assert_eq!(
|
||||
[b.sdk_cancelled_params(), b.sdk_progress_notification()],
|
||||
[0, 1]
|
||||
);
|
||||
let body = Body::from_stream(stream::once(async {
|
||||
sdk_progress_notification_serialized();
|
||||
Ok::<_, std::convert::Infallible>("data: terminal\n\n")
|
||||
}));
|
||||
let response = observe_body(Response::new(body), a.clone());
|
||||
assert_eq!(a.sdk_progress_notification(), 0);
|
||||
axum::body::to_bytes(response.into_body(), 100)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(a.sdk_progress_notification(), 1);
|
||||
assert_eq!(b.sdk_progress_notification(), 1);
|
||||
}
|
||||
@@ -39,6 +39,10 @@ Prompts-срез #107 подключает `prompts/list` и `prompts/get` об
|
||||
|
||||
Completion-срез #107 на базе rc.20/rmcp3.9.0 подключает `completion/complete` обеих revisions к тому же request-scoped `app/rmcp_dispatch.rs`: настоящие `CompleteRequestParams`/`Reference`/`ArgumentInfo` передают reference и argument прежнему shared service. SDK context представляет только строки, поэтому исходный Crank JSON context сохраняется отдельно без фильтрации/приведения типов и проходит прежнюю domain validation. `app/response.rs` заменяет handwritten completion builder сериализацией `CompleteResult`/`CompletionInfo`, сохраняя omission `hasMore=false`, точный bounded total либо его отсутствие при partial scan и прежнюю внешнюю modern/legacy result projection. Потребитель — штатный `build_app` MCP HTTP JSON/SSE. Runtime ATDD отдельно наблюдает SDK request/result seam и сохранение Prompt/Resource refs, pinned/archive, populated/empty/bounded результатов, safe refusals/context, correlation/IDs и revoked-key rejection. Domain/storage/auth/envelopes/transport/lifecycle не меняются; signals/logging/subscriptions ещё не перенесены. Это не завершение #107, не external-client/feature qualification и не production deployment.
|
||||
|
||||
Logging-срез #107 на базе rc.22/rmcp3.9.0 использует существующий общий `protocol/logging.rs`, уже подключённый к штатному `build_app` HTTP: legacy `logging/setLevel` после прежней bounded string boundary декодируется в настоящий `SetLevelRequestParams`, а modern `_meta[io.modelcontextprotocol/logLevel]` — в SDK `LoggingLevel`. Неизвестные legacy поля, включая `_meta`, остаются игнорируемыми; неверные уровни дают прежний безопасный `INVALID_LEVEL`, modern отсутствие/неверное значение не включает logging. Domain severity ordering/store сохраняются явно: SDK enum не задаёт Ord. `notifications/message.params` сериализуется через `LoggingMessageNotificationParam` только из закрытого safe vocabulary; JSON-RPC envelope остаётся прежним. HTTP ATDD наблюдает реальные SDK decode/serialization обеих revisions и revoked-auth rejection; существующая logging-матрица и streamed progress regression сохраняют opt-in/isolation/filtering/JSON silence и carried scope. Очереди, try_lock/drop, transport/session/auth/lifecycle/capabilities не меняются; собственного runtime parsing уровня и handwritten params builder больше нет. Потребитель — действующий MCP HTTP клиент; signals/progress/cancel/subscriptions/прочие notifications и envelopes/transport/lifecycle ещё не объявляются перенесёнными. Полный #107, feature qualification и production deployment этим срезом не завершены.
|
||||
|
||||
Progress/cancel-срез #107 на базе rc.23/rmcp3.9.0 подключает штатный SSE `lifecycle::progress_frame` обеих revisions к сериализации `ProgressNotificationParam`, а legacy `handle_cancelled_notification` — к декодированию `CancelledNotificationParam.request_id`. Локальная projection+restore сохраняет исходные JSON numbers токена/ID и целочисленный u64 progress, включая значения вне i64/exact-f64; message и omissions берутся из SDK. Decoder передаёт SDK только requestId, не валидируя reason/_meta/extensions. Session+credential ownership, bounded queues/slots, transport, auth и modern stream-close cancellation не меняются. Runtime ATDD подтверждает SDK seams отдельно от wire; unit regression проверяет точную числовую форму. Decoder ignore действует только после HTTP admission: `_meta:[]` сохраняет прежний HTTP400/-32020 до SDK decoder. Отдельная HTTP-регрессия проверяет отказ без отмены активного вызова, а допустимый `_meta:{}` с reason/extensions — успешную SDK-отмену. Это частичная миграция params, не завершение #107, feature qualification или production deployment.
|
||||
|
||||
Проверяемый результат:
|
||||
|
||||
- Через SDK проходят действующие Tools, Resources, Prompts, completion, уведомления и подписки в применимых revisions, а также progress/cancel и существующая logging policy.
|
||||
|
||||
Reference in new issue
Block a user