fix: implement duplicate_tool_call_threshold detection logic

Add missing duplicate tool call detection to prevent infinite loops
when the agent repeatedly calls the same tool with identical arguments.

Changes:
- Add duplicate detection logic before tool execution
- Check recent_tool_signatures for matching tool calls
- Abort execution when threshold is exceeded (default: 3)
- Send AgentEvent::Error to notify frontend
- Return error message to LLM so it can adjust its approach
- Add tracing for debugging

This fixes a critical stability issue where the agent could get stuck
in an infinite loop calling the same tool repeatedly (e.g., web_search
with the same query).

The detection logic:
1. Constructs tool signature: "tool_name:json_args"
2. Counts occurrences in recent_tool_signatures (last 8 calls)
3. If count >= duplicate_tool_call_threshold, abort with error
4. LLM receives error and can try a different approach

Example:
- Agent calls web_search("上海AI政策") 3 times
- On 3rd call, threshold exceeded
- Error returned: "Tool has been called 3 times with identical arguments"
- Agent adjusts strategy and tries different parameters

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: claude

core/src/agent.rs

@@ -3136,6 +3136,46 @@ impl AgentLoop {
                 // In streaming mode, ToolStart is sent when we receive ToolUseStart from LLM
                 // But we still need to send ToolEnd after execution
 
+                // Check for duplicate tool calls to prevent infinite loops
+                let tool_signature = format!(
+                    "{}:{}",
+                    tool_call.name,
+                    serde_json::to_string(&tool_call.args).unwrap_or_default()
+                );
+
+                let duplicate_count = recent_tool_signatures
+                    .iter()
+                    .filter(|sig| sig.starts_with(&tool_signature))
+                    .count();
+
+                if duplicate_count >= self.config.duplicate_tool_call_threshold as usize {
+                    let error_msg = format!(
+                        "Tool '{}' has been called {} times with identical arguments. \
+                         Aborting to prevent infinite loop. Consider modifying your approach.",
+                        tool_call.name, duplicate_count
+                    );
+
+                    tracing::warn!(
+                        tool_name = tool_call.name.as_str(),
+                        duplicate_count = duplicate_count,
+                        threshold = self.config.duplicate_tool_call_threshold,
+                        "Duplicate tool call threshold exceeded"
+                    );
+
+                    // Send error event
+                    if let Some(tx) = &event_tx {
+                        tx.send(AgentEvent::Error {
+                            message: error_msg.clone(),
+                        })
+                        .await
+                        .ok();
+                    }
+
+                    // Return error result to LLM so it can adjust its approach
+                    messages.push(Message::tool_result(&tool_call.id, &error_msg, true));
+                    continue;
+                }
+
                 // Check for malformed tool arguments from LLM (4.1 parse error recovery)
                 if let Some(parse_error) =
                     tool_call.args.get("__parse_error").and_then(|v| v.as_str())