talos-session 0.8.0

JSONL-based session logging for Talos agent conversations
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

#![allow(dead_code)]
//! Segment compression trait for session archival (ADR-036/037).
//!
//! When session compaction triggers (Slice D), frozen segments are compressed
//! to reduce storage. The `SegmentCompressor` trait abstracts compression
//! behind a swappable interface per ADR-036.

pub trait SegmentCompressor: Send + Sync {
    fn compress(&self, input: &[u8]) -> Result<Vec<u8>, CompressionError>;
    fn decompress(&self, input: &[u8]) -> Result<Vec<u8>, CompressionError>;
    fn format_tag(&self) -> &'static str;
}

#[derive(Debug)]
pub enum CompressionError {
    CompressFailed(String),
    DecompressFailed(String),
}

impl std::fmt::Display for CompressionError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            CompressionError::CompressFailed(msg) => write!(f, "compression failed: {msg}"),
            CompressionError::DecompressFailed(msg) => write!(f, "decompression failed: {msg}"),
        }
    }
}

impl std::error::Error for CompressionError {}

pub struct NoCompressor;

impl SegmentCompressor for NoCompressor {
    fn compress(&self, input: &[u8]) -> Result<Vec<u8>, CompressionError> {
        Ok(input.to_vec())
    }
    fn decompress(&self, input: &[u8]) -> Result<Vec<u8>, CompressionError> {
        Ok(input.to_vec())
    }
    fn format_tag(&self) -> &'static str {
        "none"
    }
}

#[cfg(feature = "archive-compress-zstd")]
pub struct ZstdCompressor {
    level: i32,
}

#[cfg(feature = "archive-compress-zstd")]
impl Default for ZstdCompressor {
    fn default() -> Self {
        Self { level: 3 }
    }
}

#[cfg(feature = "archive-compress-zstd")]
impl SegmentCompressor for ZstdCompressor {
    fn compress(&self, input: &[u8]) -> Result<Vec<u8>, CompressionError> {
        zstd::stream::encode_all(input, self.level)
            .map_err(|e| CompressionError::CompressFailed(e.to_string()))
    }
    fn decompress(&self, input: &[u8]) -> Result<Vec<u8>, CompressionError> {
        zstd::stream::decode_all(input)
            .map_err(|e| CompressionError::DecompressFailed(e.to_string()))
    }
    fn format_tag(&self) -> &'static str {
        "zstd"
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn no_compressor_round_trip() {
        let c = NoCompressor;
        let data = b"Hello, world! This is test data for compression.";
        let compressed = c.compress(data).expect("operation should succeed");
        let decompressed = c.decompress(&compressed).expect("operation should succeed");
        assert_eq!(data.as_slice(), decompressed.as_slice());
        assert_eq!(c.format_tag(), "none");
    }

    #[test]
    fn no_compressor_preserves_empty() {
        let c = NoCompressor;
        let compressed = c.compress(b"").expect("operation should succeed");
        assert!(compressed.is_empty());
        let decompressed = c.decompress(&compressed).expect("operation should succeed");
        assert!(decompressed.is_empty());
    }

    #[cfg(feature = "archive-compress-zstd")]
    #[test]
    fn zstd_compressor_round_trip() {
        let c = ZstdCompressor::default();
        let data = b"Hello, world! This is test data for compression.".repeat(100);
        let compressed = c.compress(&data).expect("operation should succeed");
        assert!(
            compressed.len() < data.len(),
            "zstd should compress repetitive data"
        );
        let decompressed = c.decompress(&compressed).expect("operation should succeed");
        assert_eq!(data, decompressed);
        assert_eq!(c.format_tag(), "zstd");
    }
}