fix: ensure reasoning_content on all Kimi assistant+tool_calls messages

Add a safety-net pass in create_request() that ensures every assistant
message with tool_calls has a reasoning_content field for Kimi thinking
models. This handles edge cases where thinking content was stripped by
compaction, tool-pair summarization, or not returned by the model.

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

@@ -836,11 +836,28 @@ pub fn create_request(
         "content": system
     });
 
-    let messages_spec = format_messages(messages, image_format);
+    let mut messages_spec = format_messages(messages, image_format);
     let mut tools_spec = format_tools(tools)?;
 
     validate_tool_schemas(&mut tools_spec);
 
+    // Safety net: Kimi thinking models require reasoning_content on every
+    // assistant message with tool_calls. Add empty reasoning_content if missing,
+    // which handles edge cases where thinking content was stripped by compaction,
+    // tool-pair summarization, or simply not returned by the model.
+    if is_kimi_thinking {
+        for msg in &mut messages_spec {
+            let is_assistant = msg.get("role").and_then(|v| v.as_str()) == Some("assistant");
+            let has_tool_calls = msg.get("tool_calls").is_some();
+            let has_reasoning = msg.get("reasoning_content").is_some();
+            if is_assistant && has_tool_calls && !has_reasoning {
+                msg.as_object_mut()
+                    .unwrap()
+                    .insert("reasoning_content".to_string(), json!(""));
+            }
+        }
+    }
+
     let mut messages_array = vec![system_message];
     messages_array.extend(messages_spec);
 
@@ -2115,4 +2132,50 @@ data: [DONE]
 
         Ok(())
     }
+
+    #[test]
+    fn test_create_request_kimi_ensures_reasoning_content() -> anyhow::Result<()> {
+        let model_config = ModelConfig {
+            model_name: "kimi-k2.5".to_string(),
+            context_limit: Some(131072),
+            temperature: None,
+            max_tokens: None,
+            toolshim: false,
+            toolshim_model: None,
+            fast_model: None,
+            request_params: None,
+        };
+
+        // Create an assistant message with a tool call but NO thinking content.
+        // This simulates edge cases where thinking was stripped (compaction,
+        // tool-pair summarization) or never returned by the model.
+        let msg = Message::assistant().with_tool_request(
+            "call_1",
+            Ok(CallToolRequestParams {
+                meta: None,
+                task: None,
+                name: "test_tool".into(),
+                arguments: Some(object!({"key": "value"})),
+            }),
+        );
+
+        let request = create_request(
+            &model_config,
+            "system",
+            &[Message::user().with_text("hello"), msg],
+            &[],
+            &ImageFormat::OpenAi,
+            false,
+        )?;
+
+        let messages = request["messages"].as_array().unwrap();
+        // messages[0] = system, messages[1] = user, messages[2] = assistant with tool_calls
+        let assistant_msg = &messages[2];
+        assert_eq!(assistant_msg["role"], "assistant");
+        assert!(assistant_msg.get("tool_calls").is_some());
+        // Safety net should have added reasoning_content
+        assert_eq!(assistant_msg.get("reasoning_content").unwrap(), &json!(""));
+
+        Ok(())
+    }
 }