From e4aea996c17e6bc2621752759d10a5c68cb2adc2 Mon Sep 17 00:00:00 2001 From: wsp Date: Fri, 20 Nov 2026 14:27:20 +0800 Subject: [PATCH] fix(agent): Require token savings for automatic compression Skip summary requests when the retained history already rules out token savings. Compare the full candidate against the latest context before replacing it so an oversized summary cannot grow the session history. Reconsider skipped compression when the history or model budget changes. Refs: #4007 --- .../exec_cli_contracts.rs | 68 ++++- .../src/agentic/execution/compression_job.rs | 69 ++++- .../execution/compression_lifecycle.rs | 243 +++++++++++++----- .../agentic/execution/compression_tests.rs | 162 +++++++++++- .../src/agentic/execution/execution_engine.rs | 104 +++++++- .../agentic/session/compression/compressor.rs | 46 +++- 6 files changed, 580 insertions(+), 112 deletions(-) diff --git a/src/apps/cli/tests/cli_command_contracts/exec_cli_contracts.rs b/src/apps/cli/tests/cli_command_contracts/exec_cli_contracts.rs index 7fabfae5b1..815862fdf3 100644 --- a/src/apps/cli/tests/cli_command_contracts/exec_cli_contracts.rs +++ b/src/apps/cli/tests/cli_command_contracts/exec_cli_contracts.rs @@ -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", ]); @@ -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() @@ -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() @@ -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"); diff --git a/src/crates/assembly/core/src/agentic/execution/compression_job.rs b/src/crates/assembly/core/src/agentic/execution/compression_job.rs index b04641c96e..f6b4967c45 100644 --- a/src/crates/assembly/core/src/agentic/execution/compression_job.rs +++ b/src/crates/assembly/core/src/agentic/execution/compression_job.rs @@ -28,7 +28,7 @@ impl Drop for PrefetchObservation { } pub(super) struct PrefetchedCompression { - task: CompressionPrefetch, + task: CompressionPrefetch, OpenBitFunError>, source_message_ids: Vec, request_identity: serde_json::Value, observation: PrefetchObservation, @@ -38,7 +38,7 @@ impl PrefetchedCompression { pub(super) fn claim( mut self, input: &CompressionModelSummaryInput<'_>, - ) -> PrefetchClaim { + ) -> PrefetchClaim, OpenBitFunError> { let latest = ContextCompressor::canonical_conversation(input.runtime_messages); self.observation.claimed = true; let request_matches = self.request_identity == CompressionJob::request_identity(input); @@ -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, + ) -> PrefetchedCompression { + self.spawn_prefetch_with(parent, move |job| async move { + job.run_automatic(contract.as_ref()).await + }) } pub(super) fn spawn_prefetch_with( @@ -130,7 +136,9 @@ impl CompressionJob { ) -> PrefetchedCompression where F: FnOnce(Self) -> Fut + Send + 'static, - Fut: std::future::Future> + Send + 'static, + Fut: std::future::Future>> + + Send + + 'static, { let source_message_ids = ContextCompressor::canonical_conversation(&self.messages) .map(|message| message.id.clone()) @@ -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 @@ -246,7 +254,24 @@ impl CompressionJob { .await } - pub(super) async fn run(self) -> OpenBitFunResult { + pub(super) async fn run_manual(self) -> OpenBitFunResult { + 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> { + self.prepare(true, contract).await + } + + async fn prepare( + self, + require_savings: bool, + contract: Option<&crate::agentic::core::CompressionContract>, + ) -> OpenBitFunResult> { let session_id = self.session_id.as_str(); let dialog_turn_id = self.turn_id.as_str(); let runtime_messages = self.messages.as_slice(); @@ -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( @@ -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!( diff --git a/src/crates/assembly/core/src/agentic/execution/compression_lifecycle.rs b/src/crates/assembly/core/src/agentic/execution/compression_lifecycle.rs index 0a679c19ba..bbe7f99de9 100644 --- a/src/crates/assembly/core/src/agentic/execution/compression_lifecycle.rs +++ b/src/crates/assembly/core/src/agentic/execution/compression_lifecycle.rs @@ -2,6 +2,38 @@ //! allowed to run hooks, publish product events and commit session context. use super::*; +use crate::agentic::session::session_manager::CompressionTranscriptReference; + +#[derive(Debug)] +pub(super) enum AutoCompressionOutcome { + Applied(usize, Vec), + NoGain(Vec), +} + +enum CompressionCommit { + Unchanged(Vec), + Applied { + result: crate::agentic::session::CompressionResult, + before: TokenPressureSnapshot, + after: TokenPressureSnapshot, + }, +} + +enum CandidateDecision { + Replan(Vec), + PrepareTranscript, + Finish(CompressionCommit), +} + +impl CandidateDecision { + fn without_savings(latest: Vec, history_grew: bool) -> Self { + if history_grew { + Self::Replan(latest) + } else { + Self::Finish(CompressionCommit::Unchanged(latest)) + } + } +} impl ExecutionEngine { #[allow(clippy::too_many_arguments)] @@ -39,7 +71,7 @@ impl ExecutionEngine { trace_config, }, ); - let candidate = job.run().await?; + let candidate = job.run_manual().await?; self.context_compressor .compress_plan_with_contract( session_id, @@ -68,7 +100,7 @@ impl ExecutionEngine { workspace: Option<&WorkspaceBinding>, workspace_services: Option<&crate::agentic::workspace::WorkspaceServices>, prefetch: Option, - ) -> OpenBitFunResult)>> { + ) -> OpenBitFunResult { let mut session = self .session_manager .get_session(session_id) @@ -86,7 +118,7 @@ impl ExecutionEngine { .iter() .any(|message| message.role != MessageRole::System) { - return Ok(None); + return Ok(AutoCompressionOutcome::NoGain(runtime_messages)); } // Generate compression ID let compression_id = format!("compression_{}", uuid::Uuid::new_v4()); @@ -163,46 +195,69 @@ impl ExecutionEngine { ai_client.as_ref(), ) .await; - let candidate = match claim { - Some(openbitfun_agent_runtime::compression_prefetch::PrefetchClaim::Ready(candidate)) => Some(candidate), - Some(openbitfun_agent_runtime::compression_prefetch::PrefetchClaim::Waiting(task)) => { - Some(task.wait().await.map_err(|_| OpenBitFunError::AIClient( - "Compression prefetch worker stopped before publishing a result".into() - ))??) - } + let prefetched = match claim { + Some(openbitfun_agent_runtime::compression_prefetch::PrefetchClaim::Ready( + candidate, + )) => candidate, + Some(openbitfun_agent_runtime::compression_prefetch::PrefetchClaim::Waiting( + task, + )) => task.wait().await.map_err(|_| { + OpenBitFunError::AIClient( + "Compression prefetch worker stopped before publishing a result".into(), + ) + })??, _ => None, }; - let is_prefetched = candidate.is_some(); - let candidate = match candidate { - Some(candidate) => candidate, - None => CompressionJob::new(self.context_compressor.clone(), session_id, - context_window, ContextCompressor::DEFAULT_RECENT_CONTEXT_TOKENS, - CompressionModelSummaryInput { - ai_client: ai_client.clone(), model_request_context, - runtime_messages: &runtime_messages, dialog_turn_id, workspace, workspace_services, - tool_definitions, prepended_prompt_reminders, primary_supports_image_understanding, - trace_config: trace_config.clone(), - }).run().await?, - }; - let boundary_turn_index = self.session_manager.get_turn_count(session_id).saturating_sub(1); - let transcript = match self.session_manager.create_compression_transcript_reference( - session_id, boundary_turn_index, &compression_id, trigger, - ).await { - Ok(reference) => reference, - Err(error) => { - warn!("Failed to create automatic compression transcript: session_id={}, error={}", session_id, error); - None + let is_prefetched = prefetched.is_some(); + let candidate = match prefetched { + Some(candidate) => Some(candidate), + None => { + CompressionJob::new( + self.context_compressor.clone(), + session_id, + context_window, + ContextCompressor::DEFAULT_RECENT_CONTEXT_TOKENS, + CompressionModelSummaryInput { + ai_client: ai_client.clone(), + model_request_context, + runtime_messages: &runtime_messages, + dialog_turn_id, + workspace, + workspace_services, + tool_definitions, + prepended_prompt_reminders, + primary_supports_image_understanding, + trace_config: trace_config.clone(), + }, + ) + .run_automatic(compression_contract.as_ref()) + .await? } }; - Ok((Some(candidate), is_prefetched, compression_contract, trace_config, transcript)) + Ok((candidate, is_prefetched, compression_contract, trace_config)) }) .await; // Only the owner commits. Rebase against the latest canonical suffix // under the append lock; never install the background snapshot's tail. let mut commit_guard = None; + let reminder_tokens = Self::prepended_reminder_tokens_for_pressure( + &prepended_prompt_reminders.ordered_reminders(), + ); + let estimate = |messages: &[Message]| { + Self::estimate_auto_compression_pressure( + messages, + tool_definitions.as_deref(), + before_pressure.trigger_budget(), + reminder_tokens, + ) + }; let planned_result = match planned_result { Err(error) => Err(error), - Ok((mut candidate, mut is_prefetched, contract, trace_config, transcript)) => { + Ok((mut candidate, mut is_prefetched, contract, trace_config)) => { + let mut transcript: Option = None; + let mut transcript_checked = + !self.session_manager.should_persist_session_id(session_id); + let mut planned_message_count = runtime_messages.len(); async { loop { let guard = self @@ -221,17 +276,17 @@ impl ExecutionEngine { "Compression execution owner changed".into(), )); } - let mut latest_runtime = Vec::new(); let result = self.session_manager.transform_compression_context( session_id, |latest| { - latest_runtime = compression_job::merge_latest_context( + let latest_runtime = compression_job::merge_latest_context( &runtime_messages, &canonical_snapshot, latest, )?; let Some(candidate) = candidate.as_ref() else { - return Ok((None, None)); + let grew = latest_runtime.len() > planned_message_count; + return Ok((None, CandidateDecision::without_savings(latest_runtime, grew))); }; let identity = CompressionJob::request_identity( &CompressionModelSummaryInput { @@ -248,7 +303,7 @@ impl ExecutionEngine { }, ); if candidate.request_identity != identity { - return Ok((None, None)); + return Ok((None, CandidateDecision::Replan(latest_runtime))); } let Some(plan) = self.context_compressor.rebase_plan( candidate.plan.clone(), @@ -256,8 +311,9 @@ impl ExecutionEngine { dialog_turn_id, )? else { - return Ok((None, None)); + return Ok((None, CandidateDecision::Replan(latest_runtime))); }; + let suffix_grew = plan.recent_tail_messages.len() > candidate.plan.recent_tail_messages.len(); let mut result = self.context_compressor.compress_plan_with_contract( session_id, @@ -274,32 +330,60 @@ impl ExecutionEngine { } let mut preview = vec![system_prompt_message.clone()]; preview.extend(result.messages.clone()); - let pressure = Self::estimate_auto_compression_pressure( - &preview, - tool_definitions.as_deref(), - before_pressure.trigger_budget(), - Self::prepended_reminder_tokens_for_pressure( - &prepended_prompt_reminders.ordered_reminders(), - ), - ); + let pressure = estimate(&preview); + let original = estimate(&latest_runtime); + if pressure.total_tokens >= original.total_tokens { + info!("Discarding compression without token savings: session_id={}, before={}, candidate={}", session_id, original.total_tokens, pressure.total_tokens); + return Ok((None, CandidateDecision::without_savings(latest_runtime, suffix_grew))); + } if is_prefetched && pressure.total_tokens >= pressure.input_limit { - return Ok((None, None)); + return Ok((None, CandidateDecision::Replan(latest_runtime))); + } + if !transcript_checked { + return Ok((None, CandidateDecision::PrepareTranscript)); } if cancellation_token.is_cancelled() { return Err(OpenBitFunError::Cancelled( "Context compaction cancelled".into(), )); } - Ok((Some(result.messages.clone()), Some(result))) + let replacement = result.messages.clone(); + let commit = CompressionCommit::Applied { + result, + before: original, + after: pressure, + }; + Ok((Some(replacement), CandidateDecision::Finish(commit))) }, )?; - if let Some(result) = result { - // Keep session mutations fenced through persistence - // and counter/cache updates. - commit_guard = Some(guard); - return Ok(Some(result)); - } + let latest_runtime = match result { + CandidateDecision::Finish(outcome) => { + if matches!(outcome, CompressionCommit::Applied { .. }) { + commit_guard = Some(guard); + } + return Ok(outcome); + } + CandidateDecision::PrepareTranscript => { + drop(guard); + let boundary = self.session_manager.get_turn_count(session_id).saturating_sub(1); + let create_reference = self.session_manager.create_compression_transcript_reference( + session_id, boundary, &compression_id, trigger, + ); + transcript = match prepare_compression_cancellable(&cancellation_token, create_reference).await { + Ok(reference) => reference, + Err(error @ OpenBitFunError::Cancelled(_)) => return Err(error), + Err(error) => { + warn!("Failed to create automatic compression transcript: session_id={}, error={}", session_id, error); + None + } + }; + transcript_checked = true; + continue; + } + CandidateDecision::Replan(latest) => latest, + }; drop(guard); + planned_message_count = latest_runtime.len(); let job = CompressionJob::new( self.context_compressor.clone(), session_id, @@ -318,9 +402,7 @@ impl ExecutionEngine { trace_config: trace_config.clone(), }, ); - candidate = Some( - prepare_compression_cancellable(&cancellation_token, job.run()).await?, - ); + candidate = prepare_compression_cancellable(&cancellation_token, job.run_automatic(contract.as_ref())).await?; is_prefetched = false; } } @@ -330,7 +412,11 @@ impl ExecutionEngine { // Once the synchronous replacement wins admission, persistence must not // be dropped halfway through by cancellation. match planned_result { - Ok(Some(compression_result)) => { + Ok(CompressionCommit::Applied { + result: compression_result, + before: before_pressure, + after: after_pressure, + }) => { self.session_manager .persist_compression_context(session_id, &compression_result.messages) .await; @@ -365,16 +451,6 @@ impl ExecutionEngine { // Calculate duration let duration_ms = elapsed_ms_u64(start_time); - // Recalculate tokens after compression - let prepended_reminders = prepended_prompt_reminders.ordered_reminders(); - let prepended_reminder_tokens = - Self::prepended_reminder_tokens_for_pressure(&prepended_reminders); - let after_pressure = Self::estimate_auto_compression_pressure( - &new_messages, - tool_definitions.as_deref(), - before_pressure.trigger_budget(), - prepended_reminder_tokens, - ); let compressed_tokens = after_pressure.total_tokens; let summary_source = "model"; @@ -447,9 +523,38 @@ impl ExecutionEngine { }) .await; - Ok(Some((compressed_tokens, new_messages))) + Ok(AutoCompressionOutcome::Applied( + compressed_tokens, + new_messages, + )) + } + Ok(CompressionCommit::Unchanged(messages)) => { + let pressure = estimate(&messages); + let tokens = pressure.total_tokens; + info!( + "Auto compression skipped without savings: session_id={}, input_tokens={}, input_limit={}, system_tokens={}, tool_tokens={}, prepended_reminder_tokens={}, conversation_tokens={}", + session_id, tokens, pressure.input_limit, pressure.system_tokens, pressure.tool_tokens, + pressure.prepended_reminder_tokens, pressure.conversation_tokens + ); + self.emit_event( + AgenticEvent::ContextCompressionCompleted { + session_id: session_id.into(), + turn_id: dialog_turn_id.into(), + compression_id, + compression_count: session.compression_state.compression_count, + tokens_before: tokens, + tokens_after: tokens, + compression_ratio: 1.0, + duration_ms: elapsed_ms_u64(start_time), + has_summary: false, + summary_source: "none".into(), + applied: false, + }, + EventPriority::Normal, + ) + .await; + Ok(AutoCompressionOutcome::NoGain(messages)) } - Ok(None) => Ok(None), Err(e) => { // Emit compression failed event self.emit_event( diff --git a/src/crates/assembly/core/src/agentic/execution/compression_tests.rs b/src/crates/assembly/core/src/agentic/execution/compression_tests.rs index 359e6eada6..aaedfae769 100644 --- a/src/crates/assembly/core/src/agentic/execution/compression_tests.rs +++ b/src/crates/assembly/core/src/agentic/execution/compression_tests.rs @@ -146,6 +146,144 @@ async fn apply_prefetch( prefetch, ) .await + .map(|result| match result { + AutoCompressionOutcome::Applied(tokens, messages) => Some((tokens, messages)), + AutoCompressionOutcome::NoGain(_) => None, + }) +} + +#[tokio::test] +async fn compression_skips_retained_history_and_reconsiders_after_large_tool_result() { + use crate::agentic::core::{ToolCall, ToolResult}; + + let (temp, engine) = engine(); + let server = RetryTestServer::new(vec![retry_test_success()]); + let mut messages = vec![Message::system("system".into()), Message::user("Hi".into())]; + let session = prefetch_session(&engine, temp.path(), &messages).await; + let work = prefetch_job(&engine, &server, &messages, 0) + .spawn_prefetch(&CancellationToken::new(), None); + assert!( + apply_prefetch(&engine, &session, &server, &messages, Some(work)) + .await + .unwrap() + .is_none() + ); + assert!(server.requests.lock().unwrap().is_empty()); + + let budget = CompressionTriggerBudget::for_model(128_000, None); + let pressure = ExecutionEngine::estimate_auto_compression_pressure(&messages, None, budget, 0); + let rejected = NoGainHistory::new(&messages, "model", pressure); + assert!(rejected.matches(&messages, "model", pressure)); + assert!(!rejected.matches(&messages, "other-model", pressure)); + let smaller_budget = CompressionTriggerBudget::for_model(32_000, None); + let changed = + ExecutionEngine::estimate_auto_compression_pressure(&messages, None, smaller_budget, 0); + assert!(!rejected.matches(&messages, "model", changed)); + + let call = ToolCall { + tool_id: "read".into(), + tool_name: "Read".into(), + arguments: serde_json::json!({"path": "log"}), + raw_arguments: None, + is_error: false, + parse_error: None, + recovered_from_truncation: false, + repair_kind: Default::default(), + }; + let result = ToolResult { + tool_id: call.tool_id.clone(), + tool_name: call.tool_name.clone(), + effective_tool_name: None, + result: serde_json::json!({"output": "long log entry ".repeat(10_000)}), + result_for_assistant: None, + is_error: false, + duration_ms: None, + image_attachments: None, + }; + for message in [ + Message::assistant_with_tools(String::new(), vec![call]), + Message::tool_result(result), + ] { + engine + .session_manager + .add_message(&session, message.clone()) + .await + .unwrap(); + messages.push(message); + } + let changed = ExecutionEngine::estimate_auto_compression_pressure(&messages, None, budget, 0); + assert!(!rejected.matches(&messages, "model", changed)); + let (tokens, _) = apply_prefetch(&engine, &session, &server, &messages, None) + .await + .unwrap() + .unwrap(); + assert!(tokens < changed.total_tokens); + assert_eq!(server.requests.lock().unwrap().len(), 1); +} + +#[tokio::test] +async fn compression_discards_oversized_summary_without_changing_session() { + for use_prefetch in [false, true] { + let (temp, engine) = engine(); + let (status, response) = retry_test_success(); + let server = RetryTestServer::new(vec![( + status, + response.replace("Recovered", &"verbose summary ".repeat(1_000)), + )]); + let messages = vec![ + Message::system("system".into()), + Message::assistant("earlier work ".repeat(300)), + ]; + let session = prefetch_session(&engine, temp.path(), &messages).await; + let before = serde_json::to_value(&messages).unwrap(); + let work = use_prefetch.then(|| { + prefetch_job(&engine, &server, &messages, 0) + .spawn_prefetch(&CancellationToken::new(), None) + }); + assert!(apply_prefetch(&engine, &session, &server, &messages, work) + .await + .unwrap() + .is_none()); + assert_eq!(server.requests.lock().unwrap().len(), 1); + let stored = engine + .session_manager + .get_context_messages(&session) + .await + .unwrap(); + assert_eq!(serde_json::to_value(stored).unwrap(), before); + assert_eq!( + engine + .session_manager + .get_session(&session) + .unwrap() + .compression_state + .compression_count, + 0 + ); + let events = engine.event_queue.dequeue_batch(100).await; + assert!(events.iter().any(|event| matches!( + event.event, AgenticEvent::ContextCompressionCompleted { + applied: false, has_summary: false, compression_count: 0, tokens_before, tokens_after, .. + } if tokens_before == tokens_after + ))); + assert!(!events + .iter() + .any(|event| matches!(event.event, AgenticEvent::ContextCompressionFailed { .. }))); + } +} + +#[test] +fn compression_fixed_cost_diagnostic_allows_the_safety_margin() { + let budget = CompressionTriggerBudget::for_model(128_000, Some(32_000)); + let pressure = + |fixed| ExecutionEngine::estimate_auto_compression_pressure(&[], None, budget, fixed); + assert!(pressure(95_999).check_fixed_input_fits().is_ok()); + let error = pressure(96_001) + .check_fixed_input_fits() + .unwrap_err() + .to_string(); + assert!(error.contains("prepended_reminder_tokens=96001")); + assert!(error.contains("available_input_tokens=96000")); } #[tokio::test] @@ -154,16 +292,18 @@ async fn compression_prefetch_starts_at_zero_and_replans_with_fresh_tail() { let server = RetryTestServer::new(vec![retry_test_success()]); let messages = messages(); let zero = prefetch_job(&engine, &server, &messages, 0) - .run() + .run_automatic(None) .await + .unwrap() .unwrap(); assert_eq!(zero.plan.recent_target_tokens, 0); assert!(zero.plan.recent_tail_messages.is_empty()); assert_eq!(zero.plan.summary_messages.len(), messages.len() - 1); let server = RetryTestServer::new(vec![overflow(), retry_test_success()]); let replanned = prefetch_job(&engine, &server, &messages, 0) - .run() + .run_automatic(None) .await + .unwrap() .unwrap(); assert!(replanned.plan.recent_target_tokens >= 10_000); assert!(replanned.plan.cutoff_message_index < zero.plan.cutoff_message_index); @@ -192,7 +332,7 @@ async fn compression_prefetch_ready_is_silent_and_reused_with_new_tail() { let job = prefetch_job(&engine, &server, &messages, 0); let (published, barrier) = tokio::sync::oneshot::channel(); let work = job.spawn_prefetch_with(&CancellationToken::new(), |job| async move { - let result = job.run().await; + let result = job.run_automatic(None).await; let _ = published.send(()); result }); @@ -313,7 +453,7 @@ async fn compression_prefetch_oversized_latest_tail_starts_fresh_blocking_plan() let job = prefetch_job(&engine, &server, &messages, 0); let (published, barrier) = tokio::sync::oneshot::channel(); let work = job.spawn_prefetch_with(&CancellationToken::new(), |job| async move { - let result = job.run().await; + let result = job.run_automatic(None).await; let _ = published.send(()); result }); @@ -359,7 +499,7 @@ async fn compression_prefetch_cancelled_owner_never_falls_back() { let messages = messages(); let session = prefetch_session(&engine, temp.path(), &messages).await; let token = engine.round_executor.ensure_cancel_token("turn"); - let work = prefetch_job(&engine, &server, &messages, 0).spawn_prefetch(&token); + let work = prefetch_job(&engine, &server, &messages, 0).spawn_prefetch(&token, None); token.cancel(); let error = apply_prefetch(&engine, &session, &server, &messages, Some(work)) .await @@ -421,7 +561,7 @@ async fn compression_prefetch_commit_includes_append_during_formal_wait() { let messages = messages(); let session = prefetch_session(&engine, temp.path(), &messages).await; let candidate = prefetch_job(&engine, &server, &messages, 0) - .run() + .run_automatic(None) .await .unwrap(); engine.event_queue.dequeue_batch(100).await; @@ -466,6 +606,16 @@ async fn compression_prefetch_commit_includes_append_during_formal_wait() { .await .unwrap(); assert!(stored.iter().any(|message| message.id == new.id)); + let mut latest = messages; + latest.push(new); + let latest_tokens = ExecutionEngine::estimate_request_tokens_internal(&latest, None); + let candidate_tokens = ExecutionEngine::estimate_request_tokens_internal(&result, None); + let events = engine.event_queue.dequeue_batch(100).await; + assert!(events.iter().any(|event| matches!( + event.event, AgenticEvent::ContextCompressionCompleted { + applied: true, tokens_before, tokens_after, .. + } if tokens_before == latest_tokens && tokens_after == candidate_tokens && tokens_after < tokens_before + ))); assert_eq!(server.requests.lock().unwrap().len(), 1); } diff --git a/src/crates/assembly/core/src/agentic/execution/execution_engine.rs b/src/crates/assembly/core/src/agentic/execution/execution_engine.rs index 8af3ce0f11..73cebf8205 100644 --- a/src/crates/assembly/core/src/agentic/execution/execution_engine.rs +++ b/src/crates/assembly/core/src/agentic/execution/execution_engine.rs @@ -533,6 +533,32 @@ struct TokenPressureSnapshot { } impl TokenPressureSnapshot { + fn fixed_tokens(&self) -> [usize; 3] { + [ + self.system_tokens, + self.tool_tokens, + self.prepended_reminder_tokens, + ] + } + + fn check_fixed_input_fits(&self) -> OpenBitFunResult<()> { + let available = self + .context_window + .saturating_sub(self.output_reserve_tokens); + if self + .system_tokens + .saturating_add(self.tool_tokens) + .saturating_add(self.prepended_reminder_tokens) + > available + { + return Err(OpenBitFunError::AIClient(format!( + "Fixed context exceeds the available input budget: system_tokens={}, tool_tokens={}, prepended_reminder_tokens={}, available_input_tokens={}, output_reserve={}", + self.system_tokens, self.tool_tokens, self.prepended_reminder_tokens, available, self.output_reserve_tokens + ))); + } + Ok(()) + } + fn trigger_budget(&self) -> CompressionTriggerBudget { CompressionTriggerBudget { context_window: self.context_window, @@ -543,6 +569,41 @@ impl TokenPressureSnapshot { } } +/// A rejected summary is only evidence about the history and budget it saw. +struct NoGainHistory { + conversation_ids: Vec, + model_id: String, + budget: CompressionTriggerBudget, + fixed_tokens: [usize; 3], +} + +impl NoGainHistory { + fn new(messages: &[Message], model_id: &str, pressure: TokenPressureSnapshot) -> Self { + Self { + conversation_ids: ContextCompressor::canonical_conversation(messages) + .map(|m| m.id.clone()) + .collect(), + model_id: model_id.to_owned(), + budget: pressure.trigger_budget(), + fixed_tokens: pressure.fixed_tokens(), + } + } + + fn matches( + &self, + messages: &[Message], + model_id: &str, + pressure: TokenPressureSnapshot, + ) -> bool { + self.model_id == model_id + && self.budget == pressure.trigger_budget() + && self.fixed_tokens == pressure.fixed_tokens() + && ContextCompressor::canonical_conversation(messages) + .map(|m| &m.id) + .eq(self.conversation_ids.iter()) + } +} + // Fields are declared in reverse parameter order so dropping an unconsumed // input preserves the previous function-parameter drop order. Call sites keep // struct literal fields in the original evaluation order. @@ -583,6 +644,7 @@ mod compression_job; mod compression_lifecycle; use compression_job::{CompressionJob, PrefetchedCompression}; +use compression_lifecycle::AutoCompressionOutcome; struct CompressionModelSummaryInput<'a> { trace_config: Option, @@ -3840,6 +3902,7 @@ impl ExecutionEngine { // Execution-local ownership deliberately prevents cross-turn reuse. Drop // cancels both pending IO and backoff on every exit path. let mut compression_prefetch: Option = None; + let mut no_gain_history: Option = None; // Preserve the turn-admission model as the stable primary candidate. A routed // round may shadow the names below, but auxiliary/finalization requests still // use this baseline model and do not recursively invoke the router. @@ -4370,12 +4433,19 @@ impl ExecutionEngine { token_pressure.safety_reserve_tokens ); - let should_compress = enable_context_compression - && token_pressure.total_tokens >= token_pressure.input_limit; + if enable_context_compression { + token_pressure.check_fixed_input_fits()?; + } + let compression_eligible = enable_context_compression + && !no_gain_history + .as_ref() + .is_some_and(|history| history.matches(&messages, &model_id, token_pressure)); + let should_compress = + compression_eligible && token_pressure.total_tokens >= token_pressure.input_limit; let mut send_pressure_reusable = true; if !should_compress { - if enable_context_compression + if compression_eligible && prefetch_enabled && compression_prefetch.is_none() && openbitfun_agent_runtime::compression_prefetch::in_prefetch_window( @@ -4432,6 +4502,10 @@ impl ExecutionEngine { &self .round_executor .ensure_cancel_token(&context.dialog_turn_id), + self.session_manager.compression_contract_for_session( + &context.session_id, + DEFAULT_COMPRESSION_CONTRACT_LIMIT, + ), ), ); } @@ -4476,7 +4550,8 @@ impl ExecutionEngine { ) .await { - Ok(Some((compressed_tokens, compressed_messages))) => { + Ok(AutoCompressionOutcome::Applied(compressed_tokens, compressed_messages)) => { + no_gain_history = None; info!( "Round {} compression completed: messages {} -> {}, tokens {} -> {}", round_index, @@ -4511,10 +4586,12 @@ impl ExecutionEngine { full_compression_count += 1; send_pressure_reusable = false; } - Ok(None) => { - return Err(OpenBitFunError::AIClient( - "Context compression has no eligible plan".to_string(), - )); + Ok(AutoCompressionOutcome::NoGain(latest)) => { + no_gain_history = + Some(NoGainHistory::new(&latest, &model_id, token_pressure)); + // Preserve any canonical suffix appended while the summary ran. + send_pressure_reusable = latest.len() == messages.len(); + messages = latest; } Err(err @ OpenBitFunError::Cancelled(_)) => return Err(err), Err(e) => return Err(e), @@ -4756,6 +4833,9 @@ impl ExecutionEngine { Err(err) if enable_context_compression && err.is_recoverable_context_overflow() + && !no_gain_history.as_ref().is_some_and(|history| { + history.matches(&messages, &model_id, send_pressure) + }) && main_context_overflow_recoveries < Self::MAX_MAIN_CONTEXT_OVERFLOW_RECOVERIES => { @@ -4788,7 +4868,11 @@ impl ExecutionEngine { ) .await { - Ok(Some((compressed_tokens, compressed_messages))) => { + Ok(AutoCompressionOutcome::Applied( + compressed_tokens, + compressed_messages, + )) => { + no_gain_history = None; info!( "Context-overflow recovery compression completed: session_id={}, turn_id={}, round_index={}, recovery={}, messages {} -> {}, tokens {} -> {}", context.session_id, @@ -4836,7 +4920,7 @@ impl ExecutionEngine { full_compression_count += 1; continue; } - Ok(None) => { + Ok(AutoCompressionOutcome::NoGain(_)) => { warn!( "Context-overflow recovery found no compressible context: session_id={}, turn_id={}, round_index={}", context.session_id, context.dialog_turn_id, round_index diff --git a/src/crates/assembly/core/src/agentic/session/compression/compressor.rs b/src/crates/assembly/core/src/agentic/session/compression/compressor.rs index 78ae458353..c60410bc04 100644 --- a/src/crates/assembly/core/src/agentic/session/compression/compressor.rs +++ b/src/crates/assembly/core/src/agentic/session/compression/compressor.rs @@ -416,25 +416,53 @@ impl ContextCompressor { "Context compression requires a non-empty model summary".to_string(), ) })?; + trace!("Rendering compression result for session {}", session_id); + Ok(self.replacement( + plan.retained_user_messages, + plan.recent_tail_messages, + plan.current_turn_todo_checkpoint, + contract, + summary, + )) + } + + // Render the smallest possible replacement, including required checkpoint + // text and the continuation reminder. Transcript references can only add cost. + pub(crate) fn minimum_replacement( + &self, + plan: &CompressionPlan, + contract: Option, + ) -> CompressionResult { + self.replacement( + plan.retained_user_messages.clone(), + plan.recent_tail_messages.clone(), + plan.current_turn_todo_checkpoint.clone(), + contract, + String::new(), + ) + } + + fn replacement( + &self, + mut messages: Vec, + tail: Vec, + checkpoint: Option, + contract: Option, + summary: String, + ) -> CompressionResult { let mut summary_artifact = self.build_model_summary_artifact(summary, contract); - if let Some(checkpoint) = plan.current_turn_todo_checkpoint { + if let Some(checkpoint) = checkpoint { Self::append_current_turn_todo_checkpoint(&mut summary_artifact, checkpoint); } let summary_message = self.create_summary_message(summary_artifact); - let mut messages = plan.retained_user_messages; messages.push(summary_message); - messages.extend(plan.recent_tail_messages); + messages.extend(tail); messages.push(Message::internal_reminder( InternalReminderKind::CompressionContinuation, Self::COMPRESSION_CONTINUATION_REMINDER, )); - debug!( - "Compression completed: session_id={}, compressed_messages={}", - session_id, - messages.len() - ); - Ok(CompressionResult { messages }) + CompressionResult { messages } } fn append_current_turn_todo_checkpoint(