fix: handle empty tool arguments for no-argument MCP tools

When the LLM calls a tool with no required arguments, it sends an empty
argument string. serde_json::from_str("") fails with "EOF while parsing
a value at line 1 column 0", which produced a __parse_error sentinel and
incorrectly incremented the malformed-args counter, eventually aborting
the agent after max_parse_retries.

Fix: check for empty/whitespace argument strings before JSON parsing and
default to {} (empty object). Applied to both the Anthropic streaming
path (where the bug manifested as __parse_error) and the OpenAI paths
(non-streaming and streaming, where the fallback was null instead of {}).

Closes #13

Author: RoyLin

core/src/llm/anthropic.rs

@@ -358,20 +358,26 @@ impl LlmClient for AnthropicClient {
                                         },
                                         AnthropicStreamEvent::ContentBlockStop { index: _ } => {
                                             if !current_tool_id.is_empty() {
-                                                let input: serde_json::Value =
-                                                serde_json::from_str(&current_tool_input)
-                                                    .unwrap_or_else(|e| {
-                                                        tracing::warn!(
-                                                            "Failed to parse tool input JSON for tool '{}': {}",
-                                                            current_tool_name, e
-                                                        );
-                                                        serde_json::json!({
-                                                            "__parse_error": format!(
-                                                                "Malformed tool arguments: {}. Raw input: {}",
-                                                                e, &current_tool_input
-                                                            )
+                                                let input: serde_json::Value = if current_tool_input
+                                                    .trim()
+                                                    .is_empty()
+                                                {
+                                                    serde_json::Value::Object(Default::default())
+                                                } else {
+                                                    serde_json::from_str(&current_tool_input)
+                                                        .unwrap_or_else(|e| {
+                                                            tracing::warn!(
+                                                                "Failed to parse tool input JSON for tool '{}': {}",
+                                                                current_tool_name, e
+                                                            );
+                                                            serde_json::json!({
+                                                                "__parse_error": format!(
+                                                                    "Malformed tool arguments: {}. Raw input: {}",
+                                                                    e, &current_tool_input
+                                                                )
+                                                            })
                                                         })
-                                                    });
+                                                };
                                                 content_blocks.push(ContentBlock::ToolUse {
                                                     id: current_tool_id.clone(),
                                                     name: current_tool_name.clone(),

core/src/llm/openai.rs

@@ -280,14 +280,18 @@ impl LlmClient for OpenAiClient {
                     content.push(ContentBlock::ToolUse {
                         id: tc.id,
                         name: tc.function.name.clone(),
-                        input: serde_json::from_str(&tc.function.arguments).unwrap_or_else(|e| {
-                            tracing::warn!(
-                                "Failed to parse tool arguments JSON for tool '{}': {}",
-                                tc.function.name,
-                                e
-                            );
-                            serde_json::Value::default()
-                        }),
+                        input: if tc.function.arguments.trim().is_empty() {
+                            serde_json::Value::Object(Default::default())
+                        } else {
+                            serde_json::from_str(&tc.function.arguments).unwrap_or_else(|e| {
+                                tracing::warn!(
+                                    "Failed to parse tool arguments JSON for tool '{}': {}",
+                                    tc.function.name,
+                                    e
+                                );
+                                serde_json::Value::Object(Default::default())
+                            })
+                        },
                     });
                 }
             }
@@ -445,13 +449,17 @@ impl LlmClient for OpenAiClient {
                                         content_blocks.push(ContentBlock::ToolUse {
                                         id: id.clone(),
                                         name: name.clone(),
-                                        input: serde_json::from_str(args).unwrap_or_else(|e| {
-                                            tracing::warn!(
-                                                "Failed to parse tool arguments JSON for tool '{}': {}",
-                                                name, e
-                                            );
-                                            serde_json::Value::default()
-                                        }),
+                                        input: if args.trim().is_empty() {
+                                            serde_json::Value::Object(Default::default())
+                                        } else {
+                                            serde_json::from_str(args).unwrap_or_else(|e| {
+                                                tracing::warn!(
+                                                    "Failed to parse tool arguments JSON for tool '{}': {}",
+                                                    name, e
+                                                );
+                                                serde_json::Value::Object(Default::default())
+                                            })
+                                        },
                                     });
                                     }
                                     tool_calls.clear();