use ai::retry::RetryPolicy;
use serde_json::{Map, Value, json};
use session_journal::ns::{
BRANCH_TIP, ENTRY_LABEL, LANE_CONFIG, LANE_STATE, OP_META, OP_PREPARATION, OP_RESULT, OP_STATE,
};
use session_journal::run::summary::{Scope, SummaryAttempt};
use session_journal::run::{MAIN_LANE, OpAt, default_settings};
use session_journal::{Session, Write};
fn mint(session: &Session) -> String {
session_journal::lock_clock(&session.clock()).next_id()
}
fn now(session: &Session) -> i64 {
session_journal::lock_clock(&session.clock()).now()
}
pub fn prepared_value(
preparation: &compaction::CompactionPreparation,
retained_tail: &[Value],
settings: &Value,
) -> Value {
let file_ops = &preparation.file_ops;
json!({
"kind": "compaction",
"messagesToSummarize": preparation.messages_to_summarize,
"turnPrefixMessages": preparation.turn_prefix_messages,
"retainedTail": retained_tail,
"isSplitTurn": preparation.is_split_turn,
"tokensBefore": preparation.tokens_before,
"fileOps": {"read": file_ops.read, "written": file_ops.written, "edited": file_ops.edited},
"settings": settings,
})
}
pub struct CompactionOp {
kind: &'static str,
target: Option<String>,
label: Option<String>,
label_entry: Option<String>,
operation_id: String,
task_id: String,
pub result_entry_id: String,
summary: Option<SummaryAttempt>,
retry: RetryPolicy,
source_tip: Option<String>,
started_at: i64,
last_operation_id: Value,
inbox: Value,
task: Value,
}
impl CompactionOp {
fn preparation_key(&self) -> String {
format!("{}:{}", self.operation_id, self.task_id)
}
pub fn operation_id(&self) -> &str {
&self.operation_id
}
fn scope(&self, session: &Session) -> Scope {
let control = session
.value(OP_STATE, &self.operation_id)
.map(|state| state["control"].clone())
.filter(Value::is_object)
.unwrap_or_else(|| json!({"status": "running"}));
let mut base = Map::new();
base.insert("control".into(), control);
base.insert("settings".into(), default_settings());
base.insert("latestAssistantEntryId".into(), Value::Null);
Scope {
operation_id: self.operation_id.clone(),
base,
task: self.task.clone(),
}
}
fn state(&self, session: &Session, at: OpAt, extra: Vec<(&str, Value)>) -> Value {
self.scope(session).state(at, extra)
}
fn lane_state(&self, running: bool) -> Value {
if running {
json!({"currentOperationId": self.operation_id, "lastOperationId": self.last_operation_id, "inbox": self.inbox})
} else {
json!({"currentOperationId": null, "lastOperationId": self.operation_id, "inbox": self.inbox})
}
}
pub fn begin(
session: &mut Session,
preparation: &compaction::CompactionPreparation,
retained_tail: &[Value],
custom_instructions: Option<&str>,
) -> Result<CompactionOp, String> {
let operation_id = mint(session);
let task_id = mint(session);
let lane = session.value(LANE_STATE, MAIN_LANE).cloned().unwrap_or(Value::Null);
let mut task = json!({"taskId": task_id, "reason": "manual"});
let mut intent = json!({"kind": "compaction"});
if let Some(instructions) = custom_instructions {
task["customInstructions"] = json!(instructions);
intent["customInstructions"] = json!(instructions);
}
task["boundary"] = json!({"kind": "finish"});
let op = CompactionOp {
kind: "compaction",
target: None,
label: None,
label_entry: None,
source_tip: session.branch_tip(MAIN_LANE).flatten(),
started_at: now(session),
last_operation_id: lane["lastOperationId"].clone(),
inbox: lane.get("inbox").cloned().unwrap_or_else(|| json!([])),
task,
result_entry_id: String::new(),
summary: None,
retry: RetryPolicy::default(),
operation_id,
task_id,
};
let prepared = prepared_value(preparation, retained_tail, &default_settings()["compaction"]);
let meta = json!({
"operationId": op.operation_id, "lane": MAIN_LANE, "sourceTipId": op.source_tip, "startedAt": op.started_at,
"intent": intent,
});
session.commit(&[
Write::set(OP_PREPARATION, &op.preparation_key(), prepared),
Write::set(OP_META, &op.operation_id, meta),
Write::set(
OP_STATE,
&op.operation_id,
op.state(session, OpAt::SummaryDeciding, vec![]),
),
Write::set(LANE_STATE, MAIN_LANE, op.lane_state(true)),
])?;
Ok(op)
}
fn navigation(session: &Session, target: Option<&str>, label: Option<&str>, task: Value) -> CompactionOp {
let lane = session.value(LANE_STATE, MAIN_LANE).cloned().unwrap_or(Value::Null);
CompactionOp {
kind: "navigation",
target: target.map(str::to_string),
label: label.map(str::to_string),
label_entry: target.map(str::to_string),
source_tip: session.branch_tip(MAIN_LANE).flatten(),
started_at: now(session),
last_operation_id: lane["lastOperationId"].clone(),
inbox: lane.get("inbox").cloned().unwrap_or_else(|| json!([])),
task,
result_entry_id: String::new(),
summary: None,
retry: RetryPolicy::default(),
operation_id: String::new(),
task_id: String::new(),
}
}
fn navigation_meta(&self, summarize: bool, custom_instructions: Option<&str>) -> Value {
let mut intent = json!({"kind": "navigation", "targetId": self.target, "summarize": summarize});
if let Some(label) = &self.label {
intent["label"] = json!(label);
}
if let Some(instructions) = custom_instructions {
intent["customInstructions"] = json!(instructions);
}
json!({
"operationId": self.operation_id, "lane": MAIN_LANE, "sourceTipId": self.source_tip,
"startedAt": self.started_at, "intent": intent,
})
}
fn navigation_task(&self, custom_instructions: Option<&str>) -> Value {
let mut task = json!({"taskId": self.task_id});
if let Some(instructions) = custom_instructions {
task["customInstructions"] = json!(instructions);
}
let mut boundary = json!({"kind": "commit_navigation", "targetId": self.target});
if let Some(label) = &self.label {
boundary["label"] = json!(label);
}
task["boundary"] = boundary;
task
}
pub fn begin_navigation(
session: &mut Session,
target: Option<&str>,
preparation: &compaction::BranchPreparation,
custom_instructions: Option<&str>,
label: Option<&str>,
) -> Result<CompactionOp, String> {
let mut op = CompactionOp::navigation(session, target, label, Value::Null);
op.operation_id = mint(session);
op.task_id = mint(session);
op.task = op.navigation_task(custom_instructions);
let ops = &preparation.file_ops;
let prepared = json!({
"kind": "branch_summary", "messages": preparation.messages,
"fileOps": {"read": ops.read, "written": ops.written, "edited": ops.edited},
"totalTokens": preparation.total_tokens,
});
session.commit(&[
Write::set(OP_PREPARATION, &op.preparation_key(), prepared),
Write::set(OP_META, &op.operation_id, op.navigation_meta(true, custom_instructions)),
Write::set(
OP_STATE,
&op.operation_id,
op.state(session, OpAt::SummaryDeciding, vec![]),
),
Write::set(LANE_STATE, MAIN_LANE, op.lane_state(true)),
])?;
Ok(op)
}
pub fn begin_direct_navigation(
session: &mut Session,
target: Option<&str>,
label: Option<&str>,
label_entry: Option<&str>,
) -> Result<CompactionOp, String> {
let mut op = CompactionOp::navigation(session, target, label, Value::Null);
op.label_entry = label_entry.map(str::to_string).or_else(|| op.target.clone());
op.operation_id = mint(session);
let mut extra = vec![("targetId", json!(op.target))];
if let Some(label) = &op.label {
extra.push(("label", json!(label)));
if op.label_entry != op.target {
extra.push(("labelEntryId", json!(op.label_entry)));
}
}
session.commit(&[
Write::set(OP_META, &op.operation_id, op.navigation_meta(false, None)),
Write::set(
OP_STATE,
&op.operation_id,
op.state(session, OpAt::NavigationReadyToCommit, extra),
),
Write::set(LANE_STATE, MAIN_LANE, op.lane_state(true)),
])?;
Ok(op)
}
pub fn commit_navigation(self, session: &mut Session) -> Result<Option<String>, String> {
let mut writes = vec![Write::set(
BRANCH_TIP,
MAIN_LANE,
self.target.clone().map_or(Value::Null, Value::from),
)];
if let (Some(entry), Some(label)) = (&self.label_entry, &self.label) {
writes.push(Write::set(ENTRY_LABEL, entry, label.clone().into()));
}
writes.extend(self.terminal(session, "completed", self.target.as_deref(), None));
session.commit(&writes)?;
Ok(self.target)
}
pub fn complete_navigation(
mut self,
session: &mut Session,
mut entry: Map<String, Value>,
hook_usage: Option<Value>,
) -> Result<String, String> {
if self.result_entry_id.is_empty() {
self.result_entry_id = mint(session);
}
let mut writes: Vec<Write> = hook_usage
.map(|usage| Write::usage(&mint(session), usage, None))
.into_iter()
.collect();
let id = self.result_entry_id.clone();
let target = self.target.clone().map_or(Value::Null, Value::from);
let mut fields = Map::new();
fields.insert("type".into(), "branch_summary".into());
fields.insert(
"fromId".into(),
self.source_tip.clone().map_or(Value::Null, Value::from),
);
fields.append(&mut entry);
writes.extend([
Write::set(BRANCH_TIP, MAIN_LANE, target),
Write::entry(&id, self.target.as_deref(), fields),
Write::set(BRANCH_TIP, MAIN_LANE, id.clone().into()),
]);
if let Some(label) = &self.label {
writes.push(Write::set(ENTRY_LABEL, &id, label.clone().into()));
}
writes.extend(self.terminal(session, "completed", Some(&id), None));
session.commit(&writes)?;
Ok(id)
}
pub fn decline(self, session: &mut Session) -> Result<(), String> {
let writes = self.terminal(session, "declined", self.source_tip.as_deref(), None);
session.commit(&writes).map(drop)
}
pub fn request(&mut self, session: &mut Session, retry: RetryPolicy) -> Result<(), String> {
self.result_entry_id = mint(session);
self.retry = retry;
let configuration = session.value(LANE_CONFIG, MAIN_LANE).cloned().unwrap_or(Value::Null);
let mut attempt = SummaryAttempt::new(&self.result_entry_id, configuration, retry.journal_value());
let scope = self.scope(session);
attempt.start(session, &scope)?;
self.summary = Some(attempt);
Ok(())
}
pub fn task_id(&self) -> &str {
&self.task_id
}
pub fn attempt(&self) -> u64 {
self.summary.as_ref().map_or(1, SummaryAttempt::attempt)
}
pub fn retry_wait(
&mut self,
session: &mut Session,
usage: Option<&Value>,
error: &str,
not_before: i64,
) -> Result<(), String> {
let Some(attempt) = &self.summary else {
return Ok(());
};
let writes = attempt.retry_wait(&self.scope(session), usage, error, not_before);
session.commit(&writes).map(drop)
}
pub fn retry(&mut self, session: &mut Session) -> Result<(), String> {
let scope = self.scope(session);
match self.summary.as_mut() {
Some(attempt) => attempt.retry(session, &scope),
None => Ok(()),
}
}
pub fn record_usage(&self, session: &mut Session, usage: &Value) -> Result<(), String> {
let Some(attempt) = &self.summary else {
return Ok(());
};
let writes = attempt.record_usage(&self.scope(session), usage);
if writes.is_empty() {
return Ok(());
}
session.commit(&writes).map(drop)
}
fn terminal(&self, session: &Session, status: &str, tip: Option<&str>, error: Option<&str>) -> Vec<Write> {
let mut result = json!({
"operationId": self.operation_id, "kind": self.kind, "status": status, "fromTipId": self.source_tip,
"tipId": tip, "startedAt": self.started_at, "endedAt": now(session),
});
if let Some(message) = error {
let code = if self.kind == "compaction" {
"compaction_failed"
} else {
"summarization_failed"
};
result["error"] = json!({"code": code, "message": message});
}
let mut writes = vec![
Write::delete(OP_META, &self.operation_id),
Write::delete(OP_STATE, &self.operation_id),
];
if !self.task.is_null() {
writes.push(Write::delete(OP_PREPARATION, &self.preparation_key()));
}
writes.extend([
Write::set(OP_RESULT, &self.operation_id, result),
Write::set(LANE_STATE, MAIN_LANE, self.lane_state(false)),
]);
writes
}
pub fn complete(self, session: &mut Session, entry: Map<String, Value>) -> Result<String, String> {
let id = self.result_entry_id.clone();
let mut writes = vec![
Write::entry(&id, self.source_tip.as_deref(), entry),
Write::set(BRANCH_TIP, MAIN_LANE, id.clone().into()),
];
writes.extend(self.terminal(session, "completed", Some(&id), None));
session.commit(&writes)?;
Ok(id)
}
pub fn abort(self, session: &mut Session) -> Result<(), String> {
let writes = self.terminal(session, "aborted", self.source_tip.as_deref(), None);
session.commit(&writes).map(drop)
}
pub fn fail(self, session: &mut Session, message: &str) -> Result<(), String> {
let writes = self.terminal(session, "failed", self.source_tip.as_deref(), Some(message));
session.commit(&writes).map(drop)
}
}
pub fn request_cancel(session: &mut Session, requested_at: i64) -> Result<(), String> {
let Some(operation) = session
.value(LANE_STATE, MAIN_LANE)
.and_then(|lane| lane["currentOperationId"].as_str().map(str::to_string))
else {
return Ok(());
};
if session
.value(OP_META, &operation)
.is_none_or(|meta| !matches!(meta["intent"]["kind"].as_str(), Some("compaction" | "navigation")))
{
return Ok(());
}
let Some(mut state) = session.value(OP_STATE, &operation).cloned() else {
return Ok(());
};
if state["control"]["status"] == "cancel_requested" {
return Ok(());
}
state["control"] = json!({"status": "cancel_requested", "requestedAt": requested_at});
session.commit(&[Write::set(OP_STATE, &operation, state)]).map(drop)
}