use ai::{AssistantMessage, StopReason};
use compaction::CompactionSettings;
use serde_json::Value;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Reason {
Threshold,
Overflow,
}
impl Reason {
pub fn name(self) -> &'static str {
match self {
Reason::Threshold => "threshold",
Reason::Overflow => "overflow",
}
}
pub fn parse(name: &str) -> Option<Reason> {
match name {
"threshold" => Some(Reason::Threshold),
"overflow" => Some(Reason::Overflow),
_ => None,
}
}
}
fn token_setting(value: Option<&Value>, what: &str) -> Result<Option<u64>, String> {
let Some(value) = value else { return Ok(None) };
match value.as_f64() {
Some(n) if jsrt::number::is_safe_integer(n) && n >= 0.0 && value.is_number() => Ok(Some(n as u64)),
_ => Err(format!(
"Invalid {what} setting: {}. Expected a non-negative safe integer.",
jsrt::value::string(Some(value))
)),
}
}
pub fn settings(
settings: &Value,
provider: &str,
model_id: &str,
enabled: Option<bool>,
) -> Result<CompactionSettings, String> {
let defaults = CompactionSettings::default();
let compaction = settings.get("compaction");
let key = format!("{provider}/{model_id}");
let resolve = |field: &str, fallback: u64| -> Result<u64, String> {
let ordinary = token_setting(compaction.and_then(|c| c.get(field)), &format!("compaction.{field}"))?;
let entry = compaction
.and_then(|c| c.get("modelOverrides"))
.and_then(|o| o.get(&key));
if let Some(entry) = entry
&& !entry.is_object()
{
return Err(format!(
"Invalid compaction.modelOverrides[\"{key}\"] setting: {}. Expected an object.",
jsrt::value::string(Some(entry))
));
}
let overridden = token_setting(
entry.and_then(|e| e.get(field)),
&format!("compaction.modelOverrides[\"{key}\"].{field}"),
)?;
Ok(overridden.or(ordinary).unwrap_or(fallback))
};
let reserve_tokens = resolve("reserveTokens", defaults.reserve_tokens)?;
let keep_recent_tokens = resolve("keepRecentTokens", defaults.keep_recent_tokens)?;
let configured = match compaction.and_then(|c| c.get("enabled")) {
None | Some(Value::Null) => true,
Some(Value::Bool(on)) => *on,
Some(Value::Number(n)) => n.as_f64().is_some_and(|n| n != 0.0 && !n.is_nan()),
Some(Value::String(text)) => !text.is_empty(),
Some(_) => true,
};
Ok(CompactionSettings {
enabled: enabled.unwrap_or(configured),
reserve_tokens,
keep_recent_tokens,
})
}
pub fn is_context_overflow(message: &AssistantMessage, context_window: u64) -> bool {
if harness::chat::models::is_context_overflow(message) {
return true;
}
let input = message.usage.input + message.usage.cache_read;
if context_window > 0 && message.stop_reason == StopReason::Stop && input > context_window {
return true;
}
context_window > 0
&& message.stop_reason == StopReason::Length
&& message.usage.output == 0
&& input as f64 >= context_window as f64 * 0.99
}
pub fn is_recoverable_length(message: &AssistantMessage, desired_max_output: u64) -> bool {
message.stop_reason == StopReason::Length && desired_max_output > 0 && message.usage.output < desired_max_output
}
pub fn overflowed(message: &AssistantMessage, context_window: u64, intended_output_limit: u64) -> bool {
is_context_overflow(message, context_window) || is_recoverable_length(message, intended_output_limit)
}
pub fn as_error(message: &AssistantMessage) -> AssistantMessage {
let mut error = message.clone();
error.error_message = Some(
message
.error_message
.clone()
.unwrap_or_else(|| "Assistant request exceeded the context window".into()),
);
error.stop_reason = StopReason::Error;
error
}
pub fn may_be_due(settings: &CompactionSettings, context_window: u64) -> bool {
settings.enabled && context_window != 0
}
pub fn threshold_due<V: std::borrow::Borrow<Value>>(
settings: &CompactionSettings,
path: &[V],
trigger: Option<&str>,
tokens_before: u64,
context_window: u64,
) -> bool {
if !may_be_due(settings, context_window) {
return false;
}
let newest_compaction = path.iter().rposition(|e| e.borrow()["type"] == "compaction");
let trigger_index = trigger.and_then(|t| path.iter().position(|e| e.borrow()["id"] == t));
if let Some(compaction) = newest_compaction
&& trigger_index.is_none_or(|trigger| compaction >= trigger)
{
return false;
}
compaction::should_compact(tokens_before, context_window, settings)
}