Skip to main content

rig_memory/
recent.rs

1//! Recent messages: which newest messages of a conversation a request
2//! sends. A [`Recent`] rule says where the messages it keeps start; [`view`] moves that
3//! start past results whose calls it cut off, so every result it keeps
4//! still follows its call.
5//!
6//! ```
7//! use std::sync::Arc;
8//!
9//! use rig_core::completion::Message;
10//! use rig_memory::recent::{LastMessages, view};
11//!
12//! let messages = [Message::user("1"), Message::assistant("2"), Message::user("3")].map(Arc::new);
13//! assert_eq!(view(&messages, &LastMessages(2)), &messages[1..]);
14//! ```
15
16use std::sync::Arc;
17
18use rig_core::completion::Message;
19use rig_core::conversation::pairing::safe_start;
20use rig_core::wasm_compat::{WasmCompatSend, WasmCompatSync};
21
22use crate::HeuristicTokenCounter;
23
24/// Where the newest messages a request sends start.
25pub trait Recent: WasmCompatSend + WasmCompatSync {
26    /// The index of the first message of `messages` to keep, at most
27    /// `messages.len()`.
28    fn start(&self, messages: &[Arc<Message>]) -> usize;
29}
30
31/// The newest so many messages.
32#[derive(Clone, Copy, Debug, PartialEq, Eq)]
33pub struct LastMessages(pub usize);
34
35impl Recent for LastMessages {
36    fn start(&self, messages: &[Arc<Message>]) -> usize {
37        messages.len().saturating_sub(self.0)
38    }
39}
40
41/// The newest messages within `max_tokens`, as [`HeuristicTokenCounter`]
42/// counts them: walking back from the newest, it stops before the first
43/// message that does not fit.
44#[derive(Clone, Copy, Debug)]
45pub struct TokenBudget {
46    /// The budget.
47    pub max_tokens: usize,
48}
49
50impl TokenBudget {
51    /// A budget of `max_tokens`.
52    pub fn new(max_tokens: usize) -> Self {
53        Self { max_tokens }
54    }
55}
56
57impl Recent for TokenBudget {
58    fn start(&self, messages: &[Arc<Message>]) -> usize {
59        let counter = HeuristicTokenCounter::default();
60        let mut budget = self.max_tokens;
61        let mut start = messages.len();
62        for (index, message) in messages.iter().enumerate().rev() {
63            let cost = counter.count(message);
64            if cost > budget {
65                break;
66            }
67            budget -= cost;
68            start = index;
69        }
70        start
71    }
72}
73
74/// The messages of `messages` that `recent` keeps, from its start moved
75/// forward by [`safe_start`] so no result loses its call.
76pub fn view<'m>(messages: &'m [Arc<Message>], recent: &dyn Recent) -> &'m [Arc<Message>] {
77    let start = safe_start(messages, recent.start(messages));
78    messages.get(start..).unwrap_or_default()
79}
80
81#[cfg(test)]
82mod tests;