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(