enact_runner/

compaction.rs

//! Context compaction for long-running agent loops
//!
//! When message history exceeds a threshold, older messages are summarized
//! into a single context message to prevent context window overflow.
//!
//! Ported from zeroclaw's `auto_compact_history` which uses the LLM itself
//! to generate a summary of older conversation history.

use enact_core::callable::Callable;

/// A message in the conversation history.
#[derive(Debug, Clone)]
pub struct HistoryMessage {
    /// Role: "system", "user", "assistant", "tool"
    pub role: String,
    /// Message content
    pub content: String,
}

impl HistoryMessage {
    pub fn system(content: impl Into<String>) -> Self {
        Self {
            role: "system".to_string(),
            content: content.into(),
        }
    }

    pub fn user(content: impl Into<String>) -> Self {
        Self {
            role: "user".to_string(),
            content: content.into(),
        }
    }

    pub fn assistant(content: impl Into<String>) -> Self {
        Self {
            role: "assistant".to_string(),
            content: content.into(),
        }
    }

    pub fn tool_result(name: &str, content: impl Into<String>) -> Self {
        Self {
            role: "tool".to_string(),
            content: format!("[{}]: {}", name, content.into()),
        }
    }
}

/// Check if compaction is needed based on message count.
pub fn needs_compaction(history: &[HistoryMessage], threshold: usize) -> bool {
    history.len() > threshold
}

/// Compact the conversation history by summarizing older messages.
///
/// Keeps the system message (index 0) and the `keep_recent` most recent messages.
/// Everything in between is summarized into a single "context summary" message.
///
/// # Arguments
/// * `history` — mutable reference to the message history
/// * `summarizer` — a Callable used to generate the summary (typically the LLM itself)
/// * `keep_recent` — how many recent messages to preserve verbatim
///
/// # Returns
/// `true` if compaction was performed, `false` if history was too short.
pub async fn compact_history(
    history: &mut Vec<HistoryMessage>,
    summarizer: &dyn Callable,
    keep_recent: usize,
) -> anyhow::Result<bool> {
    // Need at least: system + some old messages + keep_recent
    if history.len() <= keep_recent + 2 {
        return Ok(false);
    }

    // Split: [system] [old messages to summarize] [recent messages to keep]
    let split_point = history.len() - keep_recent;

    // Build a transcript of the old messages (skip system at index 0)
    let old_messages = &history[1..split_point];

    if old_messages.is_empty() {
        return Ok(false);
    }

    let transcript = old_messages
        .iter()
        .map(|m| format!("{}: {}", m.role, m.content))
        .collect::<Vec<_>>()
        .join("\n");

    // Ask the LLM to summarize the old conversation
    let summary_prompt = format!(
        "Summarize the following conversation history into a concise context summary. \
         Preserve key facts, decisions, tool results, and any state that would be needed \
         to continue the conversation. Be concise but complete.\n\n\
         CONVERSATION:\n{}\n\n\
         SUMMARY:",
        transcript
    );

    let summary = summarizer.run(&summary_prompt).await?;

    tracing::info!(
        old_messages = old_messages.len(),
        summary_len = summary.len(),
        "Compacted conversation history"
    );

    // Reconstruct history: [system] [summary] [recent messages]
    let system_msg = history[0].clone();
    let recent_messages: Vec<HistoryMessage> = history[split_point..].to_vec();

    history.clear();
    history.push(system_msg);
    history.push(HistoryMessage {
        role: "system".to_string(),
        content: format!("[Context Summary from earlier conversation]\n{}", summary),
    });
    history.extend(recent_messages);

    Ok(true)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_needs_compaction() {
        let history: Vec<HistoryMessage> = (0..50)
            .map(|i| HistoryMessage::user(format!("msg {}", i)))
            .collect();

        assert!(needs_compaction(&history, 40));
        assert!(!needs_compaction(&history, 50));
        assert!(!needs_compaction(&history, 100));
    }

    #[test]
    fn test_history_message_constructors() {
        let sys = HistoryMessage::system("You are helpful");
        assert_eq!(sys.role, "system");

        let user = HistoryMessage::user("Hello");
        assert_eq!(user.role, "user");

        let asst = HistoryMessage::assistant("Hi there");
        assert_eq!(asst.role, "assistant");

        let tool = HistoryMessage::tool_result("search", "found 5 results");
        assert_eq!(tool.role, "tool");
        assert!(tool.content.contains("[search]"));
    }

    #[tokio::test]
    async fn test_compact_short_history_is_noop() {
        use async_trait::async_trait;

        struct MockSummarizer;

        #[async_trait]
        impl Callable for MockSummarizer {
            fn name(&self) -> &str {
                "mock"
            }
            async fn run(&self, _input: &str) -> anyhow::Result<String> {
                Ok("summary".to_string())
            }
        }

        let mut history = vec![
            HistoryMessage::system("system"),
            HistoryMessage::user("hello"),
        ];

        let result = compact_history(&mut history, &MockSummarizer, 10)
            .await
            .unwrap();
        assert!(!result, "Should not compact when history is short");
        assert_eq!(history.len(), 2);
    }

    #[tokio::test]
    async fn test_compact_long_history() {
        use async_trait::async_trait;

        struct MockSummarizer;

        #[async_trait]
        impl Callable for MockSummarizer {
            fn name(&self) -> &str {
                "mock"
            }
            async fn run(&self, _input: &str) -> anyhow::Result<String> {
                Ok("Summarized: user asked about Rust, assistant explained ownership.".to_string())
            }
        }

        let mut history = vec![HistoryMessage::system("Be helpful")];
        // Add 30 old messages
        for i in 0..30 {
            history.push(HistoryMessage::user(format!("question {}", i)));
            history.push(HistoryMessage::assistant(format!("answer {}", i)));
        }

        let original_len = history.len(); // 61

        let result = compact_history(&mut history, &MockSummarizer, 5)
            .await
            .unwrap();
        assert!(result, "Should have compacted");

        // Should now be: system + summary + 5 recent = 7
        assert_eq!(history.len(), 7);
        assert!(history.len() < original_len);

        // First should still be system
        assert_eq!(history[0].role, "system");
        assert_eq!(history[0].content, "Be helpful");

        // Second should be the context summary
        assert!(history[1].content.contains("[Context Summary"));
    }
}