use jsrt::sync;
use std::collections::HashMap;
use std::sync::{Arc, Mutex, OnceLock};
pub const MIN_MARGIN: u64 = 2048;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ReminderSettings {
pub enabled: bool,
pub margin: Option<u64>,
}
impl ReminderSettings {
pub fn from_vars(reminder: Option<&str>, tokens: Option<&str>) -> ReminderSettings {
ReminderSettings {
enabled: !crate::flag_off(reminder),
margin: tokens.and_then(|value| value.trim().parse::<u64>().ok()),
}
}
}
pub fn margin(context_window: u64, configured: Option<u64>) -> u64 {
configured.unwrap_or_else(|| MIN_MARGIN.max(context_window / 10))
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Limit {
pub context_window: u64,
pub reserve_tokens: u64,
pub compaction: bool,
}
impl Limit {
pub fn tokens(&self) -> u64 {
self.context_window.saturating_sub(self.reserve_tokens)
}
pub fn trigger(&self, configured_margin: Option<u64>) -> u64 {
self.tokens()
.saturating_sub(margin(self.context_window, configured_margin))
}
}
pub fn lane_limit(model: &ai::Model, compaction: bool, reserve_tokens: u64) -> Option<Limit> {
(model.provider != ai::claude_code::PROVIDER).then_some(Limit {
context_window: model.context_window,
reserve_tokens,
compaction,
})
}
pub fn format_tokens(tokens: u64) -> String {
if tokens < 1000 {
return tokens.to_string();
}
let tenths = tokens / 100;
match tenths % 10 {
0 => format!("{}k", tenths / 10),
decimal => format!("{}.{decimal}k", tenths / 10),
}
}
pub fn reminder_line(used: u64, limit: &Limit) -> String {
let at = if limit.compaction {
"before compaction"
} else {
"before the context limit"
};
format!(
"[context: {} of {} tokens used {at}; free space with ctx now: await ctx.history() lists items with their bytes, await ctx.forget(ids, reason) or await ctx.summarize(ids, text) drops or shortens them]",
format_tokens(used),
format_tokens(limit.tokens())
)
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Measure {
pub tokens: u64,
pub epoch: Option<u64>,
}
pub type ContextMeter = Arc<dyn Fn(&str) -> Option<Measure> + Send + Sync>;
pub type LaneMeter = Arc<dyn Fn() -> Option<u64> + Send + Sync>;
pub const ESTIMATED_IMAGE_CHARS: u64 = 4800;
#[derive(Default)]
struct LaneState {
reminded: bool,
epoch: Option<u64>,
}
pub struct ContextReminders {
settings: ReminderSettings,
limits: Mutex<HashMap<String, Limit>>,
lanes: Mutex<HashMap<String, LaneState>>,
meter: OnceLock<ContextMeter>,
lane_meters: Mutex<HashMap<String, LaneMeter>>,
}
impl ContextReminders {
pub fn new(settings: ReminderSettings) -> ContextReminders {
ContextReminders {
settings,
limits: Mutex::default(),
lanes: Mutex::default(),
meter: OnceLock::new(),
lane_meters: Mutex::default(),
}
}
pub fn settings(&self) -> ReminderSettings {
self.settings
}
pub fn set_meter(&self, meter: ContextMeter) {
let _ = self.meter.set(meter);
}
pub fn set_limit(&self, lane: &str, limit: Option<Limit>) {
let mut limits = sync::lock(&self.limits);
match limit.filter(|limit| limit.context_window > 0) {
Some(limit) => limits.insert(lane.to_string(), limit),
None => limits.remove(lane),
};
}
pub fn set_lane_meter(&self, lane: &str, meter: Option<LaneMeter>) {
match meter {
Some(meter) => sync::lock(&self.lane_meters).insert(lane.to_string(), meter),
None => sync::lock(&self.lane_meters).remove(lane),
};
}
pub fn set_frame_lane(&self, lane: &str, frame: Option<(Limit, LaneMeter)>) {
match frame {
Some((limit, meter)) => {
self.set_limit(lane, Some(limit));
sync::lock(&self.lane_meters).insert(lane.to_string(), meter);
}
None => {
self.set_limit(lane, None);
sync::lock(&self.lane_meters).remove(lane);
sync::lock(&self.lanes).remove(lane);
}
}
}
pub fn limit(&self, lane: &str) -> Option<Limit> {
sync::lock(&self.limits).get(lane).copied()
}
pub fn rearm(&self, lane: &str) {
if let Some(state) = sync::lock(&self.lanes).get_mut(lane) {
state.reminded = false;
}
}
pub fn observe(&self, lane: &str, measure: Measure) -> Option<String> {
if !self.settings.enabled {
return None;
}
let limit = self.limit(lane)?;
let mut lanes = sync::lock(&self.lanes);
let state = lanes.entry(lane.to_string()).or_default();
if state.epoch != measure.epoch {
state.epoch = measure.epoch;
state.reminded = false;
}
if measure.tokens < limit.trigger(self.settings.margin) {
state.reminded = false;
return None;
}
if state.reminded {
return None;
}
state.reminded = true;
Some(reminder_line(measure.tokens, &limit))
}
pub fn reminder(&self, lane: &str, text: &str, images: usize) -> Option<String> {
if !self.settings.enabled {
return None;
}
let own = sync::lock(&self.lane_meters).get(lane).cloned();
let measure = match own {
Some(meter) => Measure {
tokens: meter()?,
epoch: None,
},
None => (self.meter.get()?)(lane)?,
};
let chars = text.encode_utf16().count() as u64 + images as u64 * ESTIMATED_IMAGE_CHARS;
self.observe(
lane,
Measure {
tokens: measure.tokens + chars.div_ceil(4),
epoch: measure.epoch,
},
)
}
}