From dad453726ef1834ce633b59a0d09a7a0f5e64a45 Mon Sep 17 00:00:00 2001 From: Jack Amadeo Date: Mon, 28 Sep 2026 16:55:14 +0000 Subject: [PATCH] don't emit warning when ending on a successful tool call (#12468) --- crates/goose-agent/src/inference.rs | 69 ++++++++++++++++++++++++++--- crates/goose/src/agents/agent.rs | 5 ++- 2 files changed, 66 insertions(+), 8 deletions(-) diff --git a/crates/goose-agent/src/inference.rs b/crates/goose-agent/src/inference.rs index 6ef154bcf..8425b76e6 100644 --- a/crates/goose-agent/src/inference.rs +++ b/crates/goose-agent/src/inference.rs @@ -131,6 +131,24 @@ fn is_empty_response(message: &Message) -> bool { }) } +pub fn ends_with_successful_tool_response(messages: &[Message]) -> bool { + let Some(message) = messages.last() else { + return false; + }; + let mut responses = message + .content + .iter() + .filter_map(MessageContent::as_tool_response) + .peekable(); + responses.peek().is_some() + && responses.all(|response| { + response + .tool_result + .as_ref() + .is_ok_and(|result| !result.is_error.unwrap_or(false)) + }) +} + fn record_request_params(span: &tracing::Span, model_config: &ModelConfig) { if let Some(temperature) = model_config.temperature { span.record("gen_ai.request.temperature", temperature as f64); @@ -172,7 +190,11 @@ pub struct InferenceRunner<'a, S, E> { /// The agent-visible conversation as the provider sees it: tool requests left /// unanswered by an earlier turn are dropped, since nothing will answer them now. -fn messages_for_provider(conversation: &Conversation, turn: &[Message]) -> Vec { +fn messages_for_provider( + conversation: &Conversation, + turn: &[Message], + keep_empty_messages: bool, +) -> Vec { let answered: std::collections::HashSet<&str> = conversation .messages() .iter() @@ -194,7 +216,7 @@ fn messages_for_provider(conversation: &Conversation, turn: &[Message]) -> Vec bool { }) } +fn should_infer(conversation: &Conversation, turn: &[Message]) -> bool { + let projected = messages_for_provider(conversation, turn, true); + if projected + .last() + .is_some_and(|message| message.content.is_empty()) + { + return false; + } + ends_with_provider_turn(&messages_for_provider(conversation, turn, false)) +} + fn cancellation_response(persisted: &[Message], pending: &[Message]) -> Option { let mut answered = persisted .iter() @@ -325,8 +358,7 @@ impl Inference for InferenceRunner<'_, S, E> let Ok(turn) = messages_since_kickoff(conversation) else { return false; }; - trailing_error(conversation).is_none() - && ends_with_provider_turn(&messages_for_provider(conversation, turn)) + trailing_error(conversation).is_none() && should_infer(conversation, turn) } async fn infer( @@ -341,10 +373,10 @@ impl Inference for InferenceRunner<'_, S, E> return not_applicable(); } - let mut messages_for_provider = messages_for_provider(conversation, messages); - if !ends_with_provider_turn(&messages_for_provider) { + if !should_infer(conversation, messages) { return not_applicable(); } + let mut messages_for_provider = messages_for_provider(conversation, messages, false); let span = inference_span(self.provider.as_ref(), &self.model_config); @@ -479,6 +511,7 @@ impl Inference for InferenceRunner<'_, S, E> } let empty_response = !cancelled + && !ends_with_successful_tool_response(conversation.messages()) && !accumulator .iter() .any(|message| message.metadata.output_token_limit_reached) @@ -490,7 +523,24 @@ impl Inference for InferenceRunner<'_, S, E> return yielded_with(usage_effects); } - usage_effects.extend(accumulator.into_iter().map(|message| E::from(message))); + if ends_with_successful_tool_response(conversation.messages()) + && !accumulator + .iter() + .any(|message| message.metadata.output_token_limit_reached) + && accumulator.iter().all(is_empty_response) + { + let mut message = accumulator + .into_iter() + .last() + .unwrap_or_else(Message::assistant); + message.content.clear(); + message.metadata.user_visible = false; + message.metadata.agent_visible = true; + let message = emit.message(message).await; + usage_effects.push(E::from(message)); + } else { + usage_effects.extend(accumulator.into_iter().map(|message| E::from(message))); + } applied(usage_effects) } .instrument(span) @@ -584,4 +634,9 @@ mod tests { &Message::assistant().with_content(MessageContent::thinking("", "sig-omitted")) )); } + + #[test] + fn whitespace_only_text_is_an_empty_response() { + assert!(is_empty_response(&Message::assistant().with_text(" \n\t "))); + } } diff --git a/crates/goose/src/agents/agent.rs b/crates/goose/src/agents/agent.rs index 370662ea1..82b9e65be 100644 --- a/crates/goose/src/agents/agent.rs +++ b/crates/goose/src/agents/agent.rs @@ -6,6 +6,7 @@ use std::sync::Arc; use anyhow::{anyhow, Context, Result}; use futures::stream::BoxStream; use futures::{stream, FutureExt, StreamExt, TryStreamExt}; +use goose_agent::inference::ends_with_successful_tool_response; use tracing_futures::Instrument; use super::container::Container; @@ -3379,7 +3380,9 @@ impl Agent { session_manager.replace_conversation(&session_config.id, &conversation).await?; yield AgentEvent::HistoryReplaced(conversation.clone()); } - Ok(RetryResult::Skipped) if empty_response => { + Ok(RetryResult::Skipped) + if empty_response + && !ends_with_successful_tool_response(conversation.messages()) => { // No recipe retry configured, and this empty // turn would otherwise fall through to a // silent exit. Retry a bounded number of