fix(toolcall): pass gates and align go/js multi-layer parser

internal/util/toolcalls_name_match.go

@@ -0,0 +1,33 @@
+package util
+
+import (
+	"regexp"
+	"strings"
+)
+
+var toolNameLoosePattern = regexp.MustCompile(`[^a-z0-9]+`)
+
+func resolveAllowedToolNameWithLooseMatch(name string, allowed map[string]struct{}, allowedCanonical map[string]string) string {
+	if _, ok := allowed[name]; ok {
+		return name
+	}
+	lower := strings.ToLower(strings.TrimSpace(name))
+	if canonical, ok := allowedCanonical[lower]; ok {
+		return canonical
+	}
+	if idx := strings.LastIndex(lower, "."); idx >= 0 && idx < len(lower)-1 {
+		if canonical, ok := allowedCanonical[lower[idx+1:]]; ok {
+			return canonical
+		}
+	}
+	loose := toolNameLoosePattern.ReplaceAllString(lower, "")
+	if loose == "" {
+		return ""
+	}
+	for candidateLower, canonical := range allowedCanonical {
+		if toolNameLoosePattern.ReplaceAllString(candidateLower, "") == loose {
+			return canonical
+		}
+	}
+	return ""
+}

internal/util/toolcalls_parse.go

@@ -2,12 +2,9 @@ package util
 
 import (
 	"encoding/json"
-	"regexp"
 	"strings"
 )
 
-var toolNameLoosePattern = regexp.MustCompile(`[^a-z0-9]+`)
-
 type ParsedToolCall struct {
 	Name  string         `json:"name"`
 	Input map[string]any `json:"input"`
@@ -45,6 +42,9 @@ func ParseToolCallsDetailed(text string, availableToolNames []string) ToolCallPa
 		if len(tc) == 0 {
 			tc = parseMarkupToolCalls(candidate)
 		}
+		if len(tc) == 0 {
+			tc = parseTextKVToolCalls(candidate)
+		}
 		if len(tc) > 0 {
 			parsed = tc
 			result.SawToolCallSyntax = true
@@ -54,7 +54,10 @@ func ParseToolCallsDetailed(text string, availableToolNames []string) ToolCallPa
 	if len(parsed) == 0 {
 		parsed = parseXMLToolCalls(text)
 		if len(parsed) == 0 {
-			return result
+			parsed = parseTextKVToolCalls(text)
+			if len(parsed) == 0 {
+				return result
+			}
 		}
 		result.SawToolCallSyntax = true
 	}
@@ -93,6 +96,9 @@ func ParseStandaloneToolCallsDetailed(text string, availableToolNames []string)
 		if len(parsed) == 0 {
 			parsed = parseMarkupToolCalls(candidate)
 		}
+		if len(parsed) == 0 {
+			parsed = parseTextKVToolCalls(candidate)
+		}
 		if len(parsed) > 0 {
 			result.SawToolCallSyntax = true
 			calls, rejectedNames := filterToolCallsDetailed(parsed, availableToolNames)
@@ -159,28 +165,7 @@ func filterToolCallsDetailed(parsed []ParsedToolCall, availableToolNames []strin
 }
 
 func resolveAllowedToolName(name string, allowed map[string]struct{}, allowedCanonical map[string]string) string {
-	if _, ok := allowed[name]; ok {
-		return name
-	}
-	lower := strings.ToLower(strings.TrimSpace(name))
-	if canonical, ok := allowedCanonical[lower]; ok {
-		return canonical
-	}
-	if idx := strings.LastIndex(lower, "."); idx >= 0 && idx < len(lower)-1 {
-		if canonical, ok := allowedCanonical[lower[idx+1:]]; ok {
-			return canonical
-		}
-	}
-	loose := toolNameLoosePattern.ReplaceAllString(lower, "")
-	if loose == "" {
-		return ""
-	}
-	for candidateLower, canonical := range allowedCanonical {
-		if toolNameLoosePattern.ReplaceAllString(candidateLower, "") == loose {
-			return canonical
-		}
-	}
-	return ""
+	return resolveAllowedToolNameWithLooseMatch(name, allowed, allowedCanonical)
 }
 
 func parseToolCallsPayload(payload string) []ParsedToolCall {
@@ -207,7 +192,8 @@ func looksLikeToolCallSyntax(text string) bool {
 	return strings.Contains(lower, "tool_calls") ||
 		strings.Contains(lower, "<tool_call") ||
 		strings.Contains(lower, "<function_call") ||
-		strings.Contains(lower, "<invoke")
+		strings.Contains(lower, "<invoke") ||
+		strings.Contains(lower, "function.name:")
 }
 
 func parseToolCallList(v any) []ParsedToolCall {

internal/util/toolcalls_textkv.go

@@ -0,0 +1,55 @@
+package util
+
+import (
+	"regexp"
+	"strings"
+)
+
+var textKVNamePattern = regexp.MustCompile(`(?is)function\.name:\s*([a-zA-Z0-9_\-.]+)`)
+
+func parseTextKVToolCalls(text string) []ParsedToolCall {
+	var out []ParsedToolCall
+	matches := textKVNamePattern.FindAllStringSubmatchIndex(text, -1)
+	if len(matches) == 0 {
+		return nil
+	}
+
+	for i, match := range matches {
+		name := text[match[2]:match[3]]
+
+		offset := match[1]
+		endSearch := len(text)
+		if i+1 < len(matches) {
+			endSearch = matches[i+1][0]
+		}
+
+		searchArea := text[offset:endSearch]
+		argIdx := strings.Index(searchArea, "function.arguments:")
+		if argIdx < 0 {
+			continue
+		}
+
+		startIdx := offset + argIdx + len("function.arguments:")
+		braceIdx := strings.IndexByte(text[startIdx:endSearch], '{')
+		if braceIdx < 0 {
+			continue
+		}
+
+		actualStart := startIdx + braceIdx
+		objJson, _, ok := extractJSONObject(text, actualStart)
+		if !ok {
+			continue
+		}
+
+		input := parseToolCallInput(objJson)
+		out = append(out, ParsedToolCall{
+			Name:  name,
+			Input: input,
+		})
+	}
+
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}

internal/util/toolcalls_textkv_test.go

@@ -0,0 +1,63 @@
+package util
+
+import (
+	"testing"
+)
+
+func TestParseTextKVToolCalls_Basic(t *testing.T) {
+	text := `
+[TOOL_CALL_HISTORY]
+status: already_called
+origin: assistant
+not_user_input: true
+tool_call_id: call_3fcd15235eb94f7eae3a8de5a9cfa36b
+function.name: execute_command
+function.arguments: {"command":"cd scripts && python check_syntax.py example.py","cwd":null,"timeout":30}
+[/TOOL_CALL_HISTORY]
+
+Some other text thinking...
+`
+	calls := ParseToolCalls(text, []string{"execute_command"})
+	if len(calls) != 1 {
+		t.Fatalf("expected 1 call, got %d", len(calls))
+	}
+	if calls[0].Name != "execute_command" {
+		t.Fatalf("unexpected name: %s", calls[0].Name)
+	}
+	if calls[0].Input["command"] != "cd scripts && python check_syntax.py example.py" {
+		t.Fatalf("unexpected command arg: %v", calls[0].Input["command"])
+	}
+}
+
+func TestParseTextKVToolCalls_Multiple(t *testing.T) {
+	text := `
+function.name: read_file
+function.arguments: {
+	"path": "abc.txt"
+}
+
+function.name: bash
+function.arguments: {"command": "ls"}
+`
+	calls := ParseToolCalls(text, []string{"read_file", "bash"})
+	if len(calls) != 2 {
+		t.Fatalf("expected 2 calls, got %d", len(calls))
+	}
+	if calls[0].Name != "read_file" {
+		t.Fatalf("unexpected 1st name: %s", calls[0].Name)
+	}
+	if calls[1].Name != "bash" {
+		t.Fatalf("unexpected 2nd name: %s", calls[1].Name)
+	}
+}
+
+func TestParseTextKVToolCalls_Standalone(t *testing.T) {
+	text := "function.name: read_file\nfunction.arguments: {\"path\":\"README.md\"}"
+	calls := ParseStandaloneToolCalls(text, []string{"read_file"})
+	if len(calls) != 1 {
+		t.Fatalf("expected 1 call, got %d", len(calls))
+	}
+	if calls[0].Name != "read_file" {
+		t.Fatalf("unexpected name: %s", calls[0].Name)
+	}
+}