Struct SchemaCache 

pub struct SchemaCache { /* private fields */ }

A thread-safe cache for normalized JSON Schemas.

An adapter-bound cache stores normalized schemas keyed by a 64-bit hash of the input schema. Binding the adapter at construction prevents results produced by different adapter instances from sharing an entry.

Thread Safety

Uses std::sync::Mutex internally, making it safe to share across threads. The lock is held only briefly during hash lookup and insertion.

Placement

Intended to live on model instances so each provider adapter maintains its own cache of normalized schemas. Use SchemaCache::new for the generic adapter or SchemaCache::for_adapter for a provider-specific adapter.

Implementations

impl SchemaCache

pub fn new() -> Self

Creates an empty cache bound to GenericSchemaAdapter.

Use SchemaCache::for_adapter when normalization requires a provider-specific adapter.

Example

use adk_core::SchemaCache;
use serde_json::json;

let cache = SchemaCache::new();
let normalized = cache.normalize(&json!({"type": "string"}));

pub fn for_adapter(adapter: Arc<dyn SchemaAdapter>) -> Self

Creates an empty cache bound to one schema adapter.

The cache owns the adapter, so every entry is guaranteed to have been produced by that adapter instance.

Example

use adk_core::{GenericSchemaAdapter, SchemaCache};
use std::sync::Arc;

let cache = SchemaCache::for_adapter(Arc::new(GenericSchemaAdapter));
assert!(cache.is_empty());

pub fn normalize(&self, schema: &Value) -> Value

Returns the schema normalized by this cache’s adapter.

If the same input schema has been normalized before, the cached result is returned. Otherwise, the bound adapter normalizes the schema and the result is stored.

Example

use adk_core::{GenericSchemaAdapter, SchemaCache};
use serde_json::json;
use std::sync::Arc;

let cache = SchemaCache::for_adapter(Arc::new(GenericSchemaAdapter));
let schema = json!({"$schema": "draft-07", "type": "string"});

let normalized = cache.normalize(&schema);
assert!(normalized.get("$schema").is_none());

pub fn get_or_normalize( &self, schema: &Value, adapter: &dyn SchemaAdapter, ) -> Value

👎Deprecated:

bind the adapter with SchemaCache::for_adapter and call SchemaCache::normalize

Returns a schema normalized by the supplied adapter.

This compatibility path normalizes before looking up the result because a borrowed trait object has no stable identity that the cache can safely retain. Use SchemaCache::for_adapter and SchemaCache::normalize to avoid repeated normalization.

pub fn clear(&self)

Clears all cached entries.

Call this when the set of tools changes (e.g., MCP server advertises updated schemas) to force re-normalization on the next request.

Example

use adk_core::{GenericSchemaAdapter, SchemaCache};
use serde_json::json;
use std::sync::Arc;

let cache = SchemaCache::for_adapter(Arc::new(GenericSchemaAdapter));
let schema = json!({"type": "string"});

// Populate cache
cache.normalize(&schema);

// Invalidate all entries
cache.clear();

pub fn len(&self) -> usize

Returns the number of cached entries.

pub fn is_empty(&self) -> bool

Returns true if the cache contains no entries.

Trait Implementations

impl Debug for SchemaCache

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

Formats the value using the given formatter.

impl Default for SchemaCache

fn default() -> Self

Returns the “default value” for a type.