use super::*;
use crate::auto_compaction::{self, Reason};
use crate::compaction_op::prepared_value;
use crate::turns::{Answer, Settled};
use compacting::{AttemptFn, CANCELLED, RetryStep};
use compaction::CompactionSettings;
enum Work {
Done,
Aborted,
Failed(String),
}
pub(super) struct Prepared {
pub preparation: compaction::CompactionPreparation,
pub retained_tail: Vec<Value>,
}
impl Prepared {
fn value(&self, settings: &CompactionSettings) -> Value {
prepared_value(&self.preparation, &self.retained_tail, &settings_value(settings))
}
}
fn settings_value(settings: &CompactionSettings) -> Value {
json!({
"enabled": settings.enabled, "reserveTokens": settings.reserve_tokens,
"keepRecentTokens": settings.keep_recent_tokens,
})
}
impl Core {
pub(super) fn compaction_settings(&self) -> CompactionSettings {
auto_compaction::settings(
&self.runtime.config.settings,
&self.model.provider,
&self.model.id,
Some(self.auto_compaction),
)
.unwrap_or(CompactionSettings {
enabled: false,
..CompactionSettings::default()
})
}
pub(super) fn run_settings(&self) -> Value {
let mut settings = session_journal::run::default_settings();
settings["compaction"] = settings_value(&self.compaction_settings());
settings
}
pub(super) fn prepare_compaction(&self, settings: CompactionSettings) -> Result<Prepared, String> {
self.prepare_compaction_of(&self.pi(), settings, false)
}
fn prepare_compaction_of(
&self,
pi: &SessionManager,
settings: CompactionSettings,
before_overflow: bool,
) -> Result<Prepared, String> {
let mut path: Vec<&Value> = pi.branch_entries(None);
if before_overflow
&& path
.last()
.is_some_and(|e| e["type"] == "message" && e["message"]["stopReason"] == "error")
{
path.pop();
}
let path = session_journal::context::apply_context_edits(&path);
let preparation = match compaction::prepare_compaction(&path, settings) {
Some(preparation) => preparation,
None => {
if path.last().is_some_and(|e| e["type"] == "compaction") {
return Err("Already compacted".into());
}
let previous = path.iter().rposition(|e| e["type"] == "compaction");
let first = match previous {
Some(index) => path[index]["firstKeptEntryId"].as_str(),
None => path.first().and_then(|e| e["id"].as_str()),
}
.ok_or("Nothing to compact (session too small)")?;
let previous_summary = previous.and_then(|index| path[index]["summary"].as_str().map(str::to_string));
let projection = pi.build_session_projection();
let tokens = compaction::estimate_projected_context_tokens(&projection, &path).tokens;
compaction::CompactionPreparation {
first_kept_entry_id: first.to_string(),
messages_to_summarize: Vec::new(),
turn_prefix_messages: Vec::new(),
is_split_turn: false,
tokens_before: tokens,
previous_summary,
file_ops: Default::default(),
settings,
}
}
};
let retained_tail = tail_from(&path, &preparation.first_kept_entry_id).unwrap_or_default();
Ok(Prepared {
preparation,
retained_tail,
})
}
fn compaction_event(&mut self, reason: Reason, end: Option<(Ended, Option<&str>)>) {
let (lane, run_id, reason) = (MAIN_LANE.to_string(), self.run_id(), reason.name().to_string());
self.emit(match end {
None => WatchEvent::CompactionStart { lane, run_id, reason },
Some((status, error)) => WatchEvent::CompactionEnd {
lane,
run_id,
reason,
status,
error: error.map(|message| Failure {
code: None,
message: message.to_string(),
}),
},
});
}
fn journal_error(&self) -> Option<String> {
self.run
.as_ref()
.and_then(|run| run.journal.error().map(str::to_string))
}
fn complete_compaction(&mut self, reason: Reason, prepared: &Prepared) -> Result<(), String> {
let signal = AbortSignal::new();
self.compacting = Some(signal.clone());
let work = self.compaction_work(reason, prepared, &signal);
self.compacting = None;
let message = match work {
Work::Done => {
self.lane.stack.context_reminders.rearm(MAIN_LANE);
self.announce();
self.compaction_event(reason, Some((Ended::Completed, None)));
self.retain_compaction();
return Ok(());
}
Work::Aborted => {
if let Some(run) = self.run.as_mut() {
run.journal.abandon_compaction();
}
self.compaction_event(reason, Some((Ended::Aborted, None)));
return Err(CANCELLED.into());
}
Work::Failed(message) => message,
};
if let Some(run) = self.run.as_mut() {
run.journal.abandon_compaction();
run.error = Some(message.clone());
run.compaction_failed = true;
}
self.compaction_event(reason, Some((Ended::Failed, Some(message.as_str()))));
Err(message)
}
fn compaction_work(&mut self, reason: Reason, prepared: &Prepared, signal: &AbortSignal) -> Work {
if signal.aborted() {
return Work::Aborted;
}
let retry = self.summary_retry();
let id = match self.run.as_mut() {
Some(run) => run.journal.compaction_request(&mut lock_session(&self.session), &retry),
None => None,
};
let Some(id) = id else {
return Work::Failed(self.journal_error().unwrap_or_else(|| "The run has no journal".into()));
};
let summarizer = self.summarizer();
let (preparation, cancel) = (prepared.preparation.clone(), signal.clone());
let attempt: AttemptFn<compaction::CompactionResult> =
Arc::new(move || summarizer.run(&preparation, None, &cancel));
let (run_id, task_id) = self.run.as_ref().map_or_else(Default::default, |run| {
(run.id.clone(), run.journal.compaction_task_id().unwrap_or_default())
});
let mut journal = |core: &mut Core, step: RetryStep<'_>| {
let Some(run) = core.run.as_mut() else {
return Err("No run is in progress".to_string());
};
let mut session = lock_session(&core.session);
match step {
RetryStep::Wait {
usage,
error,
not_before,
} => run
.journal
.compaction_retry_wait(&mut session, usage.as_ref(), error, not_before),
RetryStep::Retry => run.journal.compaction_retry(&mut session),
}
drop(session);
core.journal_error().map_or(Ok(()), Err)
};
let (result, last) = self.summary_attempts(
signal,
retry,
(&run_id, &task_id),
WatchEvent::SummarizationRetryAttemptStart {
lane: MAIN_LANE.into(),
source: "compaction".into(),
reason: Some(reason.name().into()),
},
attempt,
&mut journal,
);
let last_usage = last.map(|message| message.usage);
if signal.aborted() {
return Work::Aborted;
}
let result = match result {
Ok(result) => result,
Err(message) => {
if let (Some(usage), Some(run)) = (last_usage, self.run.as_mut()) {
let usage = serde_json::to_value(&usage).unwrap_or(Value::Null);
run.journal.compaction_usage(&mut lock_session(&self.session), &usage);
}
return Work::Failed(message);
}
};
let usage = serde_json::to_value(&result.usage).unwrap_or(Value::Null);
let entry = result.entry(prepared.retained_tail.clone(), usage.clone());
let Some(run) = self.run.as_mut() else {
return Work::Failed("No run is in progress".into());
};
let mut session = lock_session(&self.session);
run.journal.compaction_usage(&mut session, &usage);
run.journal.complete_compaction(&mut session, &id, entry);
drop(session);
match self.journal_error() {
None => Work::Done,
Some(error) => Work::Failed(error),
}
}
fn decline(&mut self, reason: Reason, waiting: usize) {
let pending = context_lane::pending_count(&lock_session(&self.session));
if pending > waiting {
self.queue_update();
}
let placement = {
let session = lock_session(&self.session);
let tip = session.branch_tip(MAIN_LANE).flatten();
let (mut writes, placed) = context_lane::placement(&session, tip.clone());
if let Some(placed) = placed.filter(|placed| Some(placed) != tip.as_ref()) {
writes.push(Write::set(BRANCH_TIP, MAIN_LANE, placed.into()));
}
writes
};
let resumed = match self.run.as_mut() {
Some(run) => run
.journal
.decline_compaction(&mut lock_session(&self.session), placement),
None => false,
};
self.compaction_event(reason, Some((Ended::Declined, None)));
if resumed && pending > 0 {
self.announce();
self.queue_update();
}
}
pub(super) fn checkpoint_compaction(&mut self) -> Result<bool, String> {
let Some(run) = self.run.as_mut() else {
return Ok(false);
};
if run.cancelled || run.signal.aborted() || run.compaction_failed {
return Ok(false);
}
let resumed = run.resume_overflow.take();
let settings = self.compaction_settings();
if resumed.is_none() && !crate::auto_compaction::may_be_due(&settings, self.model.context_window) {
return Ok(false);
}
let pi = self.pi();
let Ok(prepared) = self.prepare_compaction_of(&pi, settings, resumed.is_some()) else {
return Ok(false);
};
let reason = if resumed.is_some() {
Reason::Overflow
} else {
let path = pi.branch_entries(None);
let trigger = self
.run
.as_ref()
.and_then(|run| run.journal.run().map(|r| r.trigger().to_string()));
let due = auto_compaction::threshold_due(
&settings,
&path,
trigger.as_deref(),
prepared.preparation.tokens_before,
self.model.context_window,
);
if !due {
return Ok(false);
}
Reason::Threshold
};
drop(pi);
if let Some(run) = self.run.as_mut() {
run.journal.begin_compaction(
&mut lock_session(&self.session),
reason.name(),
prepared.value(&settings),
resumed,
);
}
self.compaction_event(reason, None);
let waiting = context_lane::pending_count(&lock_session(&self.session));
let window = i64::try_from(self.model.context_window).ok();
let tokens = i64::try_from(prepared.preparation.tokens_before).unwrap_or(i64::MAX);
let reserve = i64::try_from(settings.reserve_tokens).unwrap_or(i64::MAX);
if self
.context
.before_compaction(MAIN_LANE, reason.name(), tokens, window, reserve)
.unwrap_or(false)
{
self.decline(reason, waiting);
return Ok(false);
}
self.complete_compaction(reason, &prepared)?;
Ok(true)
}
pub(super) fn overflow(&mut self, message: AssistantMessage, answer: Answer<Settled>) {
let error = auto_compaction::as_error(&message);
let settings = self.compaction_settings();
let recoverable = self.run.as_ref().is_some_and(|run| {
!run.cancelled
&& !run.signal.aborted()
&& !run.compaction_failed
&& run.journal.run().is_some_and(|r| !r.overflow_recovery_used())
});
let prepared = if recoverable {
self.prepare_compaction(settings).ok()
} else {
None
};
let Some(prepared) = prepared else {
return answer.give(Settled::Answer(Box::new(error)));
};
if let Some(run) = self.run.as_mut() {
run.journal
.compact_with_answer(&lock_session(&self.session), prepared.value(&settings));
}
self.on_agent_event(AgentEvent::MessageEnd {
message: Message::Assistant(error),
});
self.compaction_event(Reason::Overflow, None);
match self.complete_compaction(Reason::Overflow, &prepared) {
Ok(_) => answer.give(Settled::Retry),
Err(error) => answer.give(Settled::Failed(error)),
}
}
}
fn tail_from(path: &[Value], first: &str) -> Option<Vec<Value>> {
let kept_from = path.iter().position(|e| e["id"] == first)?;
Some(
path[kept_from..]
.iter()
.filter(|e| e["type"] != "compaction")
.flat_map(crate::pi_view::pi_entry_context_messages)
.collect(),
)
}