Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
68 changes: 62 additions & 6 deletions src/apps/cli/tests/cli_command_contracts/exec_cli_contracts.rs
Original file line number Diff line number Diff line change
Expand Up @@ -491,13 +491,21 @@ fn stream_json_malformed_sse_retries_then_completes() {

#[test]
fn stream_json_context_overflow_compresses_before_reissuing_the_model_request() {
use std::io::{Seek, Write};

let server = MockOpenAiServer::context_overflow_then_immediate();
let environment = CliTestEnvironment::new();
environment.configure_mock_model(server.base_url());
// This log exceeds the verbatim user-message retention budget, but fits
// the model's input budget so only the provider's 400 triggers recovery.
const LOG_LINE: &str = "Recovery fixture: processed one queue entry.\n";
let mut log = tempfile::tempfile().expect("create input log");
log.write_all(LOG_LINE.repeat(1_600).as_bytes()).unwrap();
log.rewind().unwrap();
let mut command = environment.std_command();
command.args([
command.stdin(log).args([
"exec",
"Remember this request and continue after context recovery",
"Summarize the following queue log",
"--output-format",
"stream-json",
]);
Expand All @@ -511,10 +519,12 @@ fn stream_json_context_overflow_compresses_before_reissuing_the_model_request()
requests[0]["messages"], requests[1]["messages"],
"overflow must enter compression instead of replaying the original request"
);
assert_ne!(
requests[0]["messages"], requests[2]["messages"],
"recovery must send the compressed context"
);
let log_marker = LOG_LINE.trim_end();
assert!(requests[0]["messages"].to_string().contains(log_marker));
assert!(requests[1]["messages"].to_string().contains(log_marker));
let recovered = requests[2]["messages"].to_string();
assert!(recovered.contains(STREAM_COMPLETED_MARKER));
assert!(!recovered.contains(log_marker));
let events = jsonl_events(&stdout);
let compression_started = events
.iter()
Expand All @@ -528,6 +538,11 @@ fn stream_json_context_overflow_compresses_before_reissuing_the_model_request()
.position(|value| value["event"]["type"] == "ContextCompressionCompleted")
.expect("recovery compression should complete");
assert!(compression_started < compression_completed);
let completed = &events[compression_completed]["event"];
assert_eq!(completed["applied"], true);
assert!(
completed["tokens_after"].as_u64().unwrap() < completed["tokens_before"].as_u64().unwrap()
);
assert_eq!(
events
.iter()
Expand All @@ -541,6 +556,47 @@ fn stream_json_context_overflow_compresses_before_reissuing_the_model_request()
);
}

#[test]
fn stream_json_context_overflow_preserves_provider_error_when_compression_cannot_help() {
let server = MockOpenAiServer::context_overflow_then_immediate();
let environment = CliTestEnvironment::new();
environment.configure_mock_model(server.base_url());
let mut command = environment.std_command();
command.args([
"exec",
"Remember this request",
"--output-format",
"stream-json",
]);
let output = command_output_with_timeout(&mut command, std::time::Duration::from_secs(30));
assert_eq!(output.status.code(), Some(1), "{}", stderr(&output));
server.assert_chat_completion_requests(1);

let events = jsonl_events(&stdout(&output));
let completed = events
.iter()
.map(|value| &value["event"])
.find(|event| event["type"] == "ContextCompressionCompleted")
.expect("recovery should report that compression was skipped");
assert_eq!(completed["applied"], false);
assert_eq!(completed["compression_count"], 0);
assert_eq!(completed["tokens_after"], completed["tokens_before"]);
assert_eq!(
events
.iter()
.filter(|value| is_terminal_event(value))
.count(),
1
);
let terminal = &events.last().unwrap()["event"];
assert_eq!(terminal["type"], "DialogTurnFailed");
assert_eq!(terminal["error_category"], "context_overflow");
assert_eq!(
terminal["error_detail"]["providerCode"],
"context_length_exceeded"
);
}

#[test]
fn stream_json_provider_http_403_emits_one_error_terminal() {
let server = MockOpenAiServer::http_403("provider authorization denied");
Expand Down
69 changes: 57 additions & 12 deletions src/crates/assembly/core/src/agentic/execution/compression_job.rs
Original file line number Diff line number Diff line change
Expand Up @@ -28,7 +28,7 @@ impl Drop for PrefetchObservation {
}

pub(super) struct PrefetchedCompression {
task: CompressionPrefetch<CompressionCandidate, OpenBitFunError>,
task: CompressionPrefetch<Option<CompressionCandidate>, OpenBitFunError>,
source_message_ids: Vec<String>,
request_identity: serde_json::Value,
observation: PrefetchObservation,
Expand All @@ -38,7 +38,7 @@ impl PrefetchedCompression {
pub(super) fn claim(
mut self,
input: &CompressionModelSummaryInput<'_>,
) -> PrefetchClaim<CompressionCandidate, OpenBitFunError> {
) -> PrefetchClaim<Option<CompressionCandidate>, OpenBitFunError> {
let latest = ContextCompressor::canonical_conversation(input.runtime_messages);
self.observation.claimed = true;
let request_matches = self.request_identity == CompressionJob::request_identity(input);
Expand Down Expand Up @@ -119,8 +119,14 @@ pub(super) struct CompressionJob {
}

impl CompressionJob {
pub(super) fn spawn_prefetch(self, parent: &CancellationToken) -> PrefetchedCompression {
self.spawn_prefetch_with(parent, |job| job.run())
pub(super) fn spawn_prefetch(
self,
parent: &CancellationToken,
contract: Option<crate::agentic::core::CompressionContract>,
) -> PrefetchedCompression {
self.spawn_prefetch_with(parent, move |job| async move {
job.run_automatic(contract.as_ref()).await
})
}

pub(super) fn spawn_prefetch_with<F, Fut>(
Expand All @@ -130,7 +136,9 @@ impl CompressionJob {
) -> PrefetchedCompression
where
F: FnOnce(Self) -> Fut + Send + 'static,
Fut: std::future::Future<Output = OpenBitFunResult<CompressionCandidate>> + Send + 'static,
Fut: std::future::Future<Output = OpenBitFunResult<Option<CompressionCandidate>>>
+ Send
+ 'static,
{
let source_message_ids = ContextCompressor::canonical_conversation(&self.messages)
.map(|message| message.id.clone())
Expand Down Expand Up @@ -162,7 +170,7 @@ impl CompressionJob {
info!(
"Compression prefetch finished: prefetch_id={}, session_id={}, turn_id={}, outcome={}, duration_ms={}",
id, session_id, turn_id,
if result.is_ok() { "success" } else { "failed" },
match &result { Ok(Some(_)) => "ready", Ok(None) => "no_gain", Err(_) => "failed" },
elapsed_ms_u64(started_at)
);
result
Expand Down Expand Up @@ -246,7 +254,24 @@ impl CompressionJob {
.await
}

pub(super) async fn run(self) -> OpenBitFunResult<CompressionCandidate> {
pub(super) async fn run_manual(self) -> OpenBitFunResult<CompressionCandidate> {
self.prepare(false, None).await?.ok_or_else(|| {
OpenBitFunError::AIClient("Context compression has no eligible plan".into())
})
}

pub(super) async fn run_automatic(
self,
contract: Option<&crate::agentic::core::CompressionContract>,
) -> OpenBitFunResult<Option<CompressionCandidate>> {
self.prepare(true, contract).await
}

async fn prepare(
self,
require_savings: bool,
contract: Option<&crate::agentic::core::CompressionContract>,
) -> OpenBitFunResult<Option<CompressionCandidate>> {
let session_id = self.session_id.as_str();
let dialog_turn_id = self.turn_id.as_str();
let runtime_messages = self.messages.as_slice();
Expand All @@ -265,9 +290,7 @@ impl CompressionJob {
recent_target,
)?
else {
return Err(OpenBitFunError::AIClient(
"Context compression has no eligible plan".to_string(),
));
return Ok(None);
};
if previous_cutoff.is_some_and(|cutoff| plan.cutoff_message_index >= cutoff) {
return Err(OpenBitFunError::AIClient(
Expand All @@ -291,15 +314,37 @@ impl CompressionJob {
plan.recent_tail_messages.len()
);

if require_savings {
// The leading system prompt, tools and prepended reminders are
// common to both requests. Compare only the replaceable history.
let system_count = runtime_messages
.iter()
.take_while(|message| message.role == MessageRole::System)
.count();
let original = ExecutionEngine::estimate_request_tokens_internal(
&runtime_messages[system_count..],
None,
);
let minimum = self
.compressor
.minimum_replacement(&plan, contract.cloned());
let floor =
ExecutionEngine::estimate_request_tokens_internal(&minimum.messages, None);
if floor >= original {
debug!("Skipping compression summary: session_id={}, history_tokens={}, minimum_replacement_tokens={}", session_id, original, floor);
return Ok(None);
}
}

let summary_result = self.request_summary(&plan.summary_request_messages).await;

match summary_result {
Ok(summary) => {
return Ok(CompressionCandidate {
return Ok(Some(CompressionCandidate {
plan,
summary,
request_identity: self.request_identity.clone(),
});
}));
}
Err(err) if err.is_recoverable_context_overflow() => {
warn!(
Expand Down
Loading
Loading