Everything is streaming (#7247)

Co-authored-by: Douwe Osinga <douwe@squareup.com>
Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

crates/goose/src/agents/agent.rs

@@ -1777,6 +1777,15 @@ impl Agent {
         );
 
         tracing::info!("Calling provider to generate recipe content");
+        let model_config = {
+            let provider_guard = self.provider.lock().await;
+            let provider = provider_guard.as_ref().ok_or_else(|| {
+                let error = anyhow!("Provider not available during recipe creation");
+                tracing::error!("{}", error);
+                error
+            })?;
+            provider.get_model_config()
+        };
         let (result, _usage) = self
             .provider
             .lock()
@@ -1787,7 +1796,13 @@ impl Agent {
                 tracing::error!("{}", error);
                 error
             })?
-            .complete(session_id, &system_prompt, messages.messages(), &tools)
+            .complete(
+                &model_config,
+                session_id,
+                &system_prompt,
+                messages.messages(),
+                &tools,
+            )
             .await
             .map_err(|e| {
                 tracing::error!("Provider completion failed during recipe creation: {}", e);

crates/goose/src/agents/mcp_client.rs

@@ -242,10 +242,11 @@ impl ClientHandler for GooseClient {
             .as_deref()
             .unwrap_or("You are a general-purpose AI agent called goose");
 
+        let model_config = provider.get_model_config();
         let (response, usage) = provider
-            .complete_with_model(
-                session_id.as_deref(),
-                &provider.get_model_config(),
+            .complete(
+                &model_config,
+                session_id.as_deref().unwrap_or(""),
                 system_prompt,
                 &provider_ready_messages,
                 &[],

crates/goose/src/agents/platform_extensions/apps.rs

@@ -294,13 +294,7 @@ impl AppsManagerClient {
         model_config.max_tokens = Some(16384);
 
         let (response, _usage) = provider
-            .complete_with_model(
-                Some(session_id),
-                &model_config,
-                &system_prompt,
-                &messages,
-                &tools,
-            )
+            .complete(&model_config, session_id, &system_prompt, &messages, &tools)
             .await
             .map_err(|e| format!("LLM call failed: {}", e))?;
 
@@ -334,13 +328,7 @@ impl AppsManagerClient {
         model_config.max_tokens = Some(16384);
 
         let (response, _usage) = provider
-            .complete_with_model(
-                Some(session_id),
-                &model_config,
-                &system_prompt,
-                &messages,
-                &tools,
-            )
+            .complete(&model_config, session_id, &system_prompt, &messages, &tools)
             .await
             .map_err(|e| format!("LLM call failed: {}", e))?;
 

crates/goose/src/agents/reply_parts.rs

@@ -11,7 +11,9 @@ use super::super::agents::Agent;
 use crate::agents::platform_extensions::code_execution;
 use crate::conversation::message::{Message, MessageContent, ToolRequest};
 use crate::conversation::Conversation;
-use crate::providers::base::{stream_from_single_message, MessageStream, Provider, ProviderUsage};
+#[cfg(test)]
+use crate::providers::base::stream_from_single_message;
+use crate::providers::base::{MessageStream, Provider, ProviderUsage};
 use crate::providers::errors::ProviderError;
 use crate::providers::toolshim::{
     augment_message_with_tool_calls, convert_tool_messages_to_text,
@@ -229,35 +231,18 @@ impl Agent {
 
         // Capture errors during stream creation and return them as part of the stream
         // so they can be handled by the existing error handling logic in the agent
-        let stream_result = if provider.supports_streaming() {
-            debug!("WAITING_LLM_STREAM_START");
-            let result = provider
-                .stream(
-                    session_id,
-                    system_prompt.as_str(),
-                    messages_for_provider.messages(),
-                    &tools,
-                )
-                .await;
-            debug!("WAITING_LLM_STREAM_END");
-            result
-        } else {
-            debug!("WAITING_LLM_START");
-            let complete_result = provider
-                .complete(
-                    session_id,
-                    system_prompt.as_str(),
-                    messages_for_provider.messages(),
-                    &tools,
-                )
-                .await;
-            debug!("WAITING_LLM_END");
-
-            match complete_result {
-                Ok((message, usage)) => Ok(stream_from_single_message(message, usage)),
-                Err(e) => Err(e),
-            }
-        };
+        let model_config = provider.get_model_config();
+        debug!("WAITING_LLM_STREAM_START");
+        let stream_result = provider
+            .stream(
+                &model_config,
+                session_id,
+                system_prompt.as_str(),
+                messages_for_provider.messages(),
+                &tools,
+            )
+            .await;
+        debug!("WAITING_LLM_STREAM_END");
 
         // If there was an error creating the stream, return a stream that yields that error
         let mut stream = match stream_result {
@@ -462,18 +447,17 @@ mod tests {
             self.model_config.clone()
         }
 
-        async fn complete_with_model(
+        async fn stream(
             &self,
-            _session_id: Option<&str>,
             _model_config: &ModelConfig,
+            _session_id: &str,
             _system: &str,
             _messages: &[Message],
             _tools: &[Tool],
-        ) -> anyhow::Result<(Message, ProviderUsage), ProviderError> {
-            Ok((
-                Message::assistant().with_text("ok"),
-                ProviderUsage::new("mock".to_string(), Usage::default()),
-            ))
+        ) -> Result<MessageStream, ProviderError> {
+            let message = Message::assistant().with_text("ok");
+            let usage = ProviderUsage::new("mock".to_string(), Usage::default());
+            Ok(stream_from_single_message(message, usage))
         }
     }