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,