loopd: compact summary on the background slot

Co-Authored-By: ornith-1.5-35b-a3b <agent@wntrmute.dev>
2026-10-03 00:14:03 -07:00
parent 32e81b51fb
commit c8b0a01c41
4 changed files with 245 additions and 1 deletions
@@ -1,8 +1,34 @@
 //! Compaction: when a session starts a new epoch, the summary call, and writing the next files
-//! (M5d spec, section 3). Later tasks fill the call and the write.
+//! (M5d spec, section 3). Task 07 writes the next files; task 08 calls this after a turn.

+use bxcore::sanitize::neutralise;
 use bxcore::{LogRecord, Usage};

+use crate::baseline::messages_with_carry;
+use crate::config::Config;
+use crate::llama::{ChatMessage, ChatRequest, Client};
+use crate::session::Session;
+use crate::turn::is_context_full;
+
+/// Why a summary call or a next-epoch write failed. Every variant's `Display` ends with the
+/// runbook pointer `session-compact-failed`.
+#[derive(Debug)]
+pub enum CompactError {
+    Failed { detail: String },
+}
+
+impl std::fmt::Display for CompactError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CompactError::Failed { detail } => {
+                write!(f, "{detail}; see docs/runbook.md#session-compact-failed")
+            }
+        }
+    }
+}
+
+impl std::error::Error for CompactError {}
+
 /// True when `cache_n + prompt_n` is at or above `threshold * n_ctx`.
 pub fn due(usage: &Usage, threshold: f64, n_ctx: u64) -> bool {
    let total = usage.cache_n.saturating_add(usage.prompt_n) as f64;
@@ -30,3 +56,37 @@ pub fn fallback_summary(records: &[LogRecord], summary_chars: usize) -> String {
 pub(crate) fn cap_chars(s: &str, n: usize) -> String {
    s.chars().take(n).collect()
 }
+
+/// One completion on the background slot: no tools, thinking on, last user `compact.md`.
+/// Context-full uses `fallback_summary`. A missing prompt, or any other infer error, is
+/// `CompactError::Failed` with the runbook pointer. No fallback for a missing prompt.
+pub fn summarise(cfg: &Config, client: &Client, session: &Session) -> Result<String, CompactError> {
+    let path = cfg.compact_prompt();
+    let prompt = std::fs::read_to_string(&path).map_err(|e| CompactError::Failed {
+        detail: format!("{}: {e}", path.display()),
+    })?;
+    let mut messages = messages_with_carry(session.baseline(), session.records(), session.carry());
+    messages.push(ChatMessage::User {
+        content: prompt.trim_end().to_string(),
+    });
+    let request = ChatRequest {
+        slot: cfg.slots.background,
+        messages,
+        tools: Vec::new(),
+        thinking: true,
+    };
+    match client.chat_with_retry(&request, &mut |_| {}) {
+        Ok(completion) => {
+            let text = completion.content.unwrap_or_default();
+            let text = neutralise(&text);
+            Ok(cap_chars(text.as_ref(), cfg.compact.summary_chars))
+        }
+        Err(e) if is_context_full(&e) => Ok(fallback_summary(
+            session.records(),
+            cfg.compact.summary_chars,
+        )),
+        Err(e) => Err(CompactError::Failed {
+            detail: e.to_string(),
+        }),
+    }
+}
@@ -0,0 +1,147 @@
+//! Tests for the compaction summary call. Do not edit.
+
+mod support;
+
+use bxcore::SessionId;
+use loopd::baseline::Baseline;
+use loopd::compact::{self, CompactError};
+use loopd::llama::Client;
+use loopd::session::Session;
+use loopd::tools::Registry;
+use support::{FakeServer, Home, Reply};
+
+const CHAT: &str = "/v1/chat/completions";
+const PROMPT: &str = "Summarise this conversation for the next epoch.\n";
+
+fn sse(content: &str, cache_n: u64, prompt_n: u64) -> Reply {
+    let content_json = serde_json::to_string(content).unwrap();
+    let data1 = format!(
+        r#"data: {{"choices":[{{"finish_reason":null,"index":0,"delta":{{"content":{content_json}}}}}],"id":"sum","timings":{{"cache_n":{cache_n},"prompt_n":{prompt_n},"predicted_n":1}}}}"#
+    );
+    let data2 = format!(
+        r#"data: {{"choices":[{{"finish_reason":"stop","index":0,"delta":{{}}}}],"id":"sum","timings":{{"cache_n":{cache_n},"prompt_n":{prompt_n},"predicted_n":1}}}}"#
+    );
+    let body = format!("{data1}\n\n{data2}\n\ndata: [DONE]\n\n");
+    Reply::raw(format!(
+        "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
+        body.len()
+    ))
+}
+
+fn session(home: &Home, cfg: &loopd::config::Config) -> Session {
+    let baseline = Baseline::assemble(cfg, &Registry::m2b()).unwrap();
+    Session::create(
+        &home.dir,
+        SessionId::new("a").unwrap(),
+        baseline,
+        cfg.slots.main,
+    )
+    .unwrap()
+}
+
+#[test]
+fn the_summary_call_is_on_the_background_slot_with_no_tools_and_thinking() {
+    let home = Home::new();
+    home.write("compact.md", PROMPT);
+    let server = FakeServer::start();
+    let cfg = home.config(&server.socket);
+    server.route(CHAT, vec![sse("the sum", 0, 10)]);
+    let client = Client::new(cfg.clone());
+    let s = session(&home, &cfg);
+    let text = compact::summarise(&cfg, &client, &s).unwrap();
+    assert_eq!(text, "the sum");
+    let sent = server.requests_to(CHAT);
+    assert_eq!(sent.len(), 1);
+    let body = sent[0].json();
+    assert_eq!(body["id_slot"], 1);
+    assert!(body.get("tools").is_none(), "{body}");
+    assert_eq!(body["chat_template_kwargs"]["enable_thinking"], true);
+    let messages = body["messages"].as_array().unwrap();
+    let last = messages.last().unwrap();
+    assert_eq!(last["role"], "user");
+    assert_eq!(last["content"], PROMPT.trim_end());
+}
+
+#[test]
+fn the_summary_is_neutralised_and_capped() {
+    let home = Home::new();
+    home.write("compact.md", PROMPT);
+    let server = FakeServer::start();
+    let mut cfg = home.config(&server.socket);
+    cfg.compact.summary_chars = 4;
+    server.route(CHAT, vec![sse("abcdefghij", 0, 10)]);
+    let client = Client::new(cfg.clone());
+    let s = session(&home, &cfg);
+    let text = compact::summarise(&cfg, &client, &s).unwrap();
+    assert_eq!(text, "abcd");
+}
+
+#[test]
+fn a_context_full_summary_uses_the_fallback() {
+    let home = Home::new();
+    home.write("compact.md", PROMPT);
+    let server = FakeServer::start();
+    let cfg = home.config(&server.socket);
+    server.route(CHAT, vec![Reply::fixture("context_full")]);
+    let client = Client::new(cfg.clone());
+    let mut s = session(&home, &cfg);
+    s.append(bxcore::LogRecord::User {
+        time: bxcore::Timestamp::parse("2026-09-18T08:00:00.000Z").unwrap(),
+        content: "remember the tea".to_string(),
+        speaker: None,
+    })
+    .unwrap();
+    let text = compact::summarise(&cfg, &client, &s).unwrap();
+    assert_eq!(text, "remember the tea");
+}
+
+#[test]
+fn tags_in_the_completion_are_neutralised() {
+    let home = Home::new();
+    home.write("compact.md", PROMPT);
+    let server = FakeServer::start();
+    let cfg = home.config(&server.socket);
+    let tag = concat!("<", "think", ">");
+    server.route(CHAT, vec![sse(&format!("hello {tag} world"), 0, 10)]);
+    let client = Client::new(cfg.clone());
+    let s = session(&home, &cfg);
+    let text = compact::summarise(&cfg, &client, &s).unwrap();
+    assert!(!text.contains(tag), "{text}");
+    assert!(text.contains("hello"), "{text}");
+}
+
+#[test]
+fn a_missing_prompt_file_names_the_runbook() {
+    let home = Home::new();
+    let server = FakeServer::start();
+    let cfg = home.config(&server.socket);
+    let client = Client::new(cfg.clone());
+    let s = session(&home, &cfg);
+    let err = compact::summarise(&cfg, &client, &s).unwrap_err();
+    let e: Box<dyn std::error::Error> = Box::new(err);
+    assert!(e.to_string().contains("compact.md"), "{e}");
+    assert!(
+        e.to_string()
+            .ends_with("see docs/runbook.md#session-compact-failed"),
+        "{e}"
+    );
+}
+
+#[test]
+fn an_inference_error_that_is_not_context_full_is_a_compact_failure() {
+    let home = Home::new();
+    home.write("compact.md", PROMPT);
+    let server = FakeServer::start();
+    let cfg = home.config(&server.socket);
+    server.route(CHAT, vec![Reply::fixture("bad_request")]);
+    let client = Client::new(cfg.clone());
+    let s = session(&home, &cfg);
+    let err = compact::summarise(&cfg, &client, &s).unwrap_err();
+    assert!(matches!(err, CompactError::Failed { .. }), "{err:?}");
+    let e: Box<dyn std::error::Error> = Box::new(err);
+    assert!(
+        e.to_string()
+            .ends_with("see docs/runbook.md#session-compact-failed"),
+        "{e}"
+    );
+}