swink-agent 0.13.2

Core scaffolding for running LLM-powered agentic loops
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

//! Tests for `context_cache`.
#![cfg(test)]

use super::*;

fn test_config(intervals: usize) -> CacheConfig {
    CacheConfig::new(Duration::from_mins(10), 4096, intervals)
}

#[test]
fn first_turn_emits_write() {
    let mut state = CacheState::new();
    let config = test_config(3);
    let hint = state.advance_turn(&config);
    assert_eq!(
        hint,
        CacheHint::Write {
            ttl: Duration::from_mins(10)
        }
    );
}

#[test]
fn subsequent_turns_emit_read() {
    let mut state = CacheState::new();
    let config = test_config(3);
    state.advance_turn(&config); // turn 1: Write
    assert_eq!(state.advance_turn(&config), CacheHint::Read); // turn 2
    assert_eq!(state.advance_turn(&config), CacheHint::Read); // turn 3
}

#[test]
fn refresh_after_cache_intervals() {
    let mut state = CacheState::new();
    let config = test_config(3);
    state.advance_turn(&config); // turn 1: Write
    state.advance_turn(&config); // turn 2: Read
    state.advance_turn(&config); // turn 3: Read
    // turn 4: should refresh (turns_since_write == 3 == cache_intervals)
    let hint = state.advance_turn(&config);
    assert_eq!(
        hint,
        CacheHint::Write {
            ttl: Duration::from_mins(10)
        }
    );
}

#[test]
fn reset_forces_write_on_next_turn() {
    let mut state = CacheState::new();
    let config = test_config(5);
    state.advance_turn(&config); // Write
    state.advance_turn(&config); // Read
    state.reset(); // adapter-reported cache miss
    let hint = state.advance_turn(&config);
    assert_eq!(
        hint,
        CacheHint::Write {
            ttl: Duration::from_mins(10)
        }
    );
}

#[test]
fn cached_prefix_len_tracks_correctly() {
    let mut state = CacheState::new();
    assert_eq!(state.cached_prefix_len, 0);
    state.cached_prefix_len = 5;
    assert_eq!(state.cached_prefix_len, 5);
    state.reset();
    assert_eq!(state.cached_prefix_len, 0);
}

#[test]
fn min_tokens_below_threshold_suppresses_hints() {
    // The CacheState itself doesn't enforce min_tokens — that check
    // happens in the turn pipeline. Verify the config carries it.
    let config = CacheConfig::new(Duration::from_mins(5), 8192, 2);
    assert_eq!(config.min_tokens, 8192);
}

#[test]
fn serde_round_trip_write_hint() {
    let hint = CacheHint::Write {
        ttl: Duration::from_mins(10),
    };
    let json = serde_json::to_string(&hint).unwrap();
    let back: CacheHint = serde_json::from_str(&json).unwrap();
    assert_eq!(hint, back);
}

#[test]
fn serde_round_trip_read_hint() {
    let hint = CacheHint::Read;
    let json = serde_json::to_string(&hint).unwrap();
    let back: CacheHint = serde_json::from_str(&json).unwrap();
    assert_eq!(hint, back);
}