enlil 0.1.0

Vendor-neutral open-source control and audit plane for AI agent actions. Sits inline between your agents and any model or tool: enforce what each agent may do, and prove what it did.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

use bytes::Bytes;
use moka::future::Cache;
use std::time::Duration;

#[derive(Clone)]
pub struct CachedResponse {
    pub body: Bytes,
    pub content_type: String,
    /// blake3 hash of body for integrity validation (cache poisoning prevention)
    pub integrity_hash: String,
}

impl CachedResponse {
    pub fn new(body: Bytes, content_type: String) -> Self {
        let integrity_hash = blake3::hash(&body).to_hex().to_string();
        Self {
            body,
            content_type,
            integrity_hash,
        }
    }

    /// Validates the cached body hasn't been tampered with
    pub fn is_valid(&self) -> bool {
        blake3::hash(&self.body).to_hex().to_string() == self.integrity_hash
    }
}

#[derive(Clone)]
pub struct CacheManager {
    /// Maps a semantic hash string to the cached HTTP response
    store: Cache<String, CachedResponse>,
}

impl Default for CacheManager {
    fn default() -> Self {
        Self::new()
    }
}

impl CacheManager {
    pub fn new() -> Self {
        Self::new_with_config(900, 10_000)
    }

    pub fn new_with_config(ttl_secs: u64, max_capacity: u64) -> Self {
        let store = Cache::builder()
            .time_to_live(Duration::from_secs(ttl_secs))
            .max_capacity(max_capacity)
            .build();

        Self { store }
    }

    pub async fn get(&self, hash: &str) -> Option<CachedResponse> {
        self.store.get(hash).await
    }

    pub async fn insert(&self, hash: &str, response: CachedResponse) {
        self.store.insert(hash.to_string(), response).await;
    }
}