Merge origin/dev into PR branch and resolve toolcall test conflicts

2026-05-22 00:47:45 +08:00 · 2026-03-08 01:10:53 +08:00
parent 9b93badb57
commit 60e9d707d4
16 changed files with 586 additions and 25 deletions
--- a/internal/util/toolcalls_parse.go
+++ b/internal/util/toolcalls_parse.go
@@ -39,6 +39,9 @@ func ParseToolCallsDetailed(text string, availableToolNames []string) ToolCallPa
 	var parsed []ParsedToolCall
 	for _, candidate := range candidates {
 		tc := parseToolCallsPayload(candidate)
+		if len(tc) == 0 {
+			tc = parseXMLToolCalls(candidate)
+		}
 		if len(tc) == 0 {
 			tc = parseMarkupToolCalls(candidate)
 		}
@@ -49,7 +52,11 @@ func ParseToolCallsDetailed(text string, availableToolNames []string) ToolCallPa
 		}
 	}
 	if len(parsed) == 0 {
-		return result
+		parsed = parseXMLToolCalls(text)
+		if len(parsed) == 0 {
+			return result
+		}
+		result.SawToolCallSyntax = true
 	}

 	calls, rejectedNames := filterToolCallsDetailed(parsed, availableToolNames)
@@ -80,6 +87,9 @@ func ParseStandaloneToolCallsDetailed(text string, availableToolNames []string)
 			continue
 		}
 		parsed := parseToolCallsPayload(candidate)
+		if len(parsed) == 0 {
+			parsed = parseXMLToolCalls(candidate)
+		}
 		if len(parsed) == 0 {
 			parsed = parseMarkupToolCalls(candidate)
 		}
--- a/internal/util/toolcalls_parse_markup.go
+++ b/internal/util/toolcalls_parse_markup.go
@@ -0,0 +1,219 @@
+package util
+
+import (
+	"encoding/json"
+	"encoding/xml"
+	"regexp"
+	"strings"
+)
+
+var xmlToolCallPattern = regexp.MustCompile(`(?is)<tool_call>\s*(.*?)\s*</tool_call>`)
+var functionCallPattern = regexp.MustCompile(`(?is)<function_call>\s*([^<]+?)\s*</function_call>`)
+var functionParamPattern = regexp.MustCompile(`(?is)<function\s+parameter\s+name="([^"]+)"\s*>\s*(.*?)\s*</function\s+parameter>`)
+var antmlFunctionCallPattern = regexp.MustCompile(`(?is)<(?:[a-z0-9_]+:)?function_call[^>]*(?:name|function)="([^"]+)"[^>]*>\s*(.*?)\s*</(?:[a-z0-9_]+:)?function_call>`)
+var antmlArgumentPattern = regexp.MustCompile(`(?is)<(?:[a-z0-9_]+:)?argument\s+name="([^"]+)"\s*>\s*(.*?)\s*</(?:[a-z0-9_]+:)?argument>`)
+var antmlParametersPattern = regexp.MustCompile(`(?is)<(?:[a-z0-9_]+:)?parameters\s*>\s*(\{.*?\})\s*</(?:[a-z0-9_]+:)?parameters>`)
+var invokeCallPattern = regexp.MustCompile(`(?is)<invoke\s+name="([^"]+)"\s*>(.*?)</invoke>`)
+var invokeParamPattern = regexp.MustCompile(`(?is)<parameter\s+name="([^"]+)"\s*>\s*(.*?)\s*</parameter>`)
+
+func parseXMLToolCalls(text string) []ParsedToolCall {
+	matches := xmlToolCallPattern.FindAllString(text, -1)
+	out := make([]ParsedToolCall, 0, len(matches)+1)
+	for _, block := range matches {
+		call, ok := parseSingleXMLToolCall(block)
+		if !ok {
+			continue
+		}
+		out = append(out, call)
+	}
+	if len(out) > 0 {
+		return out
+	}
+	if call, ok := parseFunctionCallTagStyle(text); ok {
+		return []ParsedToolCall{call}
+	}
+	if calls := parseAntmlFunctionCallStyles(text); len(calls) > 0 {
+		return calls
+	}
+	if call, ok := parseInvokeFunctionCallStyle(text); ok {
+		return []ParsedToolCall{call}
+	}
+	return nil
+}
+
+func parseSingleXMLToolCall(block string) (ParsedToolCall, bool) {
+	inner := strings.TrimSpace(block)
+	inner = strings.TrimPrefix(inner, "<tool_call>")
+	inner = strings.TrimSuffix(inner, "</tool_call>")
+	inner = strings.TrimSpace(inner)
+	if strings.HasPrefix(inner, "{") {
+		var payload map[string]any
+		if err := json.Unmarshal([]byte(inner), &payload); err == nil {
+			name := strings.TrimSpace(asString(payload["tool"]))
+			if name == "" {
+				name = strings.TrimSpace(asString(payload["tool_name"]))
+			}
+			if name != "" {
+				input := map[string]any{}
+				if params, ok := payload["params"].(map[string]any); ok {
+					input = params
+				} else if params, ok := payload["parameters"].(map[string]any); ok {
+					input = params
+				}
+				return ParsedToolCall{Name: name, Input: input}, true
+			}
+		}
+	}
+
+	dec := xml.NewDecoder(strings.NewReader(block))
+	name := ""
+	params := map[string]any{}
+	inParams := false
+	inTool := false
+	for {
+		tok, err := dec.Token()
+		if err != nil {
+			break
+		}
+		switch t := tok.(type) {
+		case xml.StartElement:
+			tag := strings.ToLower(t.Name.Local)
+			switch tag {
+			case "tool":
+				inTool = true
+				for _, attr := range t.Attr {
+					if strings.EqualFold(strings.TrimSpace(attr.Name.Local), "name") && strings.TrimSpace(name) == "" {
+						name = strings.TrimSpace(attr.Value)
+					}
+				}
+			case "parameters":
+				inParams = true
+			case "tool_name", "name":
+				var v string
+				if err := dec.DecodeElement(&v, &t); err == nil && strings.TrimSpace(v) != "" {
+					name = strings.TrimSpace(v)
+				}
+			default:
+				if inParams || inTool {
+					var v string
+					if err := dec.DecodeElement(&v, &t); err == nil {
+						params[t.Name.Local] = strings.TrimSpace(v)
+					}
+				}
+			}
+		case xml.EndElement:
+			tag := strings.ToLower(t.Name.Local)
+			if tag == "parameters" {
+				inParams = false
+			}
+			if tag == "tool" {
+				inTool = false
+			}
+		}
+	}
+	if strings.TrimSpace(name) == "" {
+		return ParsedToolCall{}, false
+	}
+	return ParsedToolCall{Name: strings.TrimSpace(name), Input: params}, true
+}
+
+func parseFunctionCallTagStyle(text string) (ParsedToolCall, bool) {
+	m := functionCallPattern.FindStringSubmatch(text)
+	if len(m) < 2 {
+		return ParsedToolCall{}, false
+	}
+	name := strings.TrimSpace(m[1])
+	if name == "" {
+		return ParsedToolCall{}, false
+	}
+	input := map[string]any{}
+	for _, pm := range functionParamPattern.FindAllStringSubmatch(text, -1) {
+		if len(pm) < 3 {
+			continue
+		}
+		key := strings.TrimSpace(pm[1])
+		val := strings.TrimSpace(pm[2])
+		if key != "" {
+			input[key] = val
+		}
+	}
+	return ParsedToolCall{Name: name, Input: input}, true
+}
+
+func parseAntmlFunctionCallStyles(text string) []ParsedToolCall {
+	matches := antmlFunctionCallPattern.FindAllStringSubmatch(text, -1)
+	if len(matches) == 0 {
+		return nil
+	}
+	out := make([]ParsedToolCall, 0, len(matches))
+	for _, m := range matches {
+		if call, ok := parseSingleAntmlFunctionCallMatch(m); ok {
+			out = append(out, call)
+		}
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+func parseSingleAntmlFunctionCallMatch(m []string) (ParsedToolCall, bool) {
+	if len(m) < 3 {
+		return ParsedToolCall{}, false
+	}
+	name := strings.TrimSpace(m[1])
+	if name == "" {
+		return ParsedToolCall{}, false
+	}
+	body := strings.TrimSpace(m[2])
+	input := map[string]any{}
+	if strings.HasPrefix(body, "{") {
+		if err := json.Unmarshal([]byte(body), &input); err == nil {
+			return ParsedToolCall{Name: name, Input: input}, true
+		}
+	}
+	if pm := antmlParametersPattern.FindStringSubmatch(body); len(pm) >= 2 {
+		if err := json.Unmarshal([]byte(strings.TrimSpace(pm[1])), &input); err == nil {
+			return ParsedToolCall{Name: name, Input: input}, true
+		}
+	}
+	for _, am := range antmlArgumentPattern.FindAllStringSubmatch(body, -1) {
+		if len(am) < 3 {
+			continue
+		}
+		k := strings.TrimSpace(am[1])
+		v := strings.TrimSpace(am[2])
+		if k != "" {
+			input[k] = v
+		}
+	}
+	return ParsedToolCall{Name: name, Input: input}, true
+}
+
+func parseInvokeFunctionCallStyle(text string) (ParsedToolCall, bool) {
+	m := invokeCallPattern.FindStringSubmatch(text)
+	if len(m) < 3 {
+		return ParsedToolCall{}, false
+	}
+	name := strings.TrimSpace(m[1])
+	if name == "" {
+		return ParsedToolCall{}, false
+	}
+	input := map[string]any{}
+	for _, pm := range invokeParamPattern.FindAllStringSubmatch(m[2], -1) {
+		if len(pm) < 3 {
+			continue
+		}
+		k := strings.TrimSpace(pm[1])
+		v := strings.TrimSpace(pm[2])
+		if k != "" {
+			input[k] = v
+		}
+	}
+	return ParsedToolCall{Name: name, Input: input}, true
+}
+
+func asString(v any) string {
+	s, _ := v.(string)
+	return s
+}
--- a/internal/util/toolcalls_test.go
+++ b/internal/util/toolcalls_test.go
@@ -138,6 +138,140 @@ func TestParseToolCallsAllowsPunctuationVariantToolName(t *testing.T) {
 	}
 }

+func TestParseToolCallsSupportsClaudeXMLToolCall(t *testing.T) {
+	text := `<tool_call><tool_name>Bash</tool_name><parameters><command>pwd</command><description>show cwd</description></parameters></tool_call>`
+	calls := ParseToolCalls(text, []string{"bash"})
+	if len(calls) != 1 {
+		t.Fatalf("expected 1 call, got %#v", calls)
+	}
+	if calls[0].Name != "bash" {
+		t.Fatalf("expected canonical tool name bash, got %q", calls[0].Name)
+	}
+	if calls[0].Input["command"] != "pwd" {
+		t.Fatalf("expected command argument, got %#v", calls[0].Input)
+	}
+}
+
+func TestParseToolCallsDetailedMarksXMLToolCallSyntax(t *testing.T) {
+	text := `<tool_call><tool_name>Bash</tool_name><parameters><command>pwd</command></parameters></tool_call>`
+	res := ParseToolCallsDetailed(text, []string{"bash"})
+	if !res.SawToolCallSyntax {
+		t.Fatalf("expected SawToolCallSyntax=true, got %#v", res)
+	}
+	if len(res.Calls) != 1 {
+		t.Fatalf("expected one parsed call, got %#v", res)
+	}
+}
+
+func TestParseToolCallsSupportsClaudeXMLJSONToolCall(t *testing.T) {
+	text := `<tool_call>{"tool":"Bash","params":{"command":"pwd","description":"show cwd"}}</tool_call>`
+	calls := ParseToolCalls(text, []string{"bash"})
+	if len(calls) != 1 {
+		t.Fatalf("expected 1 call, got %#v", calls)
+	}
+	if calls[0].Name != "bash" {
+		t.Fatalf("expected canonical tool name bash, got %q", calls[0].Name)
+	}
+	if calls[0].Input["command"] != "pwd" {
+		t.Fatalf("expected command argument, got %#v", calls[0].Input)
+	}
+}
+
+func TestParseToolCallsSupportsFunctionCallTagStyle(t *testing.T) {
+	text := `<function_call>Bash</function_call><function parameter name="command">ls -la</function parameter><function parameter name="description">list</function parameter>`
+	calls := ParseToolCalls(text, []string{"bash"})
+	if len(calls) != 1 {
+		t.Fatalf("expected 1 call, got %#v", calls)
+	}
+	if calls[0].Name != "bash" {
+		t.Fatalf("expected canonical tool name bash, got %q", calls[0].Name)
+	}
+	if calls[0].Input["command"] != "ls -la" {
+		t.Fatalf("expected command argument, got %#v", calls[0].Input)
+	}
+}
+
+func TestParseToolCallsSupportsAntmlFunctionCallStyle(t *testing.T) {
+	text := `<antml:function_calls><antml:function_call name="Bash">{"command":"pwd","description":"x"}</antml:function_call></antml:function_calls>`
+	calls := ParseToolCalls(text, []string{"bash"})
+	if len(calls) != 1 {
+		t.Fatalf("expected 1 call, got %#v", calls)
+	}
+	if calls[0].Name != "bash" {
+		t.Fatalf("expected canonical tool name bash, got %q", calls[0].Name)
+	}
+	if calls[0].Input["command"] != "pwd" {
+		t.Fatalf("expected command argument, got %#v", calls[0].Input)
+	}
+}
+
+func TestParseToolCallsSupportsAntmlArgumentStyle(t *testing.T) {
+	text := `<antml:function_calls><antml:function_call id="1" name="Bash"><antml:argument name="command">pwd</antml:argument><antml:argument name="description">x</antml:argument></antml:function_call></antml:function_calls>`
+	calls := ParseToolCalls(text, []string{"bash"})
+	if len(calls) != 1 {
+		t.Fatalf("expected 1 call, got %#v", calls)
+	}
+	if calls[0].Name != "bash" {
+		t.Fatalf("expected canonical tool name bash, got %q", calls[0].Name)
+	}
+	if calls[0].Input["command"] != "pwd" {
+		t.Fatalf("expected command argument, got %#v", calls[0].Input)
+	}
+}
+
+func TestParseToolCallsSupportsInvokeFunctionCallStyle(t *testing.T) {
+	text := `<function_calls><invoke name="Bash"><parameter name="command">pwd</parameter><parameter name="description">d</parameter></invoke></function_calls>`
+	calls := ParseToolCalls(text, []string{"bash"})
+	if len(calls) != 1 {
+		t.Fatalf("expected 1 call, got %#v", calls)
+	}
+	if calls[0].Name != "bash" {
+		t.Fatalf("expected canonical tool name bash, got %q", calls[0].Name)
+	}
+	if calls[0].Input["command"] != "pwd" {
+		t.Fatalf("expected command argument, got %#v", calls[0].Input)
+	}
+}
+
+func TestParseToolCallsSupportsNestedToolTagStyle(t *testing.T) {
+	text := `<tool_call><tool name="Bash"><command>pwd</command><description>show cwd</description></tool></tool_call>`
+	calls := ParseToolCalls(text, []string{"bash"})
+	if len(calls) != 1 {
+		t.Fatalf("expected 1 call, got %#v", calls)
+	}
+	if calls[0].Name != "bash" {
+		t.Fatalf("expected canonical tool name bash, got %q", calls[0].Name)
+	}
+	if calls[0].Input["command"] != "pwd" {
+		t.Fatalf("expected command argument, got %#v", calls[0].Input)
+	}
+}
+
+func TestParseToolCallsSupportsAntmlFunctionAttributeWithParametersTag(t *testing.T) {
+	text := `<antml:function_calls><antml:function_call id="x" function="Bash"><antml:parameters>{"command":"pwd"}</antml:parameters></antml:function_call></antml:function_calls>`
+	calls := ParseToolCalls(text, []string{"bash"})
+	if len(calls) != 1 {
+		t.Fatalf("expected 1 call, got %#v", calls)
+	}
+	if calls[0].Name != "bash" {
+		t.Fatalf("expected canonical tool name bash, got %q", calls[0].Name)
+	}
+	if calls[0].Input["command"] != "pwd" {
+		t.Fatalf("expected command argument, got %#v", calls[0].Input)
+	}
+}
+
+func TestParseToolCallsSupportsMultipleAntmlFunctionCalls(t *testing.T) {
+	text := `<antml:function_calls><antml:function_call id="1" function="Bash"><antml:parameters>{"command":"pwd"}</antml:parameters></antml:function_call><antml:function_call id="2" function="Read"><antml:parameters>{"file_path":"README.md"}</antml:parameters></antml:function_call></antml:function_calls>`
+	calls := ParseToolCalls(text, []string{"bash", "read"})
+	if len(calls) != 2 {
+		t.Fatalf("expected 2 calls, got %#v", calls)
+	}
+	if calls[0].Name != "bash" || calls[1].Name != "read" {
+		t.Fatalf("expected canonical names [bash read], got %#v", calls)
+	}
+}
+
 func TestParseToolCallsDoesNotAcceptMismatchedMarkupTags(t *testing.T) {
 	text := `<tool_call><name>read_file</function><arguments>{"path":"README.md"}</arguments></tool_call>`
 	calls := ParseToolCalls(text, []string{"read_file"})