chore: clippy fmt

Signed-off-by: Elyas Mehtabuddin <[email protected]>

Author: elyasmnvidian

lib/llm/src/protocols/openai/chat_completions/aggregator.rs

@@ -639,7 +639,8 @@ mod tests {
     #[tokio::test]
     async fn test_tool_calling_finish_reason_override_from_stop() {
         // Test that when tool calls are present but finish reason is Stop, it gets overridden to ToolCalls
-        let tool_call_json = r#"{"name": "get_weather", "arguments": {"location": "New York", "unit": "celsius"}}"#;
+        let tool_call_json =
+            r#"{"name": "get_weather", "arguments": {"location": "New York", "unit": "celsius"}}"#;
 
         let annotated_delta = create_test_delta(
             0,
@@ -909,7 +910,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_tool_calling_finish_reason_override_from_stop() {
+    async fn test_tool_calling_finish_reason_override_from_stop_alternative() {
         // Test that when tool calls are present but finish reason is Stop, it gets overridden to ToolCalls
         let tool_call_json =
             r#"{"name": "get_weather", "arguments": {"location": "New York", "unit": "celsius"}}"#;

lib/parsers/src/tool_calling/harmony/harmony_parser.rs

@@ -185,25 +185,22 @@ pub fn detect_tool_call_start_harmony(
 
         // Check for partial start tokens (streaming scenario)
         // This handles cases where start tokens are split across multiple chunks
-        config
-            .tool_call_start_tokens
-            .iter()
-            .any(|token| {
-                if token.is_empty() {
-                    return false;
-                }
-                // Check if the chunk could be a prefix of this start token
-                // Handle Unicode character boundaries properly
-                for i in 1..=token.chars().count() {
-                    if let Some(prefix) = token.chars().take(i).collect::<String>().get(..) {
-                        let prefix_str = &prefix[..prefix.len()];
-                        if trimmed == prefix_str || trimmed.ends_with(prefix_str) {
-                            return true;
-                        }
+        config.tool_call_start_tokens.iter().any(|token| {
+            if token.is_empty() {
+                return false;
+            }
+            // Check if the chunk could be a prefix of this start token
+            // Handle Unicode character boundaries properly
+            for i in 1..=token.chars().count() {
+                if let Some(prefix) = token.chars().take(i).collect::<String>().get(..) {
+                    let prefix_str = &prefix[..prefix.len()];
+                    if trimmed == prefix_str || trimmed.ends_with(prefix_str) {
+                        return true;
                     }
                 }
-                false
-            })
+            }
+            false
+        })
     } else {
         // Non-strict mode: check complete tokens and some heuristics
         let has_complete_token = config
@@ -216,25 +213,22 @@ pub fn detect_tool_call_start_harmony(
         }
 
         // Check for partial start tokens or known patterns
-        let has_partial_token = config
-            .tool_call_start_tokens
-            .iter()
-            .any(|token| {
-                if token.is_empty() {
-                    return false;
-                }
-                // Check if the chunk could be a prefix of this start token
-                // Handle Unicode character boundaries properly
-                for i in 1..=token.chars().count() {
-                    if let Some(prefix) = token.chars().take(i).collect::<String>().get(..) {
-                        let prefix_str = &prefix[..prefix.len()];
-                        if trimmed == prefix_str || trimmed.ends_with(prefix_str) {
-                            return true;
-                        }
+        let has_partial_token = config.tool_call_start_tokens.iter().any(|token| {
+            if token.is_empty() {
+                return false;
+            }
+            // Check if the chunk could be a prefix of this start token
+            // Handle Unicode character boundaries properly
+            for i in 1..=token.chars().count() {
+                if let Some(prefix) = token.chars().take(i).collect::<String>().get(..) {
+                    let prefix_str = &prefix[..prefix.len()];
+                    if trimmed == prefix_str || trimmed.ends_with(prefix_str) {
+                        return true;
                     }
                 }
-                false
-            });
+            }
+            false
+        });
 
         has_partial_token || trimmed.contains("<|channel|>")
     }
@@ -393,13 +387,31 @@ mod detect_parser_tests {
         };
 
         // Test various partial prefixes in strict mode
-        assert!(detect_tool_call_start_harmony("<", &config, true), "'<' should be detected as potential start");
-        assert!(detect_tool_call_start_harmony("<|", &config, true), "'<|' should be detected as potential start");
-        assert!(detect_tool_call_start_harmony("<|start|>", &config, true), "'<|start|>' should be detected as potential start");
-        assert!(detect_tool_call_start_harmony("<|start|>assistant", &config, true), "'<|start|>assistant' should be detected as potential start");
+        assert!(
+            detect_tool_call_start_harmony("<", &config, true),
+            "'<' should be detected as potential start"
+        );
+        assert!(
+            detect_tool_call_start_harmony("<|", &config, true),
+            "'<|' should be detected as potential start"
+        );
+        assert!(
+            detect_tool_call_start_harmony("<|start|>", &config, true),
+            "'<|start|>' should be detected as potential start"
+        );
+        assert!(
+            detect_tool_call_start_harmony("<|start|>assistant", &config, true),
+            "'<|start|>assistant' should be detected as potential start"
+        );
 
         // Test that unrelated text is not detected in strict mode
-        assert!(!detect_tool_call_start_harmony("hello world", &config, true), "'hello world' should not be detected in strict mode");
-        assert!(!detect_tool_call_start_harmony("xyz", &config, true), "'xyz' should not be detected in strict mode");
+        assert!(
+            !detect_tool_call_start_harmony("hello world", &config, true),
+            "'hello world' should not be detected in strict mode"
+        );
+        assert!(
+            !detect_tool_call_start_harmony("xyz", &config, true),
+            "'xyz' should not be detected in strict mode"
+        );
     }
 }

lib/parsers/src/tool_calling/json/base_json_parser.rs

@@ -325,26 +325,23 @@ pub fn detect_tool_call_start_basic_json(chunk: &str, config: &JsonParserConfig)
 
     // Check for partial start tokens (streaming scenario)
     // This handles cases where start tokens are split across multiple chunks
-    let has_partial_token = config
-        .tool_call_start_tokens
-        .iter()
-        .any(|token| {
-            if token.is_empty() {
-                return false;
-            }
-            // Check if the chunk could be a prefix of this start token
-            // We need to be careful to avoid false positives
-            // Handle Unicode character boundaries properly
-            for i in 1..=token.chars().count() {
-                if let Some(prefix) = token.chars().take(i).collect::<String>().get(..) {
-                    let prefix_str = &prefix[..prefix.len()];
-                    if trimmed == prefix_str || trimmed.ends_with(prefix_str) {
-                        return true;
-                    }
+    let has_partial_token = config.tool_call_start_tokens.iter().any(|token| {
+        if token.is_empty() {
+            return false;
+        }
+        // Check if the chunk could be a prefix of this start token
+        // We need to be careful to avoid false positives
+        // Handle Unicode character boundaries properly
+        for i in 1..=token.chars().count() {
+            if let Some(prefix) = token.chars().take(i).collect::<String>().get(..) {
+                let prefix_str = &prefix[..prefix.len()];
+                if trimmed == prefix_str || trimmed.ends_with(prefix_str) {
+                    return true;
                 }
             }
-            false
-        });
+        }
+        false
+    });
 
     has_partial_token || trimmed.contains('{') || trimmed.contains('[')
 }
@@ -475,7 +472,10 @@ mod detect_parser_tests {
             ..Default::default()
         };
         let result = detect_tool_call_start_basic_json(text, &config);
-        assert!(result, "Should detect 'fun' as potential start of 'functools'");
+        assert!(
+            result,
+            "Should detect 'fun' as potential start of 'functools'"
+        );
     }
 
     #[test]
@@ -487,7 +487,10 @@ mod detect_parser_tests {
             ..Default::default()
         };
         let result = detect_tool_call_start_basic_json(text, &config);
-        assert!(result, "Should detect 'func' as potential start of 'functools'");
+        assert!(
+            result,
+            "Should detect 'func' as potential start of 'functools'"
+        );
     }
 
     #[test]
@@ -499,7 +502,10 @@ mod detect_parser_tests {
             ..Default::default()
         };
         let result = detect_tool_call_start_basic_json(text, &config);
-        assert!(result, "Should detect 'f' as potential start of 'functools'");
+        assert!(
+            result,
+            "Should detect 'f' as potential start of 'functools'"
+        );
     }
 
     #[test]
@@ -512,7 +518,10 @@ mod detect_parser_tests {
             ..Default::default()
         };
         let result = detect_tool_call_start_basic_json(text, &config);
-        assert!(result, "Should detect text ending with 'fun' as potential tool call start");
+        assert!(
+            result,
+            "Should detect text ending with 'fun' as potential tool call start"
+        );
     }
 
     #[test]
@@ -540,6 +549,9 @@ mod detect_parser_tests {
             ..Default::default()
         };
         let result = detect_tool_call_start_basic_json(text, &config);
-        assert!(!result, "Should not detect unrelated text as tool call start");
+        assert!(
+            !result,
+            "Should not detect unrelated text as tool call start"
+        );
     }
 }

lib/parsers/src/tool_calling/json/deepseek_parser.rs

@@ -119,25 +119,22 @@ pub fn detect_tool_call_start_deepseek_v3_1(chunk: &str, config: &JsonParserConf
 
     // Check for partial start tokens (streaming scenario)
     // This handles cases where start tokens are split across multiple chunks
-    config
-        .tool_call_start_tokens
-        .iter()
-        .any(|token| {
-            if token.is_empty() {
-                return false;
-            }
-            // Check if the chunk could be a prefix of this start token
-            // Handle Unicode character boundaries properly
-            for i in 1..=token.chars().count() {
-                if let Some(prefix) = token.chars().take(i).collect::<String>().get(..) {
-                    let prefix_str = &prefix[..prefix.len()];
-                    if trimmed == prefix_str || trimmed.ends_with(prefix_str) {
-                        return true;
-                    }
+    config.tool_call_start_tokens.iter().any(|token| {
+        if token.is_empty() {
+            return false;
+        }
+        // Check if the chunk could be a prefix of this start token
+        // Handle Unicode character boundaries properly
+        for i in 1..=token.chars().count() {
+            if let Some(prefix) = token.chars().take(i).collect::<String>().get(..) {
+                let prefix_str = &prefix[..prefix.len()];
+                if trimmed == prefix_str || trimmed.ends_with(prefix_str) {
+                    return true;
                 }
             }
-            false
-        })
+        }
+        false
+    })
 }
 
 #[cfg(test)]
@@ -304,13 +301,31 @@ mod detect_parser_tests {
         };
 
         // Test various partial prefixes
-        assert!(detect_tool_call_start_deepseek_v3_1("<", &config), "'<' should be detected as potential start");
-        assert!(detect_tool_call_start_deepseek_v3_1("<｜", &config), "'<｜' should be detected as potential start");
-        assert!(detect_tool_call_start_deepseek_v3_1("<｜tool", &config), "'<｜tool' should be detected as potential start");
-        assert!(detect_tool_call_start_deepseek_v3_1("<｜tool▁calls", &config), "'<｜tool▁calls' should be detected as potential start");
+        assert!(
+            detect_tool_call_start_deepseek_v3_1("<", &config),
+            "'<' should be detected as potential start"
+        );
+        assert!(
+            detect_tool_call_start_deepseek_v3_1("<｜", &config),
+            "'<｜' should be detected as potential start"
+        );
+        assert!(
+            detect_tool_call_start_deepseek_v3_1("<｜tool", &config),
+            "'<｜tool' should be detected as potential start"
+        );
+        assert!(
+            detect_tool_call_start_deepseek_v3_1("<｜tool▁calls", &config),
+            "'<｜tool▁calls' should be detected as potential start"
+        );
 
         // Test that unrelated text is not detected
-        assert!(!detect_tool_call_start_deepseek_v3_1("hello world", &config), "'hello world' should not be detected");
-        assert!(!detect_tool_call_start_deepseek_v3_1("xyz", &config), "'xyz' should not be detected");
+        assert!(
+            !detect_tool_call_start_deepseek_v3_1("hello world", &config),
+            "'hello world' should not be detected"
+        );
+        assert!(
+            !detect_tool_call_start_deepseek_v3_1("xyz", &config),
+            "'xyz' should not be detected"
+        );
     }
 }