fix: stop merging tool calls across step boundaries in format_messages

The parallel tool call merge (merge #2) was too aggressive — it merged
assistant+tool_call messages across separate model response boundaries.
When a multi-step conversation had reasoning_content on each step's
assistant message, merge #2 combined all tool_calls into a single
assistant message, losing reasoning_content from later steps and
creating an invalid conversation structure for Kimi thinking models.

The fix adds a check: stop merging when the next assistant message has
reasoning_content, which indicates a new model response rather than a
split parallel tool call from the same response.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Signed-off-by: Harrison <hcstebbins@gmail.com>

Author: stebbins

crates/goose/src/providers/formats/openai.rs

@@ -325,7 +325,8 @@ pub fn format_messages(messages: &[Message], image_format: &ImageFormat) -> Vec<
             let next_is_assistant_tc = messages_spec[end + 1].get("role").and_then(|v| v.as_str())
                 == Some("assistant")
                 && messages_spec[end + 1].get("tool_calls").is_some()
-                && messages_spec[end + 1].get("content").is_none();
+                && messages_spec[end + 1].get("content").is_none()
+                && messages_spec[end + 1].get("reasoning_content").is_none();
 
             if is_tool && next_is_assistant_tc {
                 end += 2;
@@ -2084,6 +2085,110 @@ data: [DONE]
         Ok(())
     }
 
+    #[test]
+    fn test_format_messages_multi_step_tool_calls_not_merged() -> anyhow::Result<()> {
+        // Simulates a 2-step conversation where both steps have reasoning + tool calls.
+        // The agent splits each step into: thinking_msg, tool_msg, resp_msg, ...
+        // Merge #2 should NOT merge across step boundaries.
+
+        // Step 1: reasoning + 2 parallel tool calls
+        let thinking1 = Message::new(
+            Role::Assistant,
+            chrono::Utc::now().timestamp(),
+            vec![MessageContent::thinking("Step 1 reasoning", "")],
+        );
+        let tool1a = Message::assistant().with_tool_request(
+            "tc1a",
+            Ok(CallToolRequestParams {
+                meta: None,
+                task: None,
+                name: "shell".into(),
+                arguments: Some(object!({"command": "ls"})),
+            }),
+        );
+        let resp1a = Message::user().with_tool_response(
+            "tc1a".to_string(),
+            Ok(CallToolResult {
+                content: vec![Content::text("file1.txt")],
+                structured_content: None,
+                is_error: Some(false),
+                meta: None,
+            }),
+        );
+        let tool1b = Message::assistant().with_tool_request(
+            "tc1b",
+            Ok(CallToolRequestParams {
+                meta: None,
+                task: None,
+                name: "shell".into(),
+                arguments: Some(object!({"command": "pwd"})),
+            }),
+        );
+        let resp1b = Message::user().with_tool_response(
+            "tc1b".to_string(),
+            Ok(CallToolResult {
+                content: vec![Content::text("/home")],
+                structured_content: None,
+                is_error: Some(false),
+                meta: None,
+            }),
+        );
+
+        // Step 2: new reasoning + 1 tool call (this is a NEW model response)
+        let thinking2 = Message::new(
+            Role::Assistant,
+            chrono::Utc::now().timestamp(),
+            vec![MessageContent::thinking("Step 2 reasoning", "")],
+        );
+        let tool2 = Message::assistant().with_tool_request(
+            "tc2",
+            Ok(CallToolRequestParams {
+                meta: None,
+                task: None,
+                name: "shell".into(),
+                arguments: Some(object!({"command": "cat result.txt"})),
+            }),
+        );
+        let resp2 = Message::user().with_tool_response(
+            "tc2".to_string(),
+            Ok(CallToolResult {
+                content: vec![Content::text("done")],
+                structured_content: None,
+                is_error: Some(false),
+                meta: None,
+            }),
+        );
+
+        let spec = format_messages(
+            &[thinking1, tool1a, resp1a, tool1b, resp1b, thinking2, tool2, resp2],
+            &ImageFormat::OpenAi,
+        );
+
+        // Step 1: assistant(reasoning1 + tc1a, tc1b) + 2 tool responses = 3
+        // Step 2: assistant(reasoning2 + tc2) + 1 tool response = 2
+        // Total = 5
+        assert_eq!(spec.len(), 5, "Expected 5 messages, got {}: {:#?}", spec.len(), spec);
+
+        // Step 1 assistant: reasoning1 + 2 tool_calls
+        assert_eq!(spec[0]["role"], "assistant");
+        assert_eq!(spec[0]["reasoning_content"], "Step 1 reasoning");
+        assert_eq!(spec[0]["tool_calls"].as_array().unwrap().len(), 2);
+
+        // Step 1 tool responses
+        assert_eq!(spec[1]["role"], "tool");
+        assert_eq!(spec[2]["role"], "tool");
+
+        // Step 2 assistant: reasoning2 + 1 tool_call (NOT merged with step 1)
+        assert_eq!(spec[3]["role"], "assistant");
+        assert_eq!(spec[3]["reasoning_content"], "Step 2 reasoning");
+        assert_eq!(spec[3]["tool_calls"].as_array().unwrap().len(), 1);
+
+        // Step 2 tool response
+        assert_eq!(spec[4]["role"], "tool");
+
+        Ok(())
+    }
+
     #[test]
     fn test_create_request_kimi_thinking_defaults() -> anyhow::Result<()> {
         let model_config = ModelConfig {