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

internal/js/helpers/stream-tool-sieve/parse.js

@@ -9,6 +9,7 @@ const {
   buildToolCallCandidates,
   parseToolCallsPayload,
   parseMarkupToolCalls,
+  parseTextKVToolCalls,
 } = require('./parse_payload');
 
 const TOOL_NAME_LOOSE_PATTERN = /[^a-z0-9]+/g;
@@ -53,13 +54,23 @@ function parseToolCallsDetailed(text, toolNames) {
     if (parsed.length === 0) {
       parsed = parseMarkupToolCalls(c);
     }
+    if (parsed.length === 0) {
+      parsed = parseTextKVToolCalls(c);
+    }
     if (parsed.length > 0) {
       result.sawToolCallSyntax = true;
       break;
     }
   }
   if (parsed.length === 0) {
-    return result;
+    parsed = parseMarkupToolCalls(sanitized);
+    if (parsed.length === 0) {
+      parsed = parseTextKVToolCalls(sanitized);
+      if (parsed.length === 0) {
+        return result;
+      }
+    }
+    result.sawToolCallSyntax = true;
   }
 
   const filtered = filterToolCallsDetailed(parsed, toolNames);
@@ -90,6 +101,9 @@ function parseStandaloneToolCallsDetailed(text, toolNames) {
   if (parsed.length === 0) {
     parsed = parseMarkupToolCalls(trimmed);
   }
+  if (parsed.length === 0) {
+    parsed = parseTextKVToolCalls(trimmed);
+  }
   if (parsed.length === 0) {
     return result;
   }
@@ -207,7 +221,8 @@ function looksLikeToolCallSyntax(text) {
   return lower.includes('tool_calls')
     || lower.includes('<tool_call')
     || lower.includes('<function_call')
-    || lower.includes('<invoke');
+    || lower.includes('<invoke')
+    || lower.includes('function.name:');
 }
 
 module.exports = {

internal/js/helpers/stream-tool-sieve/parse_payload.js

@@ -18,6 +18,7 @@ const TOOL_CALL_MARKUP_ARGS_PATTERNS = [
   /<(?:[a-z0-9_:-]+:)?args\b[^>]*>([\s\S]*?)<\/(?:[a-z0-9_:-]+:)?args>/i,
   /<(?:[a-z0-9_:-]+:)?params\b[^>]*>([\s\S]*?)<\/(?:[a-z0-9_:-]+:)?params>/i,
 ];
+const TEXT_KV_NAME_PATTERN = /function\.name:\s*([a-zA-Z0-9_.-]+)/gi;
 
 const {
   toStringSafe,
@@ -141,6 +142,47 @@ function parseMarkupToolCalls(text) {
   return out;
 }
 
+function parseTextKVToolCalls(text) {
+  const raw = toStringSafe(text);
+  if (!raw) {
+    return [];
+  }
+  const out = [];
+  const matches = [...raw.matchAll(TEXT_KV_NAME_PATTERN)];
+  if (matches.length === 0) {
+    return out;
+  }
+  for (let i = 0; i < matches.length; i += 1) {
+    const match = matches[i];
+    const name = toStringSafe(match[1]).trim();
+    if (!name) {
+      continue;
+    }
+    const nameEnd = match.index + toStringSafe(match[0]).length;
+    const searchEnd = i + 1 < matches.length ? matches[i + 1].index : raw.length;
+    const searchArea = raw.slice(nameEnd, searchEnd);
+    const argIdx = searchArea.indexOf('function.arguments:');
+    if (argIdx < 0) {
+      continue;
+    }
+    const argStart = nameEnd + argIdx + 'function.arguments:'.length;
+    const bracePos = raw.slice(argStart, searchEnd).indexOf('{');
+    if (bracePos < 0) {
+      continue;
+    }
+    const objStart = argStart + bracePos;
+    const obj = extractJSONObjectFrom(raw, objStart);
+    if (!obj.ok) {
+      continue;
+    }
+    out.push({
+      name,
+      input: parseToolCallInput(raw.slice(objStart, obj.end)),
+    });
+  }
+  return out;
+}
+
 function parseMarkupSingleToolCall(attrs, inner) {
   const embedded = parseToolCallsPayload(inner);
   if (embedded.length > 0) {
@@ -317,4 +359,5 @@ module.exports = {
   buildToolCallCandidates,
   parseToolCallsPayload,
   parseMarkupToolCalls,
+  parseTextKVToolCalls,
 };

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)
+	}
+}