Struct ToolResultCompressor 

pub struct ToolResultCompressor;

Stateless tool-result compressor for Acon (#4021).

All methods are pure functions: they take text, a token counter, and a config, and return compressed text with metadata. No I/O, no async, no agent state.

Examples

use zeph_context::tool_result_compress::{
    ToolResultCompressor, ToolResultCompressionConfig, CompressionMethod,
};

struct WordCounter;
impl zeph_common::memory::TokenCounting for WordCounter {
    fn count_tokens(&self, text: &str) -> usize { text.split_whitespace().count() }
    fn count_tool_schema_tokens(&self, _schema: &serde_json::Value) -> usize { 0 }
}

let config = ToolResultCompressionConfig {
    passthrough_threshold: 5,
    summarize_threshold: 10,
    total_budget: 20,
};
let tc = WordCounter;

let result = ToolResultCompressor::compress_single("hello world", &tc, &config);
assert_eq!(result.method, CompressionMethod::PassThrough);

Implementations

impl ToolResultCompressor

pub fn compress_single( text: &str, tc: &dyn TokenCounting, config: &ToolResultCompressionConfig, ) -> CompressedToolResult

Compress a single tool result text.

• Below passthrough_threshold tokens: returned unchanged.
• At or above passthrough_threshold tokens: char-truncated so that the truncated text has approximately passthrough_threshold tokens (using a char-boundary-safe cut at passthrough_threshold * 4 bytes), with " [...truncated]" appended.

Examples

use zeph_context::tool_result_compress::{
    ToolResultCompressor, ToolResultCompressionConfig, CompressionMethod,
};

struct WordCounter;
impl zeph_common::memory::TokenCounting for WordCounter {
    fn count_tokens(&self, text: &str) -> usize { text.split_whitespace().count() }
    fn count_tool_schema_tokens(&self, _schema: &serde_json::Value) -> usize { 0 }
}

let config = ToolResultCompressionConfig {
    passthrough_threshold: 3,
    summarize_threshold: 10,
    total_budget: 20,
};
let tc = WordCounter;

// Short text passes through.
let r = ToolResultCompressor::compress_single("one two three", &tc, &config);
assert_eq!(r.method, CompressionMethod::PassThrough);

// Long text is truncated.
let r = ToolResultCompressor::compress_single("one two three four five", &tc, &config);
assert_eq!(r.method, CompressionMethod::Truncated);
assert!(r.text.ends_with("[...truncated]"));

pub fn compress_batch( entries: &[ToolResultEntry<'_>], tc: &dyn TokenCounting, config: &ToolResultCompressionConfig, ) -> Vec<CompressedToolResult>

Compress a batch of tool results, enforcing both per-result and total-budget limits.

1. Applies compress_single to each entry.
2. If the total compressed tokens still exceed total_budget, trims results in descending token-count order. Ties are broken by entry.index (lower index trimmed first) for deterministic output.

Returns one CompressedToolResult per input entry, in the same order.

Examples

use zeph_context::tool_result_compress::{
    ToolResultCompressor, ToolResultCompressionConfig, ToolResultEntry, CompressionMethod,
};

struct WordCounter;
impl zeph_common::memory::TokenCounting for WordCounter {
    fn count_tokens(&self, text: &str) -> usize { text.split_whitespace().count() }
    fn count_tool_schema_tokens(&self, _schema: &serde_json::Value) -> usize { 0 }
}

let config = ToolResultCompressionConfig {
    passthrough_threshold: 100,
    summarize_threshold: 200,
    total_budget: 5,
};
let tc = WordCounter;
let entries = vec![
    ToolResultEntry { tool_name: "shell", text: "one two three", index: 0 },
    ToolResultEntry { tool_name: "fetch", text: "four five six", index: 1 },
];
let results = ToolResultCompressor::compress_batch(&entries, &tc, &config);
assert_eq!(results.len(), 2);
// Combined tokens (6) exceed total_budget (5) → at least one is BatchTrimmed.
assert!(results.iter().any(|r| r.method == CompressionMethod::BatchTrimmed));