mod branch;
mod bug_summary;
use std::collections::HashSet;
use ai::transcript::{ContextUsageEstimate, normalize_context};
use ai::{
AssistantContent, AssistantMessage, Context, Message, Model, StopReason, TextContent, TranscriptContext, Usage,
UserContent, UserMessage, UserMessageContent,
};
use indexmap::IndexSet;
use jsrt::utf16;
use protocol::custom_types;
use serde_json::Value;
use session_file::{Leaf, ProjectedEntry, SessionProjection, build_session_projection, current_system_message, js};
use session_journal::context::convert_to_llm;
pub use branch::{
BranchPreparation, BranchSummary, BranchSummaryError, BranchSummaryOptions, collect_entries_for_branch_summary,
generate_branch_summary, prepare_branch_entries,
};
pub use bug_summary::{bug_summary_request, bug_summary_text};
fn str_of<'a>(value: &'a Value, key: &str) -> Option<&'a str> {
value.get(key).and_then(Value::as_str)
}
fn role(message: &Value) -> Option<&str> {
str_of(message, "role")
}
fn entry_type(entry: &Value) -> Option<&str> {
str_of(entry, "type")
}
fn content_text(content: Option<&Value>, separator: &str) -> String {
match content {
Some(Value::String(text)) => text.clone(),
Some(Value::Array(blocks)) => blocks
.iter()
.filter(|b| str_of(b, "type") == Some("text"))
.map(|b| js::join_string(b.get("text")))
.collect::<Vec<_>>()
.join(separator),
_ => String::new(),
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct FileOperations {
pub read: IndexSet<String>,
pub written: IndexSet<String>,
pub edited: IndexSet<String>,
}
pub fn extract_file_ops_from_message(message: &Value, ops: &mut FileOperations) {
if role(message) != Some("assistant") {
return;
}
let Some(blocks) = message.get("content").and_then(Value::as_array) else {
return;
};
for block in blocks {
if str_of(block, "type") != Some("toolCall") || block.get("name").is_none() {
continue;
}
let Some(path) = block.get("arguments").and_then(|args| str_of(args, "path")) else {
continue;
};
if path.is_empty() {
continue;
}
let set = match str_of(block, "name") {
Some("read") => &mut ops.read,
Some("write") => &mut ops.written,
Some("edit") => &mut ops.edited,
_ => continue,
};
set.insert(path.to_string());
}
}
pub fn compute_file_lists(ops: &FileOperations) -> (Vec<String>, Vec<String>) {
let modified: IndexSet<&String> = ops.edited.iter().chain(&ops.written).collect();
let mut read_files: Vec<String> = ops.read.iter().filter(|f| !modified.contains(f)).cloned().collect();
let mut modified_files: Vec<String> = modified.into_iter().cloned().collect();
utf16::sort(&mut read_files);
utf16::sort(&mut modified_files);
(read_files, modified_files)
}
pub fn format_file_operations(read_files: &[String], modified_files: &[String]) -> String {
let mut sections = Vec::new();
if !read_files.is_empty() {
sections.push(format!("<read-files>\n{}\n</read-files>", read_files.join("\n")));
}
if !modified_files.is_empty() {
sections.push(format!(
"<modified-files>\n{}\n</modified-files>",
modified_files.join("\n")
));
}
if sections.is_empty() {
return String::new();
}
format!("\n\n{}", sections.join("\n\n"))
}
const TOOL_RESULT_MAX_CHARS: usize = 2000;
fn truncate_for_summary(text: &str, max_chars: usize) -> String {
let len = utf16::len(text);
if len <= max_chars {
return text.to_string();
}
format!(
"{}\n\n[... {} more characters truncated]",
utf16::head(text, max_chars),
len - max_chars
)
}
pub fn serialize_conversation(messages: &[Value]) -> String {
let mut parts = Vec::new();
for message in messages {
match role(message) {
Some("user") => {
let content = content_text(message.get("content"), "");
if !content.is_empty() {
parts.push(format!("[User]: {content}"));
}
}
Some("assistant") => {
let blocks = message
.get("content")
.and_then(Value::as_array)
.map_or(&[][..], Vec::as_slice);
let mut thinking = Vec::new();
let mut calls = Vec::new();
for block in blocks {
match str_of(block, "type") {
Some("thinking") => thinking.push(js::join_string(block.get("thinking"))),
Some("toolCall") => {
let args = match block.get("arguments") {
Some(Value::Object(map)) => jsrt::json::object_entries(map)
.into_iter()
.map(|(k, v)| format!("{k}={}", jsrt::json::stringify(v)))
.collect::<Vec<_>>()
.join(", "),
_ => String::new(),
};
calls.push(format!("{}({args})", js::join_string(block.get("name"))));
}
_ => {}
}
}
if !thinking.is_empty() {
parts.push(format!("[Assistant thinking]: {}", thinking.join("\n")));
}
if blocks.iter().any(|b| str_of(b, "type") == Some("text")) {
parts.push(format!("[Assistant]: {}", content_text(message.get("content"), "\n")));
}
if !calls.is_empty() {
parts.push(format!("[Assistant tool calls]: {}", calls.join("; ")));
}
}
Some("toolResult") => {
let content = content_text(message.get("content"), "");
if !content.is_empty() {
parts.push(format!(
"[Tool result]: {}",
truncate_for_summary(&content, TOOL_RESULT_MAX_CHARS)
));
}
}
_ => {}
}
}
parts.join("\n\n")
}
pub fn convert_for_summary(messages: &[Value]) -> Vec<Value> {
let recalled = |m: &Value| {
role(m) == Some("custom")
&& matches!(
m.get("customType").and_then(Value::as_str),
Some(custom_types::RECALLED_MEMORY | custom_types::REFINEMENTS)
)
};
if !messages.iter().any(recalled) {
return convert_to_llm(messages);
}
let kept: Vec<Value> = messages.iter().filter(|m| !recalled(m)).cloned().collect();
convert_to_llm(&kept)
}
const SUMMARIZATION_SYSTEM_PROMPT: &str = "You are a context summarization assistant. Your task is to read a conversation between a user and an AI assistant, then produce a structured summary following the exact format specified.
Do NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.";
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct CompactionSettings {
pub enabled: bool,
pub reserve_tokens: u64,
pub keep_recent_tokens: u64,
}
impl Default for CompactionSettings {
fn default() -> Self {
CompactionSettings {
enabled: true,
reserve_tokens: 16384,
keep_recent_tokens: 20000,
}
}
}
fn number(value: &Value, key: &str) -> u64 {
value.get(key).and_then(Value::as_f64).map_or(0, |n| n as u64)
}
pub fn calculate_context_tokens(usage: &Value) -> u64 {
match number(usage, "totalTokens") {
0 => {
number(usage, "input") + number(usage, "output") + number(usage, "cacheRead") + number(usage, "cacheWrite")
}
total => total,
}
}
fn assistant_usage(message: &Value) -> Option<&Value> {
if role(message) != Some("assistant") || matches!(str_of(message, "stopReason"), Some("aborted" | "error")) {
return None;
}
message
.get("usage")
.filter(|u| jsrt::value::truthy(Some(u)) && calculate_context_tokens(u) > 0)
}
const ESTIMATED_IMAGE_CHARS: usize = 4800;
fn text_and_image_chars(content: Option<&Value>) -> usize {
match content {
Some(Value::String(text)) => utf16::len(text),
Some(Value::Array(blocks)) => blocks
.iter()
.map(|block| match str_of(block, "type") {
Some("text") => str_of(block, "text").map_or(0, utf16::len),
Some("image") => ESTIMATED_IMAGE_CHARS,
_ => 0,
})
.sum(),
_ => 0,
}
}
pub fn estimate_tokens(message: &Value) -> u64 {
let len = |key: &str| str_of(message, key).map_or(0, utf16::len);
let chars = match role(message) {
Some("system") => {
let sections: usize = match message.get("sections") {
Some(Value::Object(map)) => map.values().filter_map(Value::as_str).map(utf16::len).sum(),
_ => 0,
};
let tools = message
.get("toolsAdded")
.filter(|t| jsrt::value::truthy(Some(t)))
.map_or(0, |t| utf16::len(&jsrt::json::stringify(t)));
text_and_image_chars(message.get("content")) + sections + tools
}
Some("user" | "custom" | "toolResult") => text_and_image_chars(message.get("content")),
Some("assistant") => message
.get("content")
.and_then(Value::as_array)
.map_or(&[][..], Vec::as_slice)
.iter()
.map(|block| match str_of(block, "type") {
Some("text") => str_of(block, "text").map_or(0, utf16::len),
Some("thinking") => str_of(block, "thinking").map_or(0, utf16::len),
Some("toolCall") => {
str_of(block, "name").map_or(0, utf16::len)
+ block
.get("arguments")
.map_or(0, |a| utf16::len(&jsrt::json::stringify(a)))
}
_ => 0,
})
.sum(),
Some("bashExecution") => len("command") + len("output"),
Some("branchSummary" | "compactionSummary") => len("summary"),
_ => 0,
};
chars.div_ceil(4) as u64
}
pub fn estimate_context_tokens(messages: &[Value]) -> ContextUsageEstimate {
let last = messages
.iter()
.enumerate()
.rev()
.find_map(|(i, m)| assistant_usage(m).map(|u| (calculate_context_tokens(u), i)));
match last {
None => {
let tokens = messages.iter().map(estimate_tokens).sum();
ContextUsageEstimate {
tokens,
usage_tokens: 0,
trailing_tokens: tokens,
last_usage_index: None,
}
}
Some((usage_tokens, index)) => {
let trailing_tokens: u64 = messages[index + 1..].iter().map(estimate_tokens).sum();
ContextUsageEstimate {
tokens: usage_tokens + trailing_tokens,
usage_tokens,
trailing_tokens,
last_usage_index: Some(index),
}
}
}
}
pub fn estimate_projected_context_tokens(
projection: &SessionProjection<'_>,
branch_entries: &[Value],
) -> ContextUsageEstimate {
let estimate = estimate_context_tokens(&projection.messages);
if let Some(last_usage) = estimate.last_usage_index {
let mut start = 0;
let mut usage_entry_id = None;
for entry in &projection.entries {
let next = start + entry.messages.len();
if last_usage < next {
usage_entry_id = entry.source.get("id").filter(|id| jsrt::value::truthy(Some(id)));
break;
}
start = next;
}
let usage_entry_index =
usage_entry_id.and_then(|id| branch_entries.iter().position(|e| e.get("id") == Some(id)));
let invalidating = branch_entries
.iter()
.rposition(|e| matches!(entry_type(e), Some("context_edit" | "compaction")));
if usage_entry_index.is_some_and(|u| invalidating.is_none_or(|i| u > i)) {
return estimate;
}
}
let system = current_system_message(&projection.messages).map_or(0, |m| estimate_tokens(&m));
let tokens = system
+ projection
.messages
.iter()
.filter(|m| role(m) != Some("system"))
.map(estimate_tokens)
.sum::<u64>();
ContextUsageEstimate {
tokens,
usage_tokens: 0,
trailing_tokens: tokens,
last_usage_index: None,
}
}
pub fn should_compact(context_tokens: u64, context_window: u64, settings: &CompactionSettings) -> bool {
settings.enabled && i128::from(context_tokens) > i128::from(context_window) - i128::from(settings.reserve_tokens)
}
fn is_cut_point_message(message: &Value) -> bool {
matches!(
role(message),
Some("user" | "assistant" | "bashExecution" | "custom" | "branchSummary" | "compactionSummary")
)
}
fn is_turn_start_message(message: &Value) -> bool {
matches!(
role(message),
Some("user" | "bashExecution" | "custom" | "branchSummary" | "compactionSummary")
)
}
fn is_turn_start_entry(entry: &Value) -> bool {
entry_type(entry) != Some("compaction") && session_file::entry_messages(entry).iter().any(is_turn_start_message)
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct CutPoint {
pub first_kept_entry_index: usize,
pub turn_start_index: Option<usize>,
pub is_split_turn: bool,
}
pub fn find_turn_start_index(entries: &[Value], entry_index: usize, start_index: usize) -> Option<usize> {
(start_index..=entry_index)
.rev()
.find(|&i| is_turn_start_entry(&entries[i]))
}
fn budget_cut(
cut_points: &[usize],
start: usize,
end: usize,
keep: u64,
tokens: impl Fn(usize) -> u64,
) -> (usize, bool) {
let mut accumulated = 0;
for i in (start..end).rev() {
let message_tokens = tokens(i);
if message_tokens == 0 {
continue;
}
accumulated += message_tokens;
if accumulated >= keep {
let cut = cut_points
.iter()
.copied()
.find(|&c| c >= i)
.unwrap_or(cut_points[cut_points.len() - 1]);
return (cut, true);
}
}
(cut_points[0], false)
}
pub fn find_cut_point(entries: &[Value], start_index: usize, end_index: usize, keep_recent_tokens: u64) -> CutPoint {
let cut_points: Vec<usize> = (start_index..end_index)
.filter(|&i| {
entry_type(&entries[i]) != Some("compaction")
&& session_file::entry_messages(&entries[i])
.iter()
.any(is_cut_point_message)
})
.collect();
if cut_points.is_empty() {
return CutPoint {
first_kept_entry_index: start_index,
turn_start_index: None,
is_split_turn: false,
};
}
let (mut cut, _) = budget_cut(&cut_points, start_index, end_index, keep_recent_tokens, |i| {
session_file::entry_messages(&entries[i])
.iter()
.map(estimate_tokens)
.sum()
});
while cut > start_index {
let previous = &entries[cut - 1];
if entry_type(previous) == Some("compaction") || !session_file::entry_messages(previous).is_empty() {
break;
}
cut -= 1;
}
let starts_turn = is_turn_start_entry(&entries[cut]);
let turn_start_index = if starts_turn {
None
} else {
find_turn_start_index(entries, cut, start_index)
};
CutPoint {
first_kept_entry_index: cut,
turn_start_index,
is_split_turn: !starts_turn && turn_start_index.is_some(),
}
}
fn source_type<'a>(entry: &ProjectedEntry<'a>) -> Option<&'a str> {
entry_type(entry.source)
}
fn is_projected_turn_start(entry: &ProjectedEntry<'_>) -> bool {
source_type(entry) != Some("compaction") && entry.messages.iter().any(is_turn_start_message)
}
fn find_projected_cut_point(entries: &[ProjectedEntry<'_>], start: usize, end: usize, keep: u64) -> CutPoint {
let cut_points: Vec<usize> = (start..end)
.filter(|&i| {
source_type(&entries[i]) != Some("compaction") && entries[i].messages.iter().any(is_cut_point_message)
})
.collect();
if cut_points.is_empty() {
return CutPoint {
first_kept_entry_index: start,
turn_start_index: None,
is_split_turn: false,
};
}
let (mut cut, exceeded) = budget_cut(&cut_points, start, end, keep, |i| {
entries[i].messages.iter().map(estimate_tokens).sum()
});
let suffix = entries.get(cut + 1..end).unwrap_or_default();
let visible = |e: &ProjectedEntry<'_>| {
source_type(e) != Some("context_edit") && !session_file::entry_messages(e.source).is_empty()
};
let omitted = |e: &ProjectedEntry<'_>| visible(e) && e.messages.is_empty();
let omitted_ids: HashSet<String> = suffix
.iter()
.filter(|e| omitted(e))
.map(|e| id_key(e.source.get("id")))
.collect();
let external_replacement = suffix.iter().any(|e| {
source_type(e) == Some("context_edit")
&& e.source.get("replacement") != Some(&Value::Null)
&& !omitted_ids.contains(&id_key(e.source.get("targetId")))
});
let recovery_suffix = exceeded
&& !external_replacement
&& suffix.iter().any(|e| {
source_type(e) == Some("message")
&& e.source.get("message").and_then(role) == Some("assistant")
&& omitted(e)
})
&& suffix
.iter()
.all(|e| source_type(e) != Some("compaction") && (!visible(e) || omitted(e)));
if recovery_suffix {
cut += 1;
}
while cut > start {
let previous = &entries[cut - 1];
if source_type(previous) == Some("compaction") || !previous.messages.is_empty() {
break;
}
cut -= 1;
}
let starts_turn = is_projected_turn_start(&entries[cut]);
let turn_start_index = if starts_turn {
None
} else {
(start..=cut).rev().find(|&i| is_projected_turn_start(&entries[i]))
};
CutPoint {
first_kept_entry_index: cut,
turn_start_index,
is_split_turn: !starts_turn && turn_start_index.is_some(),
}
}
fn id_key(value: Option<&Value>) -> String {
value.map_or_else(|| "undefined".to_string(), jsrt::json::stringify)
}
#[derive(Clone, Debug, PartialEq)]
pub struct CompactionPreparation {
pub first_kept_entry_id: String,
pub messages_to_summarize: Vec<Value>,
pub turn_prefix_messages: Vec<Value>,
pub is_split_turn: bool,
pub tokens_before: u64,
pub previous_summary: Option<String>,
pub file_ops: FileOperations,
pub settings: CompactionSettings,
}
fn summary_messages(entries: &[ProjectedEntry<'_>]) -> Vec<Value> {
entries
.iter()
.filter(|e| source_type(e) != Some("compaction"))
.flat_map(|e| e.messages.iter().filter(|m| role(m) != Some("system")).cloned())
.collect()
}
fn add_recorded_files(entry: &Value, ops: &mut FileOperations) {
if jsrt::value::truthy(entry.get("fromHook")) {
return;
}
let Some(details) = entry.get("details").filter(|d| jsrt::value::truthy(Some(d))) else {
return;
};
let files = |key: &str| {
details
.get(key)
.and_then(Value::as_array)
.map_or(&[][..], Vec::as_slice)
.iter()
.filter_map(Value::as_str)
.map(str::to_string)
};
ops.read.extend(files("readFiles"));
ops.edited.extend(files("modifiedFiles"));
}
pub fn prepare_compaction(path_entries: &[Value], settings: CompactionSettings) -> Option<CompactionPreparation> {
if path_entries.last().is_some_and(|e| entry_type(e) == Some("compaction")) {
return None;
}
let projection = build_session_projection(path_entries, Leaf::Last);
let entries = &projection.entries;
let prev_compaction = entries
.iter()
.position(|e| source_type(e) == Some("compaction") && !e.messages.is_empty());
let previous_summary = prev_compaction
.and_then(|i| str_of(entries[i].source, "summary"))
.map(str::to_string);
let boundary_start = prev_compaction.map_or(0, |i| i + 1);
let tokens_before = estimate_projected_context_tokens(&projection, path_entries).tokens;
let cut = find_projected_cut_point(entries, boundary_start, entries.len(), settings.keep_recent_tokens);
let first_kept_entry_id = entries
.get(cut.first_kept_entry_index)
.and_then(|e| str_of(e.source, "id"))
.filter(|id| !id.is_empty())?
.to_string();
let history_end = match cut.turn_start_index {
Some(turn_start) if cut.is_split_turn => turn_start,
_ => cut.first_kept_entry_index,
};
let messages_to_summarize = summary_messages(entries.get(boundary_start..history_end).unwrap_or_default());
let turn_prefix_messages = match cut.turn_start_index {
Some(turn_start) if cut.is_split_turn => summary_messages(&entries[turn_start..cut.first_kept_entry_index]),
_ => Vec::new(),
};
if messages_to_summarize.is_empty() && turn_prefix_messages.is_empty() {
return None;
}
let mut file_ops = FileOperations::default();
if let Some(i) = prev_compaction {
add_recorded_files(entries[i].source, &mut file_ops);
}
for message in messages_to_summarize.iter().chain(&turn_prefix_messages) {
extract_file_ops_from_message(message, &mut file_ops);
}
Some(CompactionPreparation {
first_kept_entry_id,
messages_to_summarize,
turn_prefix_messages,
is_split_turn: cut.is_split_turn,
tokens_before,
previous_summary,
file_ops,
settings,
})
}
const SUMMARIZATION_PROMPT: &str = "The messages above are a conversation to summarize. Create a structured context checkpoint summary that another LLM will use to continue the work.
Use this EXACT format:
## Goal
[What is the user trying to accomplish? Can be multiple items if the session covers different tasks.]
## Constraints & Preferences
- [Any constraints, preferences, or requirements mentioned by user]
- [Or \"(none)\" if none were mentioned]
## Progress
### Done
- [x] [Completed tasks/changes]
### In Progress
- [ ] [Current work]
### Blocked
- [Issues preventing progress, if any]
## Key Decisions
- **[Decision]**: [Brief rationale]
## Next Steps
1. [Ordered list of what should happen next]
## Critical Context
- [Any data, examples, or references needed to continue]
- [Or \"(none)\" if not applicable]
Keep each section concise. Preserve exact file paths, function names, and error messages.";
const UPDATE_SUMMARIZATION_PROMPT: &str = "The messages above are NEW conversation messages to incorporate into the existing summary provided in <previous-summary> tags.
Update the existing structured summary with new information. RULES:
- PRESERVE all existing information from the previous summary
- ADD new progress, decisions, and context from the new messages
- UPDATE the Progress section: move items from \"In Progress\" to \"Done\" when completed
- UPDATE \"Next Steps\" based on what was accomplished
- PRESERVE exact file paths, function names, and error messages
- If something is no longer relevant, you may remove it
Use this EXACT format:
## Goal
[Preserve existing goals, add new ones if the task expanded]
## Constraints & Preferences
- [Preserve existing, add new ones discovered]
## Progress
### Done
- [x] [Include previously done items AND newly completed items]
### In Progress
- [ ] [Current work - update based on progress]
### Blocked
- [Current blockers - remove if resolved]
## Key Decisions
- **[Decision]**: [Brief rationale] (preserve all previous, add new)
## Next Steps
1. [Update based on current state]
## Critical Context
- [Preserve important context, add new if needed]
Keep each section concise. Preserve exact file paths, function names, and error messages.";
const TURN_PREFIX_SUMMARIZATION_PROMPT: &str = "The messages above are earlier context from an ongoing conversation. Later messages are stored separately and do not need to be reconstructed.
Create a concise checkpoint of the user's request and the progress shown above. This checkpoint will be placed before the later messages so the conversation can continue with the necessary context.
## Original Request
[What did the user ask for?]
## Progress So Far
- [Key decisions and work completed in these messages]
## Context Needed to Continue
- [Information from these messages needed to understand the later work]
Only summarize information explicitly present above. Do not infer or recreate later messages.";
#[derive(Clone, Debug, PartialEq)]
pub struct SummaryRequest {
pub context: TranscriptContext,
pub max_tokens: u64,
pub reasoning: Option<String>,
pub session_id: Option<String>,
}
pub(crate) fn summary_context(prompt: String, now_ms: i64) -> TranscriptContext {
normalize_context(&Context {
system_prompt: Some(SUMMARIZATION_SYSTEM_PROMPT.to_string()),
messages: vec![Message::User(UserMessage {
content: UserMessageContent::Blocks(vec![UserContent::Text(TextContent {
text: prompt,
text_signature: None,
})]),
timestamp: now_ms,
})],
tools: None,
})
}
fn summary_max_tokens(fraction: f64, reserve_tokens: u64, model: &Model) -> u64 {
let budget = (fraction * reserve_tokens as f64).floor() as u64;
if model.max_tokens > 0 {
budget.min(model.max_tokens)
} else {
budget
}
}
pub(crate) fn summarization_failure(response: &AssistantMessage, label: &str) -> Option<String> {
match response.stop_reason {
StopReason::Error => Some(format!(
"{label} failed: {}",
response
.error_message
.as_deref()
.filter(|m| !m.is_empty())
.unwrap_or("Unknown error")
)),
StopReason::Length => Some(format!(
"{label} failed: generation hit the token cap and the summary is incomplete"
)),
_ => None,
}
}
fn has_tool_call(response: &AssistantMessage) -> bool {
response
.content
.iter()
.any(|b| matches!(b, AssistantContent::ToolCall(_)))
}
fn response_text(response: &AssistantMessage) -> String {
response
.content
.iter()
.filter_map(|b| match b {
AssistantContent::Text(t) => Some(t.text.as_str()),
_ => None,
})
.collect::<Vec<_>>()
.join("\n")
}
#[derive(Clone, Copy, Debug)]
pub struct CompactOptions<'a> {
pub model: &'a Model,
pub custom_instructions: Option<&'a str>,
pub thinking_level: Option<&'a str>,
pub session_id: Option<&'a str>,
pub now_ms: i64,
}
impl CompactOptions<'_> {
fn request(&self, prompt: String, max_tokens: u64) -> SummaryRequest {
let reasoning = self
.thinking_level
.filter(|level| self.model.reasoning && !level.is_empty() && *level != "off")
.map(str::to_string);
SummaryRequest {
context: summary_context(prompt, self.now_ms),
max_tokens,
reasoning,
session_id: self.session_id.map(str::to_string),
}
}
}
pub fn history_summary_request(
messages: &[Value],
reserve_tokens: u64,
previous_summary: Option<&str>,
options: &CompactOptions<'_>,
) -> SummaryRequest {
let previous = previous_summary.filter(|s| !s.is_empty());
let mut instructions = if previous.is_some() {
UPDATE_SUMMARIZATION_PROMPT
} else {
SUMMARIZATION_PROMPT
}
.to_string();
if let Some(focus) = options.custom_instructions.filter(|s| !s.is_empty()) {
instructions = format!("{instructions}\n\nAdditional focus: {focus}");
}
let conversation = serialize_conversation(&convert_for_summary(messages));
let mut prompt = format!("<conversation>\n{conversation}\n</conversation>\n\n");
if let Some(previous) = previous {
prompt.push_str(&format!("<previous-summary>\n{previous}\n</previous-summary>\n\n"));
}
prompt.push_str(&instructions);
options.request(prompt, summary_max_tokens(0.8, reserve_tokens, options.model))
}
pub fn turn_prefix_request(messages: &[Value], reserve_tokens: u64, options: &CompactOptions<'_>) -> SummaryRequest {
let conversation = serialize_conversation(&convert_for_summary(messages));
let prompt = format!("# Conversation\n{conversation}\n\n# Instructions\n{TURN_PREFIX_SUMMARIZATION_PROMPT}");
turn_prefix_request_of(prompt, reserve_tokens, options)
}
pub fn turn_prefix_request_of(prompt: String, reserve_tokens: u64, options: &CompactOptions<'_>) -> SummaryRequest {
options.request(prompt, summary_max_tokens(0.5, reserve_tokens, options.model))
}
pub const NO_PRIOR_HISTORY: &str = "No prior history.";
pub fn split_turn_summary(history: &str, prefix: &str) -> String {
format!("{history}\n\n---\n\n**Turn Context (split turn):**\n\n{prefix}")
}
#[derive(Clone, Debug, PartialEq)]
pub struct CompactionResult {
pub summary: String,
pub first_kept_entry_id: String,
pub tokens_before: u64,
pub usage: Usage,
pub read_files: Vec<String>,
pub modified_files: Vec<String>,
}
impl CompactionResult {
pub fn entry(&self, retained_tail: Vec<Value>, usage: Value) -> serde_json::Map<String, Value> {
let mut entry = serde_json::Map::new();
entry.insert("type".into(), "compaction".into());
entry.insert("summary".into(), self.summary.clone().into());
entry.insert("retainedTail".into(), Value::Array(retained_tail));
entry.insert("tokensBefore".into(), self.tokens_before.into());
entry.insert(
"details".into(),
serde_json::json!({"readFiles": self.read_files, "modifiedFiles": self.modified_files}),
);
entry.insert("usage".into(), usage);
entry.insert("fromHook".into(), false.into());
entry
}
}
fn combine_usage(first: &Usage, second: &Usage) -> Usage {
let optional =
|a: Option<u64>, b: Option<u64>| (a.is_some() || b.is_some()).then(|| a.unwrap_or(0) + b.unwrap_or(0));
Usage {
input: first.input + second.input,
output: first.output + second.output,
cache_read: first.cache_read + second.cache_read,
cache_write: first.cache_write + second.cache_write,
cache_write_1h: optional(first.cache_write_1h, second.cache_write_1h),
reasoning: optional(first.reasoning, second.reasoning),
total_tokens: first.total_tokens + second.total_tokens,
cost: ai::Cost {
input: first.cost.input + second.cost.input,
output: first.cost.output + second.cost.output,
cache_read: first.cost.cache_read + second.cost.cache_read,
cache_write: first.cost.cache_write + second.cost.cache_write,
total: first.cost.total + second.cost.total,
},
}
}
struct SummaryFailure {
message: String,
too_long: bool,
}
async fn summarize(
request: SummaryRequest,
label: &str,
call: &mut impl AsyncFnMut(SummaryRequest) -> AssistantMessage,
) -> Result<(String, Usage), SummaryFailure> {
let response = call(request).await;
if let Some(message) = summarization_failure(&response, label) {
return Err(SummaryFailure {
message,
too_long: ai::overflow::is_context_overflow(&response),
});
}
if has_tool_call(&response) {
return Err(SummaryFailure {
message: format!("{label} attempted to call a tool"),
too_long: false,
});
}
Ok((response_text(&response), response.usage))
}
fn halfway(messages: &[Value]) -> usize {
let total: u64 = messages.iter().map(estimate_tokens).sum();
let mut seen = 0;
let half = messages.iter().position(|message| {
seen += estimate_tokens(message);
seen * 2 >= total
});
half.map_or(1, |index| index + 1).clamp(1, messages.len() - 1)
}
async fn summarize_parts(
parts: Vec<&[Value]>,
mut previous: Option<String>,
label: &str,
reserve_tokens: u64,
options: &CompactOptions<'_>,
call: &mut impl AsyncFnMut(SummaryRequest) -> AssistantMessage,
) -> Result<(String, Usage), String> {
let mut pending: Vec<&[Value]> = parts.into_iter().rev().collect();
let mut usage: Option<Usage> = None;
while let Some(part) = pending.pop() {
let request = history_summary_request(part, reserve_tokens, previous.as_deref(), options);
match summarize(request, label, call).await {
Ok((text, used)) => {
usage = Some(usage.map_or(used.clone(), |sum| combine_usage(&sum, &used)));
previous = Some(text);
}
Err(failure) if failure.too_long && part.len() > 1 => {
let (first, rest) = part.split_at(halfway(part));
pending.extend([rest, first]);
}
Err(failure) => return Err(failure.message),
}
}
Ok((previous.unwrap_or_default(), usage.unwrap_or_default()))
}
pub async fn compact(
preparation: &CompactionPreparation,
options: &CompactOptions<'_>,
mut call: impl AsyncFnMut(SummaryRequest) -> AssistantMessage,
) -> Result<CompactionResult, String> {
let prep = preparation;
let reserve = prep.settings.reserve_tokens;
let split = prep.is_split_turn && !prep.turn_prefix_messages.is_empty();
let mut previous = prep.previous_summary.clone();
let mut usage = None;
if !split || !prep.messages_to_summarize.is_empty() {
let history = vec![&prep.messages_to_summarize[..]];
let (text, used) = summarize_parts(history, previous, "Summarization", reserve, options, &mut call).await?;
(previous, usage) = (Some(text), Some(used));
}
let plus = |used: Usage| usage.as_ref().map_or(used.clone(), |sum| combine_usage(sum, &used));
let (mut summary, usage) = if split {
const LABEL: &str = "Turn prefix summarization";
let prefix = &prep.turn_prefix_messages[..];
let request = turn_prefix_request(prefix, reserve, options);
match summarize(request, LABEL, &mut call).await {
Ok((prefix_text, used)) => {
let history = previous.unwrap_or_else(|| NO_PRIOR_HISTORY.to_string());
(split_turn_summary(&history, &prefix_text), plus(used))
}
Err(failure) if failure.too_long && prefix.len() > 1 => {
let (first, rest) = prefix.split_at(halfway(prefix));
let (text, used) =
summarize_parts(vec![first, rest], previous, LABEL, reserve, options, &mut call).await?;
(text, plus(used))
}
Err(failure) => return Err(failure.message),
}
} else {
(previous.unwrap_or_default(), usage.unwrap_or_default())
};
let (read_files, modified_files) = compute_file_lists(&prep.file_ops);
summary.push_str(&format_file_operations(&read_files, &modified_files));
Ok(CompactionResult {
summary,
first_kept_entry_id: prep.first_kept_entry_id.clone(),
tokens_before: prep.tokens_before,
usage,
read_files,
modified_files,
})
}