From c81564584190da4bd00178fd01316912119bdd37 Mon Sep 17 00:00:00 2001 From: filip <44206832+filipkujawa@users.noreply.github.com> Date: Tue, 22 Sep 2026 18:50:04 +0000 Subject: [PATCH] fix(agents): auto-compact at tool boundaries in the unrolled agent loop (#12444) Signed-off-by: Filip Kujawa --- .../agents/state_machine/ops_compaction.rs | 52 +++++++++++++++++-- .../src/agents/state_machine/ops_recipe.rs | 2 +- .../goose/src/agents/state_machine/usage.rs | 2 +- crates/goose/src/context_mgmt/mod.rs | 9 ++-- 4 files changed, 53 insertions(+), 12 deletions(-) diff --git a/crates/goose/src/agents/state_machine/ops_compaction.rs b/crates/goose/src/agents/state_machine/ops_compaction.rs index a86a9debd..da37ac7dc 100644 --- a/crates/goose/src/agents/state_machine/ops_compaction.rs +++ b/crates/goose/src/agents/state_machine/ops_compaction.rs @@ -1,5 +1,6 @@ //! Compacts conversation history when it is too large for the configured context window. +use std::collections::HashSet; use std::sync::Arc; use anyhow::{anyhow, Result}; @@ -7,13 +8,16 @@ use async_trait::async_trait; use tracing_futures::Instrument; use crate::agents::state_machine::ops_llm::{chat_span, record_chat_usage}; +use crate::agents::state_machine::ops_recipe::RecipeOperation; use crate::agents::state_machine::{ applied, last_effective_role, messages_since_kickoff, not_applicable, trailing_error, yielded, yielded_with, ConversationEffect, Emitter, GooseEffect, Operation, OperationResult, SlashCommand, }; -use crate::context_mgmt::compact_messages; -use crate::conversation::message::{Message, MessageErrorKind, SystemNotificationType}; +use crate::context_mgmt::{compact_messages, count_context_tokens}; +use crate::conversation::message::{ + Message, MessageContent, MessageErrorKind, SystemNotificationType, +}; use crate::conversation::{Conversation, EffectiveRole}; use crate::providers::base::Provider; use crate::session::Session; @@ -44,6 +48,36 @@ fn compaction_part( )) } +/// Several operations answer parts of one tool batch in separate messages, so a +/// tool tail alone does not mean the batch is complete. +fn awaits_tool_responses(messages: &[Message]) -> bool { + let answered: HashSet<&str> = messages + .iter() + .flat_map(Message::get_tool_response_ids) + .collect(); + messages + .iter() + .flat_map(|message| &message.content) + .filter_map(MessageContent::as_tool_request) + .any(|request| { + !request.was_executed_externally() && !answered.contains(request.id.as_str()) + }) +} + +/// Reported usage stops at the inference that requested the tools, so the +/// results that answered it are not counted until the next request. +async fn unreported_tool_tokens(conversation: &Conversation) -> Result { + let messages = conversation.messages(); + if last_effective_role(messages)? != EffectiveRole::Tool { + return Ok(0); + } + let after_request = messages + .iter() + .rposition(Message::is_tool_call) + .map_or(0, |index| index + 1); + count_context_tokens(&messages[after_request..]).await +} + pub struct CompactionOperation { provider: Arc, model_config: ModelConfig, @@ -78,8 +112,8 @@ impl CompactionOperation { async fn context_tokens(&self, session: &Session, conversation: &Conversation) -> Result { match session.usage.total_tokens { - Some(tokens) => Ok(tokens), - None => crate::context_mgmt::count_context_tokens(conversation).await, + Some(tokens) => Ok(tokens + unreported_tool_tokens(conversation).await?), + None => count_context_tokens(conversation.messages()).await, } } @@ -244,7 +278,15 @@ impl Operation for CompactionOperation { return not_applicable(); } } else { - if last_effective_role(messages)? != EffectiveRole::User { + // Compact only ahead of an inference. An assistant tail ends the turn or + // awaits tool responses, hiding an unanswered request orphans its result, + // and RecipeOperation delivers a successful final output from a tool tail. + let tail = last_effective_role(messages)?; + if tail == EffectiveRole::Assistant + || awaits_tool_responses(messages) + || (tail == EffectiveRole::Tool + && RecipeOperation::successful_final_output(messages).is_some()) + { return not_applicable(); } let tokens = self.context_tokens(session, conversation).await?; diff --git a/crates/goose/src/agents/state_machine/ops_recipe.rs b/crates/goose/src/agents/state_machine/ops_recipe.rs index 92e031ae6..d0dfc87b0 100644 --- a/crates/goose/src/agents/state_machine/ops_recipe.rs +++ b/crates/goose/src/agents/state_machine/ops_recipe.rs @@ -105,7 +105,7 @@ impl RecipeOperation { }) } - fn successful_final_output(messages: &[Message]) -> Option { + pub(super) fn successful_final_output(messages: &[Message]) -> Option { let answered_responses: HashSet<&str> = messages .iter() .flat_map(|message| &message.content) diff --git a/crates/goose/src/agents/state_machine/usage.rs b/crates/goose/src/agents/state_machine/usage.rs index 04fb4e3a0..36558f822 100644 --- a/crates/goose/src/agents/state_machine/usage.rs +++ b/crates/goose/src/agents/state_machine/usage.rs @@ -79,6 +79,6 @@ pub(super) async fn record( } pub(super) async fn estimate_context(conversation: &Conversation) -> Result { - let tokens = crate::context_mgmt::count_context_tokens(conversation).await?; + let tokens = crate::context_mgmt::count_context_tokens(conversation.messages()).await?; Ok(TokenUsage::new(Some(tokens), None, Some(tokens))) } diff --git a/crates/goose/src/context_mgmt/mod.rs b/crates/goose/src/context_mgmt/mod.rs index a206133f1..a4fa3d8e2 100644 --- a/crates/goose/src/context_mgmt/mod.rs +++ b/crates/goose/src/context_mgmt/mod.rs @@ -191,7 +191,7 @@ pub async fn compact_messages( } let conversation = Conversation::new_unvalidated(final_messages); - let retained_context_tokens = match count_context_tokens(&conversation).await { + let retained_context_tokens = match count_context_tokens(conversation.messages()).await { Ok(tokens) => tokens, Err(error) => { warn!("Failed to count retained context tokens, using billable output tokens: {error}"); @@ -206,14 +206,13 @@ pub async fn compact_messages( }) } -/// Estimate the tokens of the agent-visible conversation, counted the same way +/// Estimate the tokens of the agent-visible messages, counted the same way /// as the fallback estimation in `check_if_compaction_needed`. -pub(crate) async fn count_context_tokens(conversation: &Conversation) -> Result { +pub(crate) async fn count_context_tokens(messages: &[Message]) -> Result { let counter = create_token_counter() .await .map_err(|error| anyhow::anyhow!("Failed to create token counter: {error}"))?; - let total: usize = conversation - .messages() + let total: usize = messages .iter() .filter(|message| message.is_agent_visible()) .map(|message| counter.count_chat_tokens("", std::slice::from_ref(message), &[]))