swink-agent-memory 0.14.3

Session persistence and memory management for swink-agent
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

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

use super::*;
use swink_agent::{ContentBlock, LlmMessage, UserMessage};

fn text_message(text: &str) -> AgentMessage {
    AgentMessage::Llm(LlmMessage::User(
        UserMessage::new(vec![ContentBlock::Text {
            text: text.to_owned(),
        }])
        .with_timestamp(0),
    ))
}

#[test]
fn without_summary_behaves_like_sliding_window() {
    let compactor = SummarizingCompactor::new(250, 100, 1);
    let compact = compactor.compaction_fn();

    // Each message: 400 chars / 4 = 100 tokens
    let body = "x".repeat(400);
    let mut messages = vec![
        text_message(&body),
        text_message(&body),
        text_message(&body),
        text_message(&body),
    ];

    compact(&mut messages, false);

    // Same behavior as sliding_window(250, 100, 1): anchor(1) + tail(1) = 2
    assert_eq!(messages.len(), 2);
}

#[test]
fn with_summary_injects_after_anchor() {
    let compactor = SummarizingCompactor::new(250, 100, 1);
    compactor.set_summary("Earlier we discussed testing strategies.");
    let compact = compactor.compaction_fn();

    let body = "x".repeat(400);
    let mut messages = vec![
        text_message(&body),
        text_message(&body),
        text_message(&body),
        text_message(&body),
    ];

    compact(&mut messages, false);

    // anchor(1) + summary(1) + tail(1) = 3
    assert_eq!(messages.len(), 3);

    // Second message should be the summary (after anchor).
    if let AgentMessage::Llm(LlmMessage::Assistant(a)) = &messages[1] {
        let text = ContentBlock::extract_text(&a.content);
        assert!(
            text.contains("[Context summary"),
            "expected summary prefix, got: {text}"
        );
        assert!(text.contains("testing strategies"));
    } else {
        panic!("expected assistant message at index 1");
    }
}

#[test]
fn no_compaction_needed_no_summary_injected() {
    let compactor = SummarizingCompactor::new(10_000, 5_000, 1);
    compactor.set_summary("This should not appear.");
    let compact = compactor.compaction_fn();

    let mut messages = vec![text_message("hello"), text_message("world")];
    compact(&mut messages, false);

    // Under budget, no compaction, no summary injection.
    assert_eq!(messages.len(), 2);
}

#[test]
fn clear_summary_removes_stored_text() {
    let compactor = SummarizingCompactor::new(100, 50, 1);
    compactor.set_summary("some summary");
    assert!(compactor.has_summary());

    compactor.clear_summary();
    assert!(!compactor.has_summary());
}

#[test]
fn summary_injected_as_assistant_message() {
    let compactor = SummarizingCompactor::new(250, 100, 1);
    compactor.set_summary("Key discussion points here.");
    let compact = compactor.compaction_fn();

    let body = "x".repeat(400);
    let mut messages = vec![
        text_message(&body),
        text_message(&body),
        text_message(&body),
    ];

    compact(&mut messages, false);

    // Find the summary message
    let summary_msg = messages.iter().find(|m| {
        if let AgentMessage::Llm(LlmMessage::Assistant(a)) = m {
            ContentBlock::extract_text(&a.content).contains("[Context summary")
        } else {
            false
        }
    });
    assert!(
        summary_msg.is_some(),
        "summary should be an AssistantMessage"
    );
}

#[test]
fn compaction_with_single_message_returns_unchanged() {
    let compactor = SummarizingCompactor::new(10_000, 5_000, 1);
    let compact = compactor.compaction_fn();

    let mut messages = vec![text_message("single message")];
    compact(&mut messages, false);

    assert_eq!(messages.len(), 1);
}

#[test]
fn summary_consumed_after_injection() {
    let compactor = SummarizingCompactor::new(250, 100, 1);
    compactor.set_summary("Consumed summary.");
    let compact = compactor.compaction_fn();

    let body = "x".repeat(400);
    let mut messages = vec![
        text_message(&body),
        text_message(&body),
        text_message(&body),
        text_message(&body),
    ];

    compact(&mut messages, false);

    // Summary should have been consumed
    assert!(
        !compactor.has_summary(),
        "summary should be consumed after injection"
    );
}