Struct ToolDigest 

pub struct ToolDigest(/* private fields */);

A stable digest of the discovered tool list (names, descriptions, and input/output schemas) at generation time, recorded so a later comparison can detect that the server’s tool surface changed.

Newtype over a 64-character lowercase-hex String — see ConfigFingerprint’s doc comment for why this is a newtype rather than a bare String, and for the TryFrom<String>/ DigestFormatError validation its Deserialize is routed through.

Examples

use mcp_execution_core::provenance::{ToolDigest, ToolDigestEntry};
use serde_json::json;

let schema = json!({"type": "object"});
let entries = vec![ToolDigestEntry {
    name: "create_issue",
    description: "Creates a new issue",
    input_schema: &schema,
    output_schema: None,
}];

let digest = ToolDigest::compute(&entries);
assert_eq!(digest.as_str().len(), 64);

Implementations

impl ToolDigest

pub fn compute(entries: &[ToolDigestEntry<'_>]) -> Self

Computes an aggregate digest of entries, insensitive to input order (including two tools sharing the same name in swapped order) but sensitive to any schema/name/ description edit, tool addition, or tool removal.

Two-level construction: each entry is hashed on its own (domain tag, framed name, framed description, then input_schema/output_schema via the recursive hash_value_into walk — output_schema’s presence is tagged explicitly, so None and Some(Value::Null) hash differently), the resulting 32-byte digests are sorted, and the sorted sequence is hashed into the final aggregate. Sorting digests rather than tool names gives a total order even for duplicate tool names, which name-sorting alone would leave ambiguous.

Examples

Reordering the input tool list does not change the digest:

use mcp_execution_core::provenance::{ToolDigest, ToolDigestEntry};
use serde_json::json;

let schema_a = json!({"type": "object"});
let schema_b = json!({"type": "string"});
let a = ToolDigestEntry { name: "a", description: "", input_schema: &schema_a, output_schema: None };
let b = ToolDigestEntry { name: "b", description: "", input_schema: &schema_b, output_schema: None };

assert_eq!(
    ToolDigest::compute(&[a, b]),
    ToolDigest::compute(&[b, a]),
);

pub fn as_str(&self) -> &str

Returns the digest as a 64-character lowercase-hex string slice.

Examples

use mcp_execution_core::provenance::{ToolDigest, ToolDigestEntry};

let digest = ToolDigest::compute(&[] as &[ToolDigestEntry<'_>]);
assert!(!digest.as_str().is_empty());

Trait Implementations

impl Clone for ToolDigest

fn clone(&self) -> ToolDigest

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ToolDigest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ToolDigest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ToolDigest

impl PartialEq for ToolDigest

fn eq(&self, other: &ToolDigest) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for ToolDigest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ToolDigest

impl TryFrom<String> for ToolDigest

fn try_from(value: String) -> Result<Self, Self::Error>

Delegates to validate_digest_string — the sole entry point Deserialize uses.

type Error = DigestFormatError

The type returned in the event of a conversion error.