use rmcp::model::ProtocolVersion;
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum ProtocolLifecycle {
InitializeSession,
DiscoverStateless,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum CachePolicy {
Omit,
ImmediatePrivate,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct ProtocolPolicy {
pub(crate) version: ProtocolVersion,
pub(crate) lifecycle: ProtocolLifecycle,
pub(crate) cache: CachePolicy,
pub(crate) resource_subscriptions: bool,
}
const SUPPORTED_PROTOCOLS: [ProtocolPolicy; 2] = [
ProtocolPolicy {
version: ProtocolVersion::V_2026_07_28,
lifecycle: ProtocolLifecycle::DiscoverStateless,
cache: CachePolicy::ImmediatePrivate,
resource_subscriptions: true,
},
ProtocolPolicy {
version: ProtocolVersion::V_2025_11_25,
lifecycle: ProtocolLifecycle::InitializeSession,
cache: CachePolicy::Omit,
resource_subscriptions: false,
},
];
pub(crate) fn policy_for(version: &ProtocolVersion) -> Option<&'static ProtocolPolicy> {
SUPPORTED_PROTOCOLS.iter().find(|p| &p.version == version)
}
pub(crate) fn preferred_policy() -> &'static ProtocolPolicy {
match &SUPPORTED_PROTOCOLS {
[first, ..] => first,
}
}
pub(crate) fn supported_protocol_versions() -> Vec<ProtocolVersion> {
SUPPORTED_PROTOCOLS
.iter()
.map(|p| p.version.clone())
.collect()
}
pub(crate) fn cache_fields_for(protocol_version: Option<ProtocolVersion>) -> bool {
protocol_version
.as_ref()
.and_then(policy_for)
.is_some_and(|p| p.cache == CachePolicy::ImmediatePrivate)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn policy_table_rows_are_exact_supported_versions_in_preferred_order() {
let versions: Vec<ProtocolVersion> = supported_protocol_versions();
assert_eq!(versions.len(), 2, "exactly two supported versions");
assert_eq!(versions[0], ProtocolVersion::V_2026_07_28);
assert_eq!(versions[1], ProtocolVersion::V_2025_11_25);
}
#[test]
fn preferred_policy_is_modern_discovery_with_immediate_private_cache() {
let preferred = preferred_policy();
assert_eq!(preferred.version, ProtocolVersion::V_2026_07_28);
assert_eq!(preferred.lifecycle, ProtocolLifecycle::DiscoverStateless);
assert_eq!(preferred.cache, CachePolicy::ImmediatePrivate);
assert!(
preferred.resource_subscriptions,
"modern row enables subscriptions"
);
}
#[test]
fn legacy_policy_is_initialize_session_with_omitted_cache() {
let legacy = policy_for(&ProtocolVersion::V_2025_11_25).expect("legacy row must exist");
assert_eq!(legacy.version, ProtocolVersion::V_2025_11_25);
assert_eq!(legacy.lifecycle, ProtocolLifecycle::InitializeSession);
assert_eq!(legacy.cache, CachePolicy::Omit);
assert!(
!legacy.resource_subscriptions,
"legacy row disables subscriptions"
);
}
#[test]
fn older_known_unsupported_versions_have_no_policy() {
for version in [
ProtocolVersion::V_2025_06_18,
ProtocolVersion::V_2025_03_26,
ProtocolVersion::V_2024_11_05,
] {
assert!(
policy_for(&version).is_none(),
"{version} must have no policy row"
);
}
}
#[test]
fn custom_future_version_has_no_policy_and_no_cache_fields() {
let future: ProtocolVersion =
serde_json::from_value(serde_json::json!("2099-01-01")).unwrap();
assert!(
policy_for(&future).is_none(),
"future version must have no policy row"
);
assert!(
!cache_fields_for(Some(future)),
"future version must not enable cache fields"
);
}
#[test]
fn cache_fields_follow_exact_policy_rows_only() {
assert!(!cache_fields_for(None));
assert!(cache_fields_for(Some(ProtocolVersion::V_2026_07_28)));
assert!(!cache_fields_for(Some(ProtocolVersion::V_2025_11_25)));
assert!(!cache_fields_for(Some(ProtocolVersion::V_2025_06_18)));
assert!(!cache_fields_for(Some(ProtocolVersion::V_2025_03_26)));
assert!(!cache_fields_for(Some(ProtocolVersion::V_2024_11_05)));
}
}