vex_core/
context.rs

1//! Context packets for VEX agents
2//!
3//! A [`ContextPacket`] is the unit of information passed between agents,
4//! with temporal metadata and cryptographic hashing.
5
6use crate::merkle::Hash;
7use chrono::{DateTime, Duration, Utc};
8use serde::{Deserialize, Serialize};
9use sha2::{Digest, Sha256};
10use uuid::Uuid;
11
12/// Compression level for context packets
13#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
14pub enum CompressionLevel {
15    /// Full fidelity - no compression
16    Full,
17    /// Summary - moderate compression
18    Summary,
19    /// Abstract - high compression, key points only
20    Abstract,
21    /// Minimal - extreme compression
22    Minimal,
23}
24
25impl CompressionLevel {
26    /// Get the numeric compression ratio (0.0 = full, 1.0 = minimal)
27    pub fn ratio(&self) -> f64 {
28        match self {
29            Self::Full => 0.0,
30            Self::Summary => 0.3,
31            Self::Abstract => 0.6,
32            Self::Minimal => 0.9,
33        }
34    }
35}
36
37/// A context packet - the unit of information in VEX
38#[derive(Debug, Clone, Serialize, Deserialize)]
39pub struct ContextPacket {
40    /// Unique identifier for this packet
41    pub id: Uuid,
42    /// The actual content
43    pub content: String,
44    /// When this context was created
45    pub created_at: DateTime<Utc>,
46    /// When this context expires (if applicable)
47    pub expires_at: Option<DateTime<Utc>>,
48    /// Compression level applied
49    pub compression: CompressionLevel,
50    /// SHA-256 hash of the content
51    pub hash: Hash,
52    /// Hash of the parent packet (for chaining)
53    pub parent_hash: Option<Hash>,
54    /// Source agent ID
55    pub source_agent: Option<Uuid>,
56    /// Importance score (0.0 - 1.0)
57    pub importance: f64,
58}
59
60impl ContextPacket {
61    /// Create a new context packet with the given content
62    pub fn new(content: &str) -> Self {
63        let hash = Self::compute_hash(content);
64        Self {
65            id: Uuid::new_v4(),
66            content: content.to_string(),
67            created_at: Utc::now(),
68            expires_at: None,
69            compression: CompressionLevel::Full,
70            hash,
71            parent_hash: None,
72            source_agent: None,
73            importance: 0.5,
74        }
75    }
76
77    /// Create a context packet with a TTL (time-to-live)
78    pub fn with_ttl(content: &str, ttl: Duration) -> Self {
79        let mut packet = Self::new(content);
80        packet.expires_at = Some(Utc::now() + ttl);
81        packet
82    }
83
84    /// Compute SHA-256 hash of content
85    pub fn compute_hash(content: &str) -> Hash {
86        let mut hasher = Sha256::new();
87        hasher.update(content.as_bytes());
88        Hash(hasher.finalize().into())
89    }
90
91    /// Check if this packet has expired
92    pub fn is_expired(&self) -> bool {
93        self.expires_at.is_some_and(|exp| Utc::now() > exp)
94    }
95
96    /// Get the age of this packet
97    pub fn age(&self) -> Duration {
98        Utc::now().signed_duration_since(self.created_at)
99    }
100
101    /// Create a compressed version of this packet
102    pub fn compress(&self, level: CompressionLevel) -> Self {
103        // In a real implementation, this would use an LLM to summarize
104        // For now, we just truncate based on compression ratio
105        let max_len = ((1.0 - level.ratio()) * self.content.len() as f64) as usize;
106        let compressed_content = if max_len < self.content.len() {
107            format!("{}...", &self.content[..max_len.max(10)])
108        } else {
109            self.content.clone()
110        };
111
112        let mut packet = Self::new(&compressed_content);
113        packet.compression = level;
114        packet.parent_hash = Some(self.hash.clone());
115        packet.source_agent = self.source_agent;
116        packet.importance = self.importance;
117        packet
118    }
119
120    /// Chain this packet to a parent
121    pub fn chain_to(&mut self, parent: &ContextPacket) {
122        self.parent_hash = Some(parent.hash.clone());
123    }
124}
125
126#[cfg(test)]
127mod tests {
128    use super::*;
129
130    #[test]
131    fn test_create_packet() {
132        let packet = ContextPacket::new("Hello, world!");
133        assert_eq!(packet.content, "Hello, world!");
134        assert_eq!(packet.compression, CompressionLevel::Full);
135        assert!(!packet.is_expired());
136    }
137
138    #[test]
139    fn test_packet_with_ttl() {
140        let packet = ContextPacket::with_ttl("Temporary data", Duration::hours(1));
141        assert!(packet.expires_at.is_some());
142        assert!(!packet.is_expired());
143    }
144
145    #[test]
146    fn test_compress_packet() {
147        let packet = ContextPacket::new(
148            "This is a long piece of content that should be compressed when needed.",
149        );
150        let compressed = packet.compress(CompressionLevel::Summary);
151        assert_eq!(compressed.compression, CompressionLevel::Summary);
152        assert!(compressed.content.len() <= packet.content.len());
153    }
154}
vex_core/context.rs

vex_core/
context.rs
