From 8c0ac3b1e0232847c1708cabdbfb44607288a4af Mon Sep 17 00:00:00 2001 From: wsp Date: Fri, 20 Nov 2026 12:32:33 +0800 Subject: [PATCH] fix(agent): Use the active model context budget A stale session window could exhaust the input budget and trigger compression before every request. Resolve the budget from the active model or model pool for execution, compaction, and usage estimates. Keep the persisted window for compatibility with older readers. Refs: #4007 --- .../src/agentic/coordination/coordinator.rs | 49 ++----- .../coordinator/tests/manual_compaction.rs | 7 +- .../coordinator/tests/subagent_input.rs | 50 +++++++ .../execution/compression_lifecycle.rs | 16 +-- .../agentic/execution/compression_tests.rs | 8 +- .../src/agentic/execution/context_budget.rs | 39 ++++++ .../src/agentic/execution/execution_engine.rs | 132 +++++++----------- .../execution_engine/context_estimate.rs | 17 +-- .../src/agentic/session/session_manager.rs | 9 +- .../execution/agent-runtime/src/session.rs | 3 + 10 files changed, 168 insertions(+), 162 deletions(-) diff --git a/src/crates/assembly/core/src/agentic/coordination/coordinator.rs b/src/crates/assembly/core/src/agentic/coordination/coordinator.rs index 66b28c0b38..a93f68512c 100644 --- a/src/crates/assembly/core/src/agentic/coordination/coordinator.rs +++ b/src/crates/assembly/core/src/agentic/coordination/coordinator.rs @@ -2185,7 +2185,7 @@ Update the persona files and delete BOOTSTRAP.md as soon as bootstrap is complet fn build_manual_compaction_round_completed( turn_id: &str, outcome: &ContextCompactionOutcome, - context_window: usize, + context_window: Option, ) -> crate::service::session::ModelRoundData { use crate::service::session::{ModelRoundData, ToolCallData, ToolItemData, ToolResultData}; @@ -2274,7 +2274,7 @@ Update the persona files and delete BOOTSTRAP.md as soon as bootstrap is complet turn_id: &str, compression_id: String, error: &str, - context_window: usize, + context_window: Option, ) -> crate::service::session::ModelRoundData { use crate::service::session::{ModelRoundData, ToolCallData, ToolItemData, ToolResultData}; @@ -6279,7 +6279,6 @@ Update the persona files and delete BOOTSTRAP.md as soon as bootstrap is complet session_manager, execution_engine, event_queue, - session, context_messages, session_id_for_task, turn_id_for_task, @@ -6308,7 +6307,7 @@ Update the persona files and delete BOOTSTRAP.md as soon as bootstrap is complet session_id: &str, turn_id: &str, outcome: &ContextCompactionOutcome, - context_window: usize, + context_window: Option, ) -> OpenBitFunResult<()> { let model_round = Self::build_manual_compaction_round_completed(turn_id, outcome, context_window); @@ -6388,7 +6387,6 @@ Update the persona files and delete BOOTSTRAP.md as soon as bootstrap is complet session_manager: Arc, execution_engine: Arc, event_queue: Arc, - session: Session, context_messages: Vec, session_id: String, turn_id: String, @@ -6401,17 +6399,17 @@ Update the persona files and delete BOOTSTRAP.md as soon as bootstrap is complet commit_gate: Arc, ) -> OpenBitFunResult<()> { let compression_id = format!("compression_{}", uuid::Uuid::new_v4()); - let mut context_window = session.config.max_context_tokens; + let mut context_window = None; // Preparation and compaction embed the full model/tool-catalog future. // Keep that state on the heap instead of duplicating it through this // task and its callers: even a pre-cancelled turn must enter the poll // stack frame before it can observe cancellation. let result = Box::pin(async { - let (manual_execution_context, resolved_context_window) = + let manual_execution_context = prepare_compression_cancellable(&cancellation_token, async { let manual_workspace_services = Self::build_workspace_services(&manual_workspace).await?; - let manual_execution_context = ExecutionContext { + Ok(ExecutionContext { session_id: session_id.clone(), dialog_turn_id: turn_id.clone(), turn_index, @@ -6432,30 +6430,9 @@ Update the persona files and delete BOOTSTRAP.md as soon as bootstrap is complet round_injection: None, emit_lifecycle_events: false, recover_partial_on_cancel: false, - }; - let session_max_tokens = session.config.max_context_tokens; - - // Unify context_window: min(model capability, session config) - let model_context_window = - match crate::infrastructure::ai::get_global_ai_client_factory().await { - Ok(factory) => { - let model_id = - session.config.model_id.as_deref().unwrap_or("default"); - match factory.get_client_resolved(model_id).await { - Ok(client) => Some(client.config.context_window as usize), - Err(_) => None, - } - } - Err(_) => None, - }; - let context_window = match model_context_window { - Some(mcw) => mcw.min(session_max_tokens), - None => session_max_tokens, - }; - Ok((manual_execution_context, context_window)) + }) }) .await?; - context_window = resolved_context_window; execution_engine .compact_session_context( session_id.clone(), @@ -6466,6 +6443,7 @@ Update the persona files and delete BOOTSTRAP.md as soon as bootstrap is complet "manual", cancellation_token, commit_gate, + &mut context_window, ) .await }) @@ -7533,10 +7511,6 @@ Update the persona files and delete BOOTSTRAP.md as soon as bootstrap is complet // Create execution context (pass full config and resource IDs) let mut context_vars = std::collections::HashMap::new(); - context_vars.insert( - "max_context_tokens".to_string(), - session.config.max_context_tokens.to_string(), - ); context_vars.insert( "enable_tools".to_string(), session.config.enable_tools.to_string(), @@ -8116,10 +8090,6 @@ Update the persona files and delete BOOTSTRAP.md as soon as bootstrap is complet .is_transient_session(&request.session_id), ); let mut context_vars = HashMap::new(); - context_vars.insert( - "max_context_tokens".to_string(), - session.config.max_context_tokens.to_string(), - ); context_vars.insert( "enable_tools".to_string(), session.config.enable_tools.to_string(), @@ -11131,8 +11101,7 @@ Update the persona files and delete BOOTSTRAP.md as soon as bootstrap is complet let session_id = session.session_id.clone(); let _execution_lease = execution_lease.unwrap_or_else(|| self.register_session_execution(&session_id)); - // Sync context window from AI config so subagents with large-context - // models are not prematurely capped at SessionConfig::default()'s 128128. + // Keep the legacy session window snapshot aligned with the subagent model. if let Err(error) = self .session_manager .refresh_session_context_window(&session_id) diff --git a/src/crates/assembly/core/src/agentic/coordination/coordinator/tests/manual_compaction.rs b/src/crates/assembly/core/src/agentic/coordination/coordinator/tests/manual_compaction.rs index e2506a2b2c..485c7addcb 100644 --- a/src/crates/assembly/core/src/agentic/coordination/coordinator/tests/manual_compaction.rs +++ b/src/crates/assembly/core/src/agentic/coordination/coordinator/tests/manual_compaction.rs @@ -113,7 +113,7 @@ fn manual_compaction_transcript_restores_user_and_tool_payload() { ConversationCoordinator::build_manual_compaction_round_completed( &turn.turn_id, &outcome, - 128_000, + Some(128_000), ), ]; turn.status = TurnStatus::Completed; @@ -177,7 +177,7 @@ fn manual_compaction_failure_round_preserves_runtime_identity_and_error() { "compact-turn", "compression-runtime".to_string(), "summary request failed", - 128_000, + Some(128_000), ); assert_eq!(round.tool_items.len(), 1); @@ -227,7 +227,6 @@ async fn manual_compaction_cancelled_before_setup_preserves_context_and_settles_ session_manager.clone(), coordinator.execution_engine.clone(), coordinator.event_queue.clone(), - session, original, session_id.clone(), turn_id.clone(), @@ -322,7 +321,7 @@ async fn applied_manual_compaction_emits_failed_terminal_when_turn_persistence_f summary_source: "model".to_string(), applied: true, }, - 128_000, + Some(128_000), ) .await; diff --git a/src/crates/assembly/core/src/agentic/coordination/coordinator/tests/subagent_input.rs b/src/crates/assembly/core/src/agentic/coordination/coordinator/tests/subagent_input.rs index 2e33f2fa6f..3270ef4edf 100644 --- a/src/crates/assembly/core/src/agentic/coordination/coordinator/tests/subagent_input.rs +++ b/src/crates/assembly/core/src/agentic/coordination/coordinator/tests/subagent_input.rs @@ -296,6 +296,56 @@ async fn current_context_estimate_remote_subagent_uses_cached_rules_without_loca .await; } +#[tokio::test] +async fn current_context_estimate_uses_the_model_window_with_legacy_session_limits() { + use crate::agentic::core::Session; + use openbitfun_core_types::UsageContextEstimateRequest; + + let root = tempfile::tempdir().unwrap(); + crate::service::workspace::legacy_compat::register_local_fixture_blocking(root.path()); + let mut config = context_estimate_ai_config(); + config.models[1].context_window = Some(1_048_576); + config.models[1].max_tokens = Some(384_000); + TEST_MODEL_RESOLUTION_AI_CONFIG + .scope(config, async { + let (coordinator, manager) = test_persistent_coordinator(); + for (saved_window, model, expected_window) in [ + (128_128, "child-model", 1_048_576), + (1_048_576, "parent-model", 64_000), + ] { + let session = Session::new( + "Saved session".into(), + "Standard".into(), + SessionConfig { + workspace_path: Some(root.path().to_string_lossy().into_owned()), + model_id: Some(model.into()), + max_context_tokens: saved_window, + ..Default::default() + }, + ); + manager + .persistence_manager() + .save_session(root.path(), &session) + .await + .unwrap(); + let inputs = manager + .read_context_estimate_inputs(root.path(), &session.session_id) + .await + .unwrap(); + assert_eq!(inputs.session.config.max_context_tokens, saved_window); + let estimate = coordinator + .estimate_session_context(inputs, &UsageContextEstimateRequest::default()) + .await + .unwrap(); + assert_eq!( + estimate.composition.unwrap().context_window, + Some(expected_window) + ); + } + }) + .await; +} + #[tokio::test] async fn current_context_estimate_keeps_external_and_internal_worker_contexts_unsupported() { use crate::agentic::tools::ToolRuntimeRestrictions; 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 c9a8fd9c9b..0a679c19ba 100644 --- a/src/crates/assembly/core/src/agentic/execution/compression_lifecycle.rs +++ b/src/crates/assembly/core/src/agentic/execution/compression_lifecycle.rs @@ -59,7 +59,6 @@ impl ExecutionEngine { trigger: &str, runtime_messages: Vec, before_pressure: TokenPressureSnapshot, - context_window: usize, ai_client: Arc, model_request_context: &ModelRequestContext, tool_definitions: &Option>, @@ -77,6 +76,8 @@ impl ExecutionEngine { OpenBitFunError::NotFound(format!("Session not found: {}", session_id)) })?; + let context_window = before_pressure.context_window; + // Record start time let start_time = std::time::Instant::now(); @@ -276,11 +277,7 @@ impl ExecutionEngine { let pressure = Self::estimate_auto_compression_pressure( &preview, tool_definitions.as_deref(), - context_window, - Self::compression_trigger_budget( - context_window, - ai_client.config.max_tokens, - ), + before_pressure.trigger_budget(), Self::prepended_reminder_tokens_for_pressure( &prepended_prompt_reminders.ordered_reminders(), ), @@ -375,12 +372,7 @@ impl ExecutionEngine { let after_pressure = Self::estimate_auto_compression_pressure( &new_messages, tool_definitions.as_deref(), - context_window, - CompressionTriggerBudget { - input_limit: before_pressure.input_limit, - output_reserve_tokens: before_pressure.output_reserve_tokens, - safety_reserve_tokens: before_pressure.safety_reserve_tokens, - }, + before_pressure.trigger_budget(), prepended_reminder_tokens, ); let compressed_tokens = after_pressure.total_tokens; 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 9701125fa4..359e6eada6 100644 --- a/src/crates/assembly/core/src/agentic/execution/compression_tests.rs +++ b/src/crates/assembly/core/src/agentic/execution/compression_tests.rs @@ -125,8 +125,7 @@ async fn apply_prefetch( let pressure = ExecutionEngine::estimate_auto_compression_pressure( messages, None, - 128_000, - ExecutionEngine::compression_trigger_budget(128_000, None), + CompressionTriggerBudget::for_model(128_000, None), 0, ); engine @@ -136,7 +135,6 @@ async fn apply_prefetch( "auto", messages.to_vec(), pressure, - 128_000, server.client(), &ModelRequestContext::default(), &None, @@ -579,8 +577,7 @@ async fn compression_failure_preserves_context_and_success_count() { let pressure = ExecutionEngine::estimate_auto_compression_pressure( &messages, None, - 128_000, - ExecutionEngine::compression_trigger_budget(128_000, None), + CompressionTriggerBudget::for_model(128_000, None), 0, ); let error = engine @@ -590,7 +587,6 @@ async fn compression_failure_preserves_context_and_success_count() { "auto", messages, pressure, - 128_000, server.client(), &ModelRequestContext::default(), &None, diff --git a/src/crates/assembly/core/src/agentic/execution/context_budget.rs b/src/crates/assembly/core/src/agentic/execution/context_budget.rs index 71fba636ab..cfbab0b502 100644 --- a/src/crates/assembly/core/src/agentic/execution/context_budget.rs +++ b/src/crates/assembly/core/src/agentic/execution/context_budget.rs @@ -5,6 +5,7 @@ use openbitfun_core_types::model_pool::ModelPoolContextBudget; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub(super) struct CompressionTriggerBudget { + pub context_window: usize, pub input_limit: usize, pub output_reserve_tokens: usize, pub safety_reserve_tokens: usize, @@ -13,12 +14,25 @@ pub(super) struct CompressionTriggerBudget { impl CompressionTriggerBudget { const SAFETY_RESERVE_TOKENS: usize = 10_000; + /// The active model or pool owns the request budget. Persisted session + /// windows can describe a previous model or a legacy creation default. + pub(super) fn for_request( + model: &openbitfun_core_types::AIConfig, + pool: Option, + ) -> Self { + match pool { + Some(budget) => Self::for_pool(budget), + None => Self::for_model(model.context_window as usize, model.max_tokens), + } + } + pub(super) fn for_model(context_window: usize, configured_max_tokens: Option) -> Self { let output_reserve_tokens = configured_max_tokens .map(|value| value as usize) .unwrap_or_else(|| automatic_max_output_tokens(context_window as u32) as usize); let safety_reserve_tokens = Self::SAFETY_RESERVE_TOKENS; Self { + context_window, input_limit: context_window .saturating_sub(output_reserve_tokens + safety_reserve_tokens), output_reserve_tokens, @@ -31,6 +45,7 @@ impl CompressionTriggerBudget { let input_limit = budget.input_limit as usize; let safety_reserve_tokens = Self::SAFETY_RESERVE_TOKENS.min(context_window); Self { + context_window, input_limit, // This is an equivalent reserve for the common window, not a new // max_tokens setting for any member's provider request. @@ -40,3 +55,27 @@ impl CompressionTriggerBudget { } } } + +#[cfg(test)] +mod tests { + use super::*; + use crate::service::config::types::AIModelConfig; + + #[test] + fn compression_budget_follows_each_selected_model() { + for (window, max_output, input_limit) in + [(1_048_576, 384_000, 654_576), (64_000, 16_000, 38_000)] + { + let model = openbitfun_core_types::AIConfig::try_from(AIModelConfig { + context_window: Some(window), + max_tokens: Some(max_output), + ..Default::default() + }) + .unwrap(); + let budget = CompressionTriggerBudget::for_request(&model, None); + assert_eq!(budget.context_window, window as usize); + assert_eq!(budget.input_limit, input_limit); + assert_eq!(47_544 >= budget.input_limit, window == 64_000); + } + } +} 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 a9693820be..8af3ce0f11 100644 --- a/src/crates/assembly/core/src/agentic/execution/execution_engine.rs +++ b/src/crates/assembly/core/src/agentic/execution/execution_engine.rs @@ -532,6 +532,17 @@ struct TokenPressureSnapshot { usage_ratio: f32, } +impl TokenPressureSnapshot { + fn trigger_budget(&self) -> CompressionTriggerBudget { + CompressionTriggerBudget { + context_window: self.context_window, + input_limit: self.input_limit, + output_reserve_tokens: self.output_reserve_tokens, + safety_reserve_tokens: self.safety_reserve_tokens, + } + } +} + // 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. @@ -782,7 +793,6 @@ impl ExecutionEngine { fn estimate_auto_compression_pressure( messages: &[Message], tools: Option<&[ToolDefinition]>, - context_window: usize, trigger_budget: CompressionTriggerBudget, prepended_reminder_tokens: usize, ) -> TokenPressureSnapshot { @@ -792,7 +802,6 @@ impl ExecutionEngine { total_tokens, messages, tools, - context_window, trigger_budget, prepended_reminder_tokens, ) @@ -801,7 +810,6 @@ impl ExecutionEngine { fn estimate_auto_compression_pressure_with_anchor( messages: &[Message], tools: Option<&[ToolDefinition]>, - context_window: usize, trigger_budget: CompressionTriggerBudget, anchor: Option<&TokenAnchor>, prepended_reminder_tokens: usize, @@ -810,7 +818,6 @@ impl ExecutionEngine { let snapshot = Self::estimate_auto_compression_pressure( messages, tools, - context_window, trigger_budget, prepended_reminder_tokens, ); @@ -843,7 +850,6 @@ impl ExecutionEngine { total_tokens, messages, tools, - context_window, trigger_budget, prepended_reminder_tokens, ); @@ -874,7 +880,6 @@ impl ExecutionEngine { total_tokens: usize, messages: &[Message], tools: Option<&[ToolDefinition]>, - context_window: usize, trigger_budget: CompressionTriggerBudget, prepended_reminder_tokens: usize, ) -> TokenPressureSnapshot { @@ -890,6 +895,7 @@ impl ExecutionEngine { .saturating_add(tool_tokens) .saturating_add(prepended_reminder_tokens); let conversation_tokens = total_tokens.saturating_sub(reserved_overhead); + let context_window = trigger_budget.context_window; let usage_ratio = ContextHealthSnapshot::token_usage_ratio(total_tokens, context_window); TokenPressureSnapshot { total_tokens, @@ -905,13 +911,6 @@ impl ExecutionEngine { } } - fn compression_trigger_budget( - context_window: usize, - configured_max_tokens: Option, - ) -> CompressionTriggerBudget { - CompressionTriggerBudget::for_model(context_window, configured_max_tokens) - } - fn prepended_reminder_tokens_for_pressure(prepended_reminders: &[&str]) -> usize { prepended_reminders .iter() @@ -2780,6 +2779,7 @@ impl ExecutionEngine { trigger: &str, cancellation_token: CancellationToken, commit_gate: Arc, + resolved_context_window: &mut Option, ) -> OpenBitFunResult { let mut session = self .session_manager @@ -2812,25 +2812,18 @@ impl ExecutionEngine { } else { None }; - let context_window = pool_budget - .map(|budget| budget.context_window as usize) - .unwrap_or_else(|| (scaffold.ai_client.config.context_window as usize) - .min(session.config.max_context_tokens)); + let compression_trigger_budget = + CompressionTriggerBudget::for_request(&scaffold.ai_client.config, pool_budget); + let context_window = compression_trigger_budget.context_window; + *resolved_context_window = Some(context_window); let prepended_reminders = scaffold.prepended_prompt_reminders.ordered_reminders(); let prepended_reminder_tokens = Self::prepended_reminder_tokens_for_pressure(&prepended_reminders); - let compression_trigger_budget = pool_budget - .map(CompressionTriggerBudget::for_pool) - .unwrap_or_else(|| Self::compression_trigger_budget( - context_window, - scaffold.ai_client.config.max_tokens, - )); let mut runtime_messages = vec![scaffold.system_prompt_message.clone()]; runtime_messages.extend(messages.clone()); let before_pressure = Self::estimate_auto_compression_pressure( &runtime_messages, scaffold.tool_definitions.as_deref(), - context_window, compression_trigger_budget, prepended_reminder_tokens, ); @@ -2933,12 +2926,7 @@ impl ExecutionEngine { return Err(manual_compaction_terminal_error(err)); } }; - let context_window = before_pressure.context_window; - let compression_trigger_budget = CompressionTriggerBudget { - input_limit: before_pressure.input_limit, - output_reserve_tokens: before_pressure.output_reserve_tokens, - safety_reserve_tokens: before_pressure.safety_reserve_tokens, - }; + let compression_trigger_budget = before_pressure.trigger_budget(); let prepended_reminders = scaffold.prepended_prompt_reminders.ordered_reminders(); let prepended_reminder_tokens = Self::prepended_reminder_tokens_for_pressure(&prepended_reminders); @@ -2986,7 +2974,6 @@ impl ExecutionEngine { let after_pressure = Self::estimate_auto_compression_pressure( &compressed_runtime_messages, scaffold.tool_definitions.as_deref(), - context_window, compression_trigger_budget, prepended_reminder_tokens, ); @@ -3525,19 +3512,12 @@ impl ExecutionEngine { .await; let mut primary_supports_image_understanding = primary_model_facts.supports_image_inputs; - let model_context_window = ai_client.config.context_window as usize; - let session_max_tokens = session.config.max_context_tokens; - let mut context_window = if let Some((attempt, _)) = &initial_pool_attempt { - attempt.context_budget.context_window as usize - } else { - model_context_window.min(session_max_tokens) - }; - if model_context_window != session_max_tokens { - debug!( - "Context window: model={}, session_config={}, effective={}", - model_context_window, session_max_tokens, context_window - ); - } + let mut compression_trigger_budget = CompressionTriggerBudget::for_request( + &ai_client.config, + initial_pool_attempt + .as_ref() + .map(|(attempt, _)| attempt.context_budget), + ); // 3. Get available tools list (read tool configuration for current mode from global config) let tool_policy = agent_registry @@ -3558,6 +3538,10 @@ impl ExecutionEngine { Err(_) => true, }; let mut execution_context_vars = context.context.clone(); + execution_context_vars.insert( + "max_context_tokens".into(), + compression_trigger_budget.context_window.to_string(), + ); execution_context_vars.insert( "enable_deferred_tool_loading".to_string(), deferred_tool_loading_enabled.to_string(), @@ -3577,7 +3561,6 @@ impl ExecutionEngine { serde_json::to_string(&allowed_tools).unwrap_or_else(|_| "[]".to_string()), ); } - let tool_manifest_context_vars = execution_context_vars.clone(); let tool_description_context = tool_context_runtime::build_tool_description_context( &agent_type, @@ -3587,7 +3570,7 @@ impl ExecutionEngine { context.terminal_port.as_ref(), context.remote_exec_port.as_ref(), Some(&primary_model_facts), - &tool_manifest_context_vars, + &execution_context_vars, &context.runtime_tool_restrictions, ); @@ -3880,13 +3863,6 @@ impl ExecutionEngine { baseline_ai_client.config.model.clone(), baseline_supports_image_understanding, ); - let mut compression_trigger_budget = initial_pool_attempt - .as_ref() - .map(|(attempt, _)| CompressionTriggerBudget::for_pool(attempt.context_budget)) - .unwrap_or_else(|| { - Self::compression_trigger_budget(context_window, ai_client.config.max_tokens) - }); - // Project images at the provider boundary on every round. Keep the // canonical pixels and paths so steering, retries, and model switches // retain the same attachments. @@ -4122,9 +4098,13 @@ impl ExecutionEngine { channel_client_source = selected_model.client.channel_source; primary_model_facts = selected_model.model_facts; primary_supports_image_understanding = primary_model_facts.supports_image_inputs; - context_window = (ai_client.config.context_window as usize).min(session_max_tokens); compression_trigger_budget = - Self::compression_trigger_budget(context_window, ai_client.config.max_tokens); + CompressionTriggerBudget::for_request(&ai_client.config, None); + + execution_context_vars.insert( + "max_context_tokens".into(), + compression_trigger_budget.context_window.to_string(), + ); let next_scaffold_model_key = ( model_id.clone(), @@ -4160,7 +4140,7 @@ impl ExecutionEngine { route, model_id, ai_client.config.model, - context_window + compression_trigger_budget.context_window ); if let Some(router) = turn_router.as_ref() { router.record_execution_model(RoundModelExecutionRecord { @@ -4197,14 +4177,14 @@ impl ExecutionEngine { ) .await? }; - let next_context_window = attempt.context_budget.context_window as usize; let next_budget = CompressionTriggerBudget::for_pool(attempt.context_budget); - if context_window != next_context_window - || compression_trigger_budget != next_budget - { + if compression_trigger_budget != next_budget { compression_prefetch.take(); - context_window = next_context_window; compression_trigger_budget = next_budget; + execution_context_vars.insert( + "max_context_tokens".into(), + next_budget.context_window.to_string(), + ); } let binding = &attempt.reservation.binding; if model_id != binding.model_id @@ -4246,7 +4226,7 @@ impl ExecutionEngine { context.terminal_port.as_ref(), context.remote_exec_port.as_ref(), Some(&primary_model_facts), - &tool_manifest_context_vars, + &execution_context_vars, &context.runtime_tool_restrictions, ); if enable_tools { @@ -4281,6 +4261,7 @@ impl ExecutionEngine { None }; + let context_window = compression_trigger_budget.context_window; // Check and compress before sending AI request // // NOTE: There used to be a "microcompact" pre-pass here that @@ -4312,7 +4293,6 @@ impl ExecutionEngine { Self::estimate_auto_compression_pressure_with_anchor( &messages, tool_definitions.as_deref(), - context_window, compression_trigger_budget, token_anchor_selection.selected.as_ref(), pressure_prepended_reminder_tokens, @@ -4484,7 +4464,6 @@ impl ExecutionEngine { "auto", messages.clone(), token_pressure, - context_window, baseline_ai_client.clone(), &model_request_context, &tool_definitions, @@ -4557,7 +4536,6 @@ impl ExecutionEngine { Self::estimate_auto_compression_pressure( &messages, tool_definitions.as_deref(), - context_window, compression_trigger_budget, send_prepended_reminder_tokens, ) @@ -4580,7 +4558,6 @@ impl ExecutionEngine { send_pressure = Self::estimate_auto_compression_pressure( &messages, tool_definitions.as_deref(), - context_window, compression_trigger_budget, send_prepended_reminder_tokens, ); @@ -4799,7 +4776,6 @@ impl ExecutionEngine { "context_overflow_recovery", messages.clone(), send_pressure, - context_window, baseline_ai_client.clone(), &model_request_context, &tool_definitions, @@ -5032,7 +5008,6 @@ impl ExecutionEngine { let after_round_pressure = Self::estimate_auto_compression_pressure( &messages, tool_definitions.as_deref(), - context_window, compression_trigger_budget, send_prepended_reminder_tokens, ); @@ -5526,6 +5501,7 @@ impl ExecutionEngine { }; if let Some(finalize_reminder) = finalize_reminder { + let context_window = compression_trigger_budget.context_window; let finalize_round_group_id = Some(format!( "{}:finalize:{}", context.dialog_turn_id, completed_rounds @@ -5935,8 +5911,8 @@ mod tests { build_skill_agent_tool_listing_sections_from_snapshot, deferred_tool_listing_reminder, manual_compaction_terminal_error, reached_fixed_model_round_limit, resolve_round_permission_mode, runtime_context_needs_for_manifest, - skill_agent_listing_reminders, ContextHealthSnapshot, ExecutionEngine, - ExecutionEngineConfig, RoundResult, TurnPromptScaffold, + skill_agent_listing_reminders, CompressionTriggerBudget, ContextHealthSnapshot, + ExecutionEngine, ExecutionEngineConfig, RoundResult, TurnPromptScaffold, }; use crate::agentic::agents::{ PrependedPromptReminders, PromptBuilderContext, ToolListingSections, UserContextPolicy, @@ -7646,8 +7622,7 @@ mod tests { let snapshot = ExecutionEngine::estimate_auto_compression_pressure( &messages, Some(&tools), - 128_000, - ExecutionEngine::compression_trigger_budget(128_000, None), + CompressionTriggerBudget::for_model(128_000, None), prepended_reminder_tokens, ); @@ -7667,7 +7642,7 @@ mod tests { #[test] fn compression_trigger_budget_reserves_output_and_safety_tokens() { - let budget = ExecutionEngine::compression_trigger_budget(128_000, Some(32_000)); + let budget = CompressionTriggerBudget::for_model(128_000, Some(32_000)); assert_eq!(budget.output_reserve_tokens, 32_000); assert_eq!(budget.safety_reserve_tokens, 10_000); @@ -7676,7 +7651,7 @@ mod tests { #[test] fn compression_trigger_budget_uses_the_automatic_output_tier_when_max_tokens_is_unset() { - let budget = ExecutionEngine::compression_trigger_budget(128_000, None); + let budget = CompressionTriggerBudget::for_model(128_000, None); assert_eq!(budget.output_reserve_tokens, 32_000); assert_eq!(budget.safety_reserve_tokens, 10_000); @@ -7711,8 +7686,7 @@ mod tests { let (snapshot, details) = ExecutionEngine::estimate_auto_compression_pressure_with_anchor( &messages, None, - 1_000, - ExecutionEngine::compression_trigger_budget(1_000, None), + CompressionTriggerBudget::for_model(1_000, None), Some(&anchor), 0, ); @@ -7758,8 +7732,7 @@ mod tests { let (snapshot, details) = ExecutionEngine::estimate_auto_compression_pressure_with_anchor( &messages, Some(&new_tools), - 1_000, - ExecutionEngine::compression_trigger_budget(1_000, None), + CompressionTriggerBudget::for_model(1_000, None), Some(&anchor), 0, ); @@ -7806,8 +7779,7 @@ mod tests { let (snapshot, details) = ExecutionEngine::estimate_auto_compression_pressure_with_anchor( &messages, None, - 1_000, - ExecutionEngine::compression_trigger_budget(1_000, None), + CompressionTriggerBudget::for_model(1_000, None), Some(&anchor), new_reminder_tokens, ); diff --git a/src/crates/assembly/core/src/agentic/execution/execution_engine/context_estimate.rs b/src/crates/assembly/core/src/agentic/execution/execution_engine/context_estimate.rs index d1d0a9eea5..ccdabd3a0e 100644 --- a/src/crates/assembly/core/src/agentic/execution/execution_engine/context_estimate.rs +++ b/src/crates/assembly/core/src/agentic/execution/execution_engine/context_estimate.rs @@ -60,7 +60,7 @@ impl ExecutionEngine { "Model configuration is unavailable for context inspection", ) })?; - let (model_id, pool_window) = + let (model_id, pool_budget) = if session.config.model_binding_policy == SessionModelBindingPolicy::Pool { let pool_id = session.config.model_pool_id.as_deref().ok_or_else(|| { OpenBitFunError::validation("Pool session has no pool selection") @@ -76,15 +76,7 @@ impl ExecutionEngine { ImageInputRequirement::None, ) .await?; - ( - id, - Some( - self.model_pools - .context_budget(pool_id) - .await? - .context_window as usize, - ), - ) + (id, Some(self.model_pools.context_budget(pool_id).await?)) } else { let (id, _) = self .resolve_model_id_for_turn( @@ -118,9 +110,8 @@ impl ExecutionEngine { &model_config.format, supports_images, ); - let context_window = pool_window.unwrap_or( - (model_config.context_window as usize).min(session.config.max_context_tokens), - ); + let context_window = + CompressionTriggerBudget::for_request(&model_config, pool_budget).context_window; let policy = registry .get_agent_tool_policy(&session.agent_type, workspace.workspace_id.as_deref()) .await; diff --git a/src/crates/assembly/core/src/agentic/session/session_manager.rs b/src/crates/assembly/core/src/agentic/session/session_manager.rs index e57b03ac4c..d669ee1130 100644 --- a/src/crates/assembly/core/src/agentic/session/session_manager.rs +++ b/src/crates/assembly/core/src/agentic/session/session_manager.rs @@ -5111,13 +5111,8 @@ impl SessionManager { Ok(()) } - /// Sync session context window from AI config without requiring an explicit model_id. - /// - /// Subagent sessions created via `build_session_config_for_workspace` use - /// `SessionConfig::default()` which hardcodes `max_context_tokens: 128128`. - /// This method reloads the AI config and updates `max_context_tokens` to the - /// model's actual configured `context_window`, so subagents with large-context - /// models are not prematurely capped. + /// Refresh the legacy session window snapshot for existing session consumers. + /// Request budgets are resolved independently from the active model or pool. pub async fn refresh_session_context_window(&self, session_id: &str) -> OpenBitFunResult<()> { let config = self .get_session(session_id) diff --git a/src/crates/execution/agent-runtime/src/session.rs b/src/crates/execution/agent-runtime/src/session.rs index 98f315bf8f..8c886faa6d 100644 --- a/src/crates/execution/agent-runtime/src/session.rs +++ b/src/crates/execution/agent-runtime/src/session.rs @@ -184,6 +184,9 @@ impl From for openbitfun_runtime_ports::AgentSessionCreateResult { /// Session configuration #[derive(Debug, Clone, Serialize, Deserialize)] pub struct SessionConfig { + /// Legacy context window snapshot required by older readers of session state. + /// It may still hold the 128128 fallback. Resolve request budgets from the + /// active model's context window or the model pool's shared budget. pub max_context_tokens: usize, pub auto_compact: bool, pub enable_tools: bool,