fix(tool_parser): serialize tool-call arguments with vLLM/json.dumps spacing

crates/tool_parser/src/parsers/deepseek_dsml.rs

@@ -232,7 +232,7 @@ impl DeepSeekDsmlParser {
             }
         }
 
-        serde_json::to_string(&Value::Object(params)).unwrap_or_else(|_| "{}".to_string())
+        helpers::args_to_json_string(&Value::Object(params)).unwrap_or_else(|_| "{}".to_string())
     }
 
     /// Parse a single complete invoke block into a ToolCall

crates/tool_parser/src/parsers/helpers.rs

@@ -394,6 +394,54 @@ pub(crate) fn handle_json_tool_streaming(
     Ok(result)
 }
 
+/// serde_json formatter with Python `json.dumps` separators (`", "` / `": "`).
+struct SpacedFormatter;
+
+impl serde_json::ser::Formatter for SpacedFormatter {
+    fn begin_array_value<W: ?Sized + std::io::Write>(
+        &mut self,
+        writer: &mut W,
+        first: bool,
+    ) -> std::io::Result<()> {
+        if first {
+            Ok(())
+        } else {
+            writer.write_all(b", ")
+        }
+    }
+
+    fn begin_object_key<W: ?Sized + std::io::Write>(
+        &mut self,
+        writer: &mut W,
+        first: bool,
+    ) -> std::io::Result<()> {
+        if first {
+            Ok(())
+        } else {
+            writer.write_all(b", ")
+        }
+    }
+
+    fn begin_object_value<W: ?Sized + std::io::Write>(
+        &mut self,
+        writer: &mut W,
+    ) -> std::io::Result<()> {
+        writer.write_all(b": ")
+    }
+}
+
+/// Serialize tool-call arguments like Python `json.dumps` (spaced separators), so
+/// they match vLLM — chat templates emit `arguments` verbatim, so compact vs spaced
+/// would diverge the prompt across multi-turn tool calls.
+pub fn args_to_json_string<T: serde::Serialize>(value: &T) -> ParserResult<String> {
+    let mut buf = Vec::new();
+    let mut ser = serde_json::Serializer::with_formatter(&mut buf, SpacedFormatter);
+    value
+        .serialize(&mut ser)
+        .map_err(|e| ParserError::ParsingFailed(e.to_string()))?;
+    Ok(String::from_utf8_lossy(&buf).into_owned())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/tool_parser/src/parsers/minimax_m2.rs

@@ -160,7 +160,7 @@ impl MinimaxM2Parser {
             let param_types = helpers::param_types_for_function(tools, func_name);
             let parameters = self.parse_parameters(params_text, &param_types);
 
-            match serde_json::to_string(&parameters) {
+            match helpers::args_to_json_string(&parameters) {
                 Ok(arguments_str) => calls.push(ToolCall {
                     function: FunctionCall {
                         name: func_name.to_string(),

crates/tool_parser/src/parsers/qwen_xml.rs

@@ -216,8 +216,7 @@ impl QwenXmlParser {
             }
         }
 
-        let arguments = serde_json::to_string(&parameters)
-            .map_err(|e| ParserError::ParsingFailed(e.to_string()))?;
+        let arguments = helpers::args_to_json_string(&parameters)?;
 
         Ok(Some(ToolCall {
             function: FunctionCall {

crates/tool_parser/tests/tool_parser_minimax_m2.rs

@@ -965,3 +965,23 @@ async fn test_minimax_invalid_json_in_parameters() {
 
     assert_eq!(normal_text, "");
 }
+
+#[tokio::test]
+async fn test_minimax_arguments_use_python_json_spacing() {
+    // Spaced separators (", " / ": "), matching vLLM's json.dumps.
+    let parser = MinimaxM2Parser::new();
+    let input = r#"<minimax:tool_call>
+<invoke name="get_weather">
+<parameter name="city">Tokyo</parameter>
+<parameter name="units">celsius</parameter>
+</invoke>
+</minimax:tool_call>"#;
+    let (_n, tools) = parser.parse_complete(input).await.unwrap();
+    assert_eq!(tools.len(), 1);
+    let a = &tools[0].function.arguments;
+    assert!(
+        a.contains("\": \""),
+        "expected spaced key/value separators, got {a}"
+    );
+    assert!(!a.contains("\":\""), "must not be compact, got {a}");
+}