daimon 0.16.0

A Rust-native AI agent framework
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

use std::collections::VecDeque;

use tokio::sync::Mutex;

use crate::error::Result;
use crate::memory::traits::Memory;
use crate::model::types::Message;

/// In-memory conversation storage that keeps only the most recent N messages.
///
/// When the window is exceeded, the oldest messages are evicted. Thread-safe via internal mutex.
pub struct SlidingWindowMemory {
    messages: Mutex<VecDeque<Message>>,
    max_messages: usize,
}

impl SlidingWindowMemory {
    /// Creates a new sliding window with the given maximum message count.
    /// When exceeded, oldest messages are dropped.
    pub fn new(max_messages: usize) -> Self {
        Self {
            messages: Mutex::new(VecDeque::new()),
            max_messages,
        }
    }
}

impl Default for SlidingWindowMemory {
    /// Default window size of 50 messages.
    fn default() -> Self {
        Self::new(50)
    }
}

impl Memory for SlidingWindowMemory {
    async fn add_message(&self, message: Message) -> Result<()> {
        let mut messages = self.messages.lock().await;
        if messages.len() >= self.max_messages {
            messages.pop_front();
        }
        messages.push_back(message);
        Ok(())
    }

    async fn get_messages(&self) -> Result<Vec<Message>> {
        let mut messages = self.messages.lock().await;
        Ok(messages.make_contiguous().to_vec())
    }

    async fn clear(&self) -> Result<()> {
        let mut messages = self.messages.lock().await;
        messages.clear();
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::model::types::Role;

    #[tokio::test]
    async fn test_add_and_get_messages() {
        let memory = SlidingWindowMemory::new(10);
        memory.add_message(Message::user("hello")).await.unwrap();
        memory
            .add_message(Message::assistant("hi there"))
            .await
            .unwrap();

        let messages = memory.get_messages().await.unwrap();
        assert_eq!(messages.len(), 2);
        assert_eq!(messages[0].role, Role::User);
        assert_eq!(messages[1].role, Role::Assistant);
    }

    #[tokio::test]
    async fn test_sliding_window_evicts_old_messages() {
        let memory = SlidingWindowMemory::new(3);

        for i in 0..5 {
            memory
                .add_message(Message::user(format!("msg {i}")))
                .await
                .unwrap();
        }

        let messages = memory.get_messages().await.unwrap();
        assert_eq!(messages.len(), 3);
        assert_eq!(messages[0].content.as_deref(), Some("msg 2"));
        assert_eq!(messages[1].content.as_deref(), Some("msg 3"));
        assert_eq!(messages[2].content.as_deref(), Some("msg 4"));
    }

    #[tokio::test]
    async fn test_clear_removes_all_messages() {
        let memory = SlidingWindowMemory::new(10);
        memory.add_message(Message::user("hello")).await.unwrap();
        memory.clear().await.unwrap();

        let messages = memory.get_messages().await.unwrap();
        assert!(messages.is_empty());
    }

    #[tokio::test]
    async fn test_default_window_size() {
        let memory = SlidingWindowMemory::default();
        assert_eq!(memory.max_messages, 50);
    }

    #[tokio::test]
    async fn test_empty_memory_returns_empty_vec() {
        let memory = SlidingWindowMemory::new(10);
        let messages = memory.get_messages().await.unwrap();
        assert!(messages.is_empty());
    }

    #[tokio::test]
    async fn test_window_size_of_one() {
        let memory = SlidingWindowMemory::new(1);
        memory.add_message(Message::user("first")).await.unwrap();
        memory.add_message(Message::user("second")).await.unwrap();

        let messages = memory.get_messages().await.unwrap();
        assert_eq!(messages.len(), 1);
        assert_eq!(messages[0].content.as_deref(), Some("second"));
    }

    #[tokio::test]
    async fn test_messages_at_exact_capacity() {
        let memory = SlidingWindowMemory::new(3);
        memory.add_message(Message::user("a")).await.unwrap();
        memory.add_message(Message::user("b")).await.unwrap();
        memory.add_message(Message::user("c")).await.unwrap();

        let messages = memory.get_messages().await.unwrap();
        assert_eq!(messages.len(), 3);
        assert_eq!(messages[0].content.as_deref(), Some("a"));
    }
}