fix: add provider-aware message splitting to fix Moonshot thinking model errors

Moonshot's kimi-k2-thinking model requires a single assistant message with
all tool_calls and reasoning_content together. The previous code always split
thinking and tool calls into separate messages (needed by Gemini), which broke
Moonshot with "reasoning_content is missing" errors.

Add `should_split_tool_messages()` to the Provider trait (default false) and
override it to true only for Google/Gemini/GcpVertexAI providers. When false,
the agent keeps the original response message intact and appends tool responses
after it.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: stebbins

crates/goose/src/agents/agent.rs

@@ -1417,36 +1417,56 @@ impl Agent {
                                     }
                                 }
 
-                                // Preserve thinking content from the original response
-                                // Gemini (and other thinking models) require thinking to be echoed back
-                                let thinking_content: Vec<MessageContent> = response.content.iter()
-                                    .filter(|c| matches!(c, MessageContent::Thinking(_)))
-                                    .cloned()
-                                    .collect();
-                                if !thinking_content.is_empty() {
-                                    let thinking_msg = Message::new(
-                                        response.role.clone(),
-                                        response.created,
-                                        thinking_content,
-                                    ).with_id(format!("msg_{}", Uuid::new_v4()));
-                                    messages_to_add.push(thinking_msg);
-                                }
+                                let should_split = self.provider().await
+                                    .map(|p| p.should_split_tool_messages())
+                                    .unwrap_or(false);
+
+                                if should_split {
+                                    // Split mode (Google/Gemini): separate thinking and individual
+                                    // tool call messages. Gemini requires thinking to be echoed back
+                                    // as a separate message, and each tool call in its own message.
+                                    let thinking_content: Vec<MessageContent> = response.content.iter()
+                                        .filter(|c| matches!(c, MessageContent::Thinking(_)))
+                                        .cloned()
+                                        .collect();
+                                    if !thinking_content.is_empty() {
+                                        let thinking_msg = Message::new(
+                                            response.role.clone(),
+                                            response.created,
+                                            thinking_content,
+                                        ).with_id(format!("msg_{}", Uuid::new_v4()));
+                                        messages_to_add.push(thinking_msg);
+                                    }
 
-                                for (idx, request) in frontend_requests.iter().chain(remaining_requests.iter()).enumerate() {
-                                    if request.tool_call.is_ok() {
-                                        let request_msg = Message::assistant()
-                                            .with_id(format!("msg_{}", Uuid::new_v4()))
-                                            .with_tool_request_with_metadata(
-                                                request.id.clone(),
-                                                request.tool_call.clone(),
-                                                request.metadata.as_ref(),
-                                                request.tool_meta.clone(),
-                                            );
-                                        messages_to_add.push(request_msg);
-                                        let final_response = tool_response_messages[idx]
-                                                                .lock().await.clone();
-                                        yield AgentEvent::Message(final_response.clone());
-                                        messages_to_add.push(final_response);
+                                    for (idx, request) in frontend_requests.iter().chain(remaining_requests.iter()).enumerate() {
+                                        if request.tool_call.is_ok() {
+                                            let request_msg = Message::assistant()
+                                                .with_id(format!("msg_{}", Uuid::new_v4()))
+                                                .with_tool_request_with_metadata(
+                                                    request.id.clone(),
+                                                    request.tool_call.clone(),
+                                                    request.metadata.as_ref(),
+                                                    request.tool_meta.clone(),
+                                                );
+                                            messages_to_add.push(request_msg);
+                                            let final_response = tool_response_messages[idx]
+                                                                    .lock().await.clone();
+                                            yield AgentEvent::Message(final_response.clone());
+                                            messages_to_add.push(final_response);
+                                        }
+                                    }
+                                } else {
+                                    // Non-split mode (OpenAI-compatible providers including Moonshot):
+                                    // Keep the original response message intact with all tool_calls
+                                    // and reasoning_content together, then append tool responses.
+                                    messages_to_add.push(response.clone());
+                                    for (idx, request) in frontend_requests.iter().chain(remaining_requests.iter()).enumerate() {
+                                        if request.tool_call.is_ok() {
+                                            let final_response = tool_response_messages[idx]
+                                                                    .lock().await.clone();
+                                            yield AgentEvent::Message(final_response.clone());
+                                            messages_to_add.push(final_response);
+                                        }
                                     }
                                 }
 

crates/goose/src/providers/base.rs

@@ -563,6 +563,19 @@ pub trait Provider: Send + Sync {
         false
     }
 
+    /// Whether tool call messages should be split into individual messages.
+    ///
+    /// When true (Google/Gemini providers), the agent splits a response with thinking + multiple
+    /// tool calls into separate messages: one thinking message and one message per tool call.
+    /// This is required because Gemini expects thinking content to be echoed back separately.
+    ///
+    /// When false (default, OpenAI-compatible providers), the original response message is kept
+    /// intact with all tool calls and reasoning content together. This is required by providers
+    /// like Moonshot that expect a single assistant message with all tool_calls and reasoning_content.
+    fn should_split_tool_messages(&self) -> bool {
+        false
+    }
+
     /// Get the currently active model name
     /// For regular providers, this returns the configured model
     /// For LeadWorkerProvider, this returns the currently active model (lead or worker)

crates/goose/src/providers/gcpvertexai.rs

@@ -648,6 +648,10 @@ impl Provider for GcpVertexAIProvider {
         true
     }
 
+    fn should_split_tool_messages(&self) -> bool {
+        true
+    }
+
     async fn stream(
         &self,
         session_id: &str,

crates/goose/src/providers/gemini_cli.rs

@@ -268,6 +268,10 @@ impl Provider for GeminiCliProvider {
         self.model.clone()
     }
 
+    fn should_split_tool_messages(&self) -> bool {
+        true
+    }
+
     #[tracing::instrument(
         skip(self, _model_config, system, messages, tools),
         fields(model_config, input, output, input_tokens, output_tokens, total_tokens)

crates/goose/src/providers/google.rs

@@ -211,6 +211,10 @@ impl Provider for GoogleProvider {
         true
     }
 
+    fn should_split_tool_messages(&self) -> bool {
+        true
+    }
+
     async fn stream(
         &self,
         session_id: &str,