Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.
model/parsers: add gemma4 tool call repair (#15374)
Devon Rifkin8c8f8f3450d3
diff --git a/model/parsers/gemma4.go b/model/parsers/gemma4.goindex 55d45b5e6..156605824 100644--- a/model/parsers/gemma4.go+++ b/model/parsers/gemma4.go@@ -7,6 +7,7 @@ import ("regexp""strings""unicode"+ "unicode/utf8""github.com/ollama/ollama/api")@@ -25,6 +26,7 @@ const (gemma4ThinkingCloseTag = "<channel|>"gemma4ToolCallOpenTag = "<|tool_call>"gemma4ToolCallCloseTag = "<tool_call|>"+ gemma4StringDelimiter = `<|"|>`)var (@@ -35,6 +37,7 @@ var (type Gemma4Parser struct {state Gemma4ParserStatebuffer strings.Builder+ tools []api.ToolhasThinkingSupport boolthinkingEnabled bool // true when both model supports and user requested thinkingneedsChannelNameStrip bool // true when we just entered thinking and need to strip "thought\n"@@ -49,6 +52,8 @@ func (p *Gemma4Parser) HasThinkingSupport() bool {}func (p *Gemma4Parser) Init(tools []api.Tool, lastMessage *api.Message, thinkValue *api.ThinkValue) []api.Tool {+ p.tools = tools+prefill := lastMessage != nil && lastMessage.Role == "assistant"p.thinkingEnabled = p.HasThinkingSupport() && (thinkValue != nil && thinkValue.Bool())@@ -288,7 +293,7 @@ func (p *Gemma4Parser) eat(done bool) ([]gemma4Event, bool) {p.buffer.WriteString(remaining)p.state = Gemma4IgnoringPostToolCallNoise- if toolCall, err := parseGemma4ToolCall(toolCallContent); err == nil {+ if toolCall, err := parseGemma4ToolCall(toolCallContent, p.tools); err == nil {events = append(events, gemma4EventToolCall{toolCall: toolCall})} else {slog.Warn("gemma4 tool call parsing failed", "error", err, "content", toolCallContent)@@ -301,7 +306,7 @@ func (p *Gemma4Parser) eat(done bool) ([]gemma4Event, bool) {if done && len(bufStr) > 0 {p.buffer.Reset()p.state = Gemma4CollectingContent- if toolCall, err := parseGemma4ToolCall(bufStr); err == nil {+ if toolCall, err := parseGemma4ToolCall(bufStr, p.tools); err == nil {events = append(events, gemma4EventToolCall{toolCall: toolCall})} else {slog.Warn("gemma4 tool call flush on done failed", "error", err, "content", bufStr)@@ -350,7 +355,7 @@ func (p *Gemma4Parser) eat(done bool) ([]gemma4Event, bool) {// parseGemma4ToolCall parses a tool call in Gemma 4 format:// call:NAME{key:value,key:value}-func parseGemma4ToolCall(content string) (api.ToolCall, error) {+func parseGemma4ToolCall(content string, tools []api.Tool) (api.ToolCall, error) {// Expected format: call:NAME{args}if !strings.HasPrefix(content, "call:") {return api.ToolCall{}, errors.New("expected 'call:' prefix")@@ -371,7 +376,11 @@ func parseGemma4ToolCall(content string) (api.ToolCall, error) {var args api.ToolCallFunctionArgumentsif err := json.Unmarshal([]byte(jsonStr), &args); err != nil {- return api.ToolCall{}, err+ repairedArgs, repairErr := repairGemma4ToolCallArgs(argsStr, toolName, tools)+ if repairErr != nil {+ return api.ToolCall{}, errors.Join(err, repairErr)+ }+ args = repairedArgs}return api.ToolCall{@@ -400,3 +409,361 @@ func gemma4ArgsToJSON(s string) string {return text}++// repairGemma4ToolCallArgs is a best-effort repair after strict parsing fails.+// For example, if the model emits an unclosed gemma string as the last value,+// we can repair it by closing it with the gemma string delimiter.+func repairGemma4ToolCallArgs(argsStr, toolName string, tools []api.Tool) (api.ToolCallFunctionArguments, error) {+ for _, candidate := range gemma4RepairCandidates(argsStr, toolName, tools) {+ jsonStr := gemma4ArgsToJSON(candidate)++ var args api.ToolCallFunctionArguments+ if err := json.Unmarshal([]byte(jsonStr), &args); err == nil {+ return args, nil+ }+ }++ return api.ToolCallFunctionArguments{}, errors.New("repair failed to produce valid JSON arguments")+}++func gemma4ToolProperties(toolName string, tools []api.Tool) *api.ToolPropertiesMap {+ for i := range tools {+ if tools[i].Function.Name == toolName {+ return tools[i].Function.Parameters.Properties+ }+ }+ return nil+}++// gemma4RepairCandidates returns the small set of repaired argument strings we+// are willing to try after strict parsing fails. Each candidate still has to+// pass the normal Gemma4-to-JSON conversion and JSON unmarshal before it is used.+func gemma4RepairCandidates(argsStr, toolName string, tools []api.Tool) []string {+ seen := map[string]bool{}+ var candidates []string+ addCandidate := func(candidate string, allowMissingObjectClose bool) {+ original := candidate+ candidate = repairGemma4SingleQuotedValues(candidate)+ candidate = repairGemma4MissingStringDelimiter(candidate)+ if allowMissingObjectClose || candidate != original {+ candidate = repairGemma4MissingObjectClose(candidate)+ }+ if !seen[candidate] {+ candidates = append(candidates, candidate)+ seen[candidate] = true+ }+ }++ addCandidate(argsStr, false)+ if raw, ok := repairGemma4RawTerminalStringValue(argsStr, toolName, tools); ok {+ addCandidate(raw, true)+ }++ return candidates+}++// repairGemma4MissingStringDelimiter closes an unbalanced Gemma string marker.+// When the value is immediately followed by a closing brace/bracket, the marker+// is inserted before that structural close rather than after it.+func repairGemma4MissingStringDelimiter(s string) string {+ if strings.Count(s, gemma4StringDelimiter)%2 == 0 {+ return s+ }++ insertAt := gemma4TrimRightSpaceIndex(s)+ if insertAt > 0 && (s[insertAt-1] == '}' || s[insertAt-1] == ']') {+ insertAt--+ }++ var sb strings.Builder+ sb.Grow(len(s) + len(gemma4StringDelimiter))+ sb.WriteString(s[:insertAt])+ sb.WriteString(gemma4StringDelimiter)+ sb.WriteString(s[insertAt:])+ return sb.String()+}++// repairGemma4MissingObjectClose adds a final object close after another repair+// has made a truncated object plausible. Callers decide when that guardrail is+// satisfied; this helper only performs the mechanical insertion.+func repairGemma4MissingObjectClose(s string) string {+ trimmedStart := strings.TrimLeftFunc(s, unicode.IsSpace)+ if !strings.HasPrefix(trimmedStart, "{") {+ return s+ }++ trimmedEnd := gemma4TrimRightSpaceIndex(s)+ if trimmedEnd > 0 && s[trimmedEnd-1] == '}' {+ return s+ }++ return s[:trimmedEnd] + "}" + s[trimmedEnd:]+}++// repairGemma4SingleQuotedValues converts single-quoted argument values into+// Gemma string-delimited values. It also drops a stray Gemma delimiter that+// sometimes appears immediately after the closing single quote.+func repairGemma4SingleQuotedValues(s string) string {+ var sb strings.Builder+ sb.Grow(len(s))++ for i := 0; i < len(s); {+ if strings.HasPrefix(s[i:], gemma4StringDelimiter) {+ end := strings.Index(s[i+len(gemma4StringDelimiter):], gemma4StringDelimiter)+ if end == -1 {+ sb.WriteString(s[i:])+ break+ }++ end = i + len(gemma4StringDelimiter) + end + len(gemma4StringDelimiter)+ sb.WriteString(s[i:end])+ i = end+ continue+ }++ if s[i] == '"' {+ end := gemma4JSONQuotedStringEnd(s, i)+ if end != -1 {+ sb.WriteString(s[i:end])+ i = end+ continue+ }+ }++ if s[i] != ':' {+ sb.WriteByte(s[i])+ i+++ continue+ }++ sb.WriteByte(s[i])+ i++++ spaceEnd := gemma4SkipSpace(s, i)+ sb.WriteString(s[i:spaceEnd])+ i = spaceEnd+ if i >= len(s) || s[i] != '\'' {+ continue+ }++ value, end, ok := gemma4SingleQuotedValue(s, i)+ if !ok {+ continue+ }++ sb.WriteString(gemma4StringDelimiter)+ sb.WriteString(value)+ sb.WriteString(gemma4StringDelimiter)+ i = end+ if strings.HasPrefix(s[i:], gemma4StringDelimiter) {+ i += len(gemma4StringDelimiter)+ }+ }++ return sb.String()+}++func gemma4SingleQuotedValue(s string, start int) (string, int, bool) {+ var sb strings.Builder+ escaped := false+ for i := start + 1; i < len(s); i++ {+ if s[i] == '\'' && !escaped {+ return sb.String(), i + 1, true+ }++ sb.WriteByte(s[i])+ escaped = s[i] == '\\' && !escaped+ if s[i] != '\\' {+ escaped = false+ }+ }++ return "", start, false+}++// repairGemma4RawTerminalStringValue wraps a raw value in Gemma string+// delimiters only when the tool schema says that argument is a string. This is+// deliberately schema-gated because raw text is otherwise too ambiguous.+func repairGemma4RawTerminalStringValue(argsStr, toolName string, tools []api.Tool) (string, bool) {+ props := gemma4ToolProperties(toolName, tools)+ if props == nil {+ return "", false+ }++ for key, prop := range props.All() {+ if !gemma4PropertyAcceptsString(prop) {+ continue+ }++ if repaired, ok := repairGemma4RawTerminalStringValueForKey(argsStr, key, props); ok {+ return repaired, true+ }+ }++ return "", false+}++func repairGemma4RawTerminalStringValueForKey(s, key string, props *api.ToolPropertiesMap) (string, bool) {+ for searchStart := 0; searchStart < len(s); {+ valueStart, ok := gemma4FindValueStartForKey(s, key, searchStart)+ if !ok {+ return "", false+ }++ valueCheck := gemma4SkipSpace(s, valueStart)+ if valueCheck < len(s) && gemma4ValueStartsStructured(s, valueCheck) {+ searchStart = valueStart+ continue+ }++ valueEnd := gemma4RawStringValueEnd(s, valueStart, props)+ return s[:valueStart] + gemma4StringDelimiter + s[valueStart:valueEnd] + gemma4StringDelimiter + s[valueEnd:], true+ }++ return "", false+}++func gemma4FindValueStartForKey(s, key string, searchStart int) (int, bool) {+ for i := searchStart; i < len(s); i++ {+ if strings.HasPrefix(s[i:], gemma4StringDelimiter) {+ end := strings.Index(s[i+len(gemma4StringDelimiter):], gemma4StringDelimiter)+ if end == -1 {+ return 0, false+ }+ i += len(gemma4StringDelimiter) + end + len(gemma4StringDelimiter) - 1+ continue+ }++ if s[i] == '"' {+ if end := gemma4JSONQuotedStringEnd(s, i); end != -1 {+ i = end - 1+ continue+ }+ }++ if s[i] != '{' && s[i] != ',' {+ continue+ }++ keyStart := gemma4SkipSpace(s, i+1)+ if !strings.HasPrefix(s[keyStart:], key) {+ continue+ }++ colon := gemma4SkipSpace(s, keyStart+len(key))+ if colon < len(s) && s[colon] == ':' {+ return colon + 1, true+ }+ }++ return 0, false+}++func gemma4RawStringValueEnd(s string, start int, props *api.ToolPropertiesMap) int {+ for i := start; i < len(s); i++ {+ if s[i] != ',' {+ continue+ }++ keyStart := gemma4SkipSpace(s, i+1)+ keyEnd := keyStart+ for keyEnd < len(s) {+ r, size := utf8.DecodeRuneInString(s[keyEnd:])+ if !(r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r)) {+ break+ }+ keyEnd += size+ }+ if keyEnd == keyStart {+ continue+ }++ colon := gemma4SkipSpace(s, keyEnd)+ if colon < len(s) && s[colon] == ':' {+ if _, ok := props.Get(s[keyStart:keyEnd]); ok {+ return i+ }+ }+ }++ end := gemma4TrimRightSpaceIndex(s)+ if end > start && s[end-1] == '}' {+ return end - 1+ }+ return len(s)+}++func gemma4ValueStartsStructured(s string, pos int) bool {+ if pos >= len(s) {+ return false+ }+ if strings.HasPrefix(s[pos:], gemma4StringDelimiter) {+ return true+ }++ switch s[pos] {+ case '\'', '"', '{', '[':+ return true+ }++ return gemma4LooksLikeJSONLiteralStart(s[pos])+}++func gemma4JSONQuotedStringEnd(s string, start int) int {+ escaped := false+ for i := start + 1; i < len(s); i++ {+ if s[i] == '"' && !escaped {+ return i + 1+ }++ escaped = s[i] == '\\' && !escaped+ if s[i] != '\\' {+ escaped = false+ }+ }++ return -1+}++func gemma4SkipSpace(s string, i int) int {+ for i < len(s) {+ r, size := utf8.DecodeRuneInString(s[i:])+ if !unicode.IsSpace(r) {+ return i+ }+ i += size+ }+ return i+}++func gemma4TrimRightSpaceIndex(s string) int {+ i := len(s)+ for i > 0 {+ r, size := utf8.DecodeLastRuneInString(s[:i])+ if !unicode.IsSpace(r) {+ return i+ }+ i -= size+ }+ return i+}++func gemma4PropertyAcceptsString(prop api.ToolProperty) bool {+ for _, typ := range prop.Type {+ if strings.EqualFold(typ, "string") {+ return true+ }+ }++ for _, anyOf := range prop.AnyOf {+ if gemma4PropertyAcceptsString(anyOf) {+ return true+ }+ }++ return false+}++func gemma4LooksLikeJSONLiteralStart(ch byte) bool {+ return ch == '-' || ('0' <= ch && ch <= '9') || ch == 't' || ch == 'f' || ch == 'n'+}diff --git a/model/parsers/gemma4_test.go b/model/parsers/gemma4_test.goindex 00784c4f7..07ff67bf1 100644--- a/model/parsers/gemma4_test.go+++ b/model/parsers/gemma4_test.go@@ -720,6 +720,292 @@ func TestGemma4ArgsToJSON(t *testing.T) {}}+func TestRepairGemma4MissingStringDelimiter(t *testing.T) {+ tests := []struct {+ name string+ input string+ expected string+ }{+ {+ name: "closes_before_object_close",+ input: `{command:<|"|>ls}`,+ expected: `{command:<|"|>ls<|"|>}`,+ },+ {+ name: "closes_terminal_value_after_previous_property",+ input: `{path:<|"|>/tmp<|"|>,command:<|"|>ls}`,+ expected: `{path:<|"|>/tmp<|"|>,command:<|"|>ls<|"|>}`,+ },+ {+ name: "closes_at_end",+ input: `{command:<|"|>ls`,+ expected: `{command:<|"|>ls<|"|>`,+ },+ {+ name: "preserves_valid_gemma_quoted_string",+ input: `{command:<|"|>ls<|"|>}`,+ expected: `{command:<|"|>ls<|"|>}`,+ },+ {+ name: "preserves_input_without_gemma_delimiter",+ input: `{command:ls}`,+ expected: `{command:ls}`,+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ got := repairGemma4MissingStringDelimiter(tt.input)+ if got != tt.expected {+ t.Fatalf("repairGemma4MissingStringDelimiter(%q) = %q, want %q", tt.input, got, tt.expected)+ }+ })+ }+}++func TestRepairGemma4MissingObjectClose(t *testing.T) {+ tests := []struct {+ name string+ input string+ expected string+ }{+ {+ name: "adds_object_close",+ input: `{content:<|"|>hello<|"|>`,+ expected: `{content:<|"|>hello<|"|>}`,+ },+ {+ name: "adds_object_close_before_trailing_space",+ input: "{content:<|\"|>hello<|\"|> ",+ expected: "{content:<|\"|>hello<|\"|>} ",+ },+ {+ name: "preserves_existing_object_close",+ input: `{content:<|"|>hello<|"|>}`,+ expected: `{content:<|"|>hello<|"|>}`,+ },+ {+ name: "preserves_non_object_input",+ input: `content:<|"|>hello<|"|>`,+ expected: `content:<|"|>hello<|"|>`,+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ got := repairGemma4MissingObjectClose(tt.input)+ if got != tt.expected {+ t.Fatalf("repairGemma4MissingObjectClose(%q) = %q, want %q", tt.input, got, tt.expected)+ }+ })+ }+}++func TestRepairGemma4SingleQuotedValues(t *testing.T) {+ tests := []struct {+ name string+ input string+ expected string+ }{+ {+ name: "converts_single_quoted_value",+ input: `{pattern:':\s*\w+'}`,+ expected: `{pattern:<|"|>:\s*\w+<|"|>}`,+ },+ {+ name: "converts_middle_single_quoted_value",+ input: `{include:<|"|>*.py<|"|>,pattern:'abc',path:<|"|>/tmp<|"|>}`,+ expected: `{include:<|"|>*.py<|"|>,pattern:<|"|>abc<|"|>,path:<|"|>/tmp<|"|>}`,+ },+ {+ name: "drops_dangling_gemma_delimiter_after_single_quoted_value",+ input: `{pattern:'abc'<|"|>}`,+ expected: `{pattern:<|"|>abc<|"|>}`,+ },+ {+ name: "preserves_gemma_quoted_value",+ input: `{pattern:<|"|>abc<|"|>}`,+ expected: `{pattern:<|"|>abc<|"|>}`,+ },+ {+ name: "preserves_json_quoted_value",+ input: `{pattern:"abc"}`,+ expected: `{pattern:"abc"}`,+ },+ {+ name: "preserves_unterminated_single_quote",+ input: `{pattern:'abc}`,+ expected: `{pattern:'abc}`,+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ got := repairGemma4SingleQuotedValues(tt.input)+ if got != tt.expected {+ t.Fatalf("repairGemma4SingleQuotedValues(%q) = %q, want %q", tt.input, got, tt.expected)+ }+ })+ }+}++func TestRepairGemma4RawTerminalStringValue(t *testing.T) {+ numberProps := api.NewToolPropertiesMap()+ numberProps.Set("content", api.ToolProperty{Type: api.PropertyType{"number"}})+ numberTool := api.Tool{+ Type: "function",+ Function: api.ToolFunction{+ Name: "write",+ Parameters: api.ToolFunctionParameters{+ Type: "object",+ Properties: numberProps,+ },+ },+ }++ tests := []struct {+ name string+ input string+ toolName string+ tools []api.Tool+ expected string+ expectedOK bool+ }{+ {+ name: "wraps_known_string_property_terminal_value",+ input: "{content:\n\n# Title",+ toolName: "write",+ tools: []api.Tool{gemma4TestStringTool("write", "content")},+ expected: "{content:<|\"|>\n\n# Title<|\"|>",+ expectedOK: true,+ },+ {+ name: "stops_before_next_known_property",+ input: `{content:hello,mode:<|"|>fast<|"|>}`,+ toolName: "write",+ tools: []api.Tool{gemma4TestStringTool("write", "content", "mode")},+ expected: `{content:<|"|>hello<|"|>,mode:<|"|>fast<|"|>}`,+ expectedOK: true,+ },+ {+ name: "does_not_repair_without_schema",+ input: `{content:hello`,+ toolName: "write",+ tools: nil,+ expectedOK: false,+ },+ {+ name: "does_not_repair_non_string_property",+ input: `{content:hello`,+ toolName: "write",+ tools: []api.Tool{numberTool},+ expectedOK: false,+ },+ {+ name: "does_not_repair_already_structured_value",+ input: `{content:<|"|>hello<|"|>}`,+ toolName: "write",+ tools: []api.Tool{gemma4TestStringTool("write", "content")},+ expectedOK: false,+ },+ {+ name: "does_not_repair_json_literal_start",+ input: `{content:123}`,+ toolName: "write",+ tools: []api.Tool{gemma4TestStringTool("write", "content")},+ expectedOK: false,+ },+ {+ name: "does_not_repair_unknown_tool",+ input: `{content:hello`,+ toolName: "missing",+ tools: []api.Tool{gemma4TestStringTool("write", "content")},+ expectedOK: false,+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ got, ok := repairGemma4RawTerminalStringValue(tt.input, tt.toolName, tt.tools)+ if ok != tt.expectedOK {+ t.Fatalf("repairGemma4RawTerminalStringValue ok = %t, want %t", ok, tt.expectedOK)+ }+ if got != tt.expected {+ t.Fatalf("repairGemma4RawTerminalStringValue got %q, want %q", got, tt.expected)+ }+ })+ }+}++func TestGemma4RepairCandidates(t *testing.T) {+ tests := []struct {+ name string+ input string+ toolName string+ tools []api.Tool+ expected []string+ }{+ {+ name: "missing_string_delimiter_candidate",+ input: `{command:<|"|>ls}`,+ toolName: "bash",+ tools: []api.Tool{gemma4TestStringTool("bash", "command")},+ expected: []string{`{command:<|"|>ls<|"|>}`},+ },+ {+ name: "single_quoted_value_candidate",+ input: `{pattern:'abc'<|"|>}`,+ toolName: "grep",+ tools: []api.Tool{gemma4TestStringTool("grep", "pattern")},+ expected: []string{`{pattern:<|"|>abc<|"|>}`},+ },+ {+ name: "raw_string_candidate_also_gets_missing_object_close",+ input: `{content:hello`,+ toolName: "write",+ tools: []api.Tool{gemma4TestStringTool("write", "content")},+ expected: []string{+ `{content:hello`,+ `{content:<|"|>hello<|"|>}`,+ },+ },+ {+ name: "does_not_add_missing_object_close_without_another_repair",+ input: `{n:1`,+ toolName: "count",+ tools: []api.Tool{gemma4TestStringTool("count", "name")},+ expected: []string{`{n:1`},+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ got := gemma4RepairCandidates(tt.input, tt.toolName, tt.tools)+ if diff := cmp.Diff(tt.expected, got); diff != "" {+ t.Fatalf("gemma4RepairCandidates mismatch (-want +got):\n%s", diff)+ }+ })+ }+}++func gemma4TestStringTool(name string, argNames ...string) api.Tool {+ props := api.NewToolPropertiesMap()+ for _, argName := range argNames {+ props.Set(argName, api.ToolProperty{Type: api.PropertyType{"string"}})+ }++ return api.Tool{+ Type: "function",+ Function: api.ToolFunction{+ Name: name,+ Parameters: api.ToolFunctionParameters{+ Type: "object",+ Properties: props,+ },+ },+ }+}+func TestGemma4Parser_HasToolSupport(t *testing.T) {parser := &Gemma4Parser{}if !parser.HasToolSupport() {@@ -740,14 +1026,14 @@ func TestGemma4Parser_HasThinkingSupport(t *testing.T) {}func TestParseGemma4ToolCall_InvalidRawQuotedEscape(t *testing.T) {- _, err := parseGemma4ToolCall(`call:open_file{path:"C:\users\bob\file.txt"}`)+ _, err := parseGemma4ToolCall(`call:open_file{path:"C:\users\bob\file.txt"}`, nil)if err == nil {t.Fatal("expected parseGemma4ToolCall to reject malformed raw-quoted JSON escapes")}}func TestParseGemma4ToolCall_QuotedScalarsStayStrings(t *testing.T) {- toolCall, err := parseGemma4ToolCall(`call:foo{n:<|"|>1<|"|>,b:<|"|>true<|"|>,z:<|"|>null<|"|>}`)+ toolCall, err := parseGemma4ToolCall(`call:foo{n:<|"|>1<|"|>,b:<|"|>true<|"|>,z:<|"|>null<|"|>}`, nil)if err != nil {t.Fatalf("parseGemma4ToolCall returned error: %v", err)}@@ -769,7 +1055,7 @@ func TestParseGemma4ToolCall_QuotedScalarsStayStrings(t *testing.T) {}func TestParseGemma4ToolCall_UnquotedScalarsKeepStructuredTypes(t *testing.T) {- toolCall, err := parseGemma4ToolCall(`call:foo{n:1,b:true,z:null}`)+ toolCall, err := parseGemma4ToolCall(`call:foo{n:1,b:true,z:null}`, nil)if err != nil {t.Fatalf("parseGemma4ToolCall returned error: %v", err)}@@ -791,7 +1077,7 @@ func TestParseGemma4ToolCall_UnquotedScalarsKeepStructuredTypes(t *testing.T) {}func TestParseGemma4ToolCall_ReferenceImplementationExample(t *testing.T) {- toolCall, err := parseGemma4ToolCall(`call:get_current_temperature{detail_level:0,location:<|"|>Paris, France<|"|>,unit:<|"|>celsius<|"|>}`)+ toolCall, err := parseGemma4ToolCall(`call:get_current_temperature{detail_level:0,location:<|"|>Paris, France<|"|>,unit:<|"|>celsius<|"|>}`, nil)if err != nil {t.Fatalf("parseGemma4ToolCall returned error: %v", err)}@@ -812,8 +1098,158 @@ func TestParseGemma4ToolCall_ReferenceImplementationExample(t *testing.T) {}}+func TestParseGemma4ToolCall_RepairsIssue15315Examples(t *testing.T) {+ writeContent := "\n\n# Project Style Guide for Autonomous Agents' Code Generation (AGENTS.md)\n\n" ++ "This document captures the *de facto* coding standards observed across the `src/` and `components/` source code, designed to ensure consistency for all generated code and modules consumed by the agent system."++ tests := []struct {+ name string+ content string+ tools []api.Tool+ want api.ToolCall+ }{+ {+ name: "raw multiline string",+ // Source: https://github.com/ollama/ollama/issues/15315#issue-4203625511+ content: "call:write{content:" + writeContent,+ tools: []api.Tool{gemma4TestStringTool("write", "content")},+ want: api.ToolCall{+ Function: api.ToolCallFunction{+ Name: "write",+ Arguments: testArgs(map[string]any{+ "content": writeContent,+ }),+ },+ },+ },+ {+ name: "single quoted value with dangling gemma string delimiter",+ content: `call:grep{include:<|"|>*.py<|"|>,output_mode:<|"|>content<|"|>,path:<|"|>/data/robotics/experiment1<|"|>,pattern:':\s*\w+'<|"|>}`,+ tools: []api.Tool{gemma4TestStringTool("grep", "include", "output_mode", "path", "pattern")},+ // Source: https://github.com/ollama/ollama/issues/15315#issue-4203625511+ want: api.ToolCall{+ Function: api.ToolCallFunction{+ Name: "grep",+ Arguments: testArgs(map[string]any{+ "include": "*.py",+ "output_mode": "content",+ "path": "/data/robotics/experiment1",+ "pattern": `:\s*\w+`,+ }),+ },+ },+ },+ {+ name: "unclosed gemma string before object close",+ content: `call:bash{command:<|"|>ls}`,+ tools: []api.Tool{gemma4TestStringTool("bash", "command")},+ // Source: https://github.com/ollama/ollama/issues/15315#issuecomment-4194547092+ want: api.ToolCall{+ Function: api.ToolCallFunction{+ Name: "bash",+ Arguments: testArgs(map[string]any{+ "command": "ls",+ }),+ },+ },+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ got, err := parseGemma4ToolCall(tt.content, tt.tools)+ if err != nil {+ t.Fatalf("parseGemma4ToolCall returned error: %v", err)+ }++ if diff := cmp.Diff(tt.want, got, argsComparer); diff != "" {+ t.Fatalf("tool call mismatch (-want +got):\n%s", diff)+ }+ })+ }+}++func TestParseGemma4ToolCall_RepairsMultipleProperties(t *testing.T) {+ tests := []struct {+ name string+ content string+ tools []api.Tool+ want api.ToolCall+ }{+ {+ name: "single_quoted_middle_property",+ content: `call:grep{include:<|"|>*.py<|"|>,pattern:'abc',path:<|"|>/tmp<|"|>}`,+ tools: []api.Tool{gemma4TestStringTool("grep", "include", "pattern", "path")},+ want: api.ToolCall{+ Function: api.ToolCallFunction{+ Name: "grep",+ Arguments: testArgs(map[string]any{+ "include": "*.py",+ "pattern": "abc",+ "path": "/tmp",+ }),+ },+ },+ },+ {+ name: "unclosed_gemma_string_terminal_property",+ content: `call:bash{path:<|"|>/tmp<|"|>,command:<|"|>ls}`,+ tools: []api.Tool{gemma4TestStringTool("bash", "path", "command")},+ want: api.ToolCall{+ Function: api.ToolCallFunction{+ Name: "bash",+ Arguments: testArgs(map[string]any{+ "path": "/tmp",+ "command": "ls",+ }),+ },+ },+ },+ {+ name: "raw_string_before_next_property",+ content: `call:write{content:hello,mode:<|"|>fast<|"|>}`,+ tools: []api.Tool{gemma4TestStringTool("write", "content", "mode")},+ want: api.ToolCall{+ Function: api.ToolCallFunction{+ Name: "write",+ Arguments: testArgs(map[string]any{+ "content": "hello",+ "mode": "fast",+ }),+ },+ },+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ got, err := parseGemma4ToolCall(tt.content, tt.tools)+ if err != nil {+ t.Fatalf("parseGemma4ToolCall returned error: %v", err)+ }++ if diff := cmp.Diff(tt.want, got, argsComparer); diff != "" {+ t.Fatalf("tool call mismatch (-want +got):\n%s", diff)+ }+ })+ }+}++func TestParseGemma4ToolCall_DoesNotRepairNonTerminalUnclosedGemmaString(t *testing.T) {+ // TODO(drifkin): our current examples show unclosed gemma strings as the last+ // values, but if we find examples where there's an unclosed non-last value,+ // we should consider repairing it. This test shows that we don't yet repair+ // this type (the heuristics of where to close are much more complicated)+ _, err := parseGemma4ToolCall(`call:example{first:<|"|>one,second:<|"|>two<|"|>}`, []api.Tool{+ gemma4TestStringTool("example", "first", "second"),+ })+ if err == nil {+ t.Fatal("expected non-terminal unclosed Gemma string to remain unsupported")+ }+}+func TestParseGemma4ToolCall_InvalidRawQuotedStructuralString(t *testing.T) {- _, err := parseGemma4ToolCall(`call:foo{q:"a,b:c"}`)+ _, err := parseGemma4ToolCall(`call:foo{q:"a,b:c"}`, nil)if err == nil {t.Fatal("expected parseGemma4ToolCall to reject raw-quoted strings with structural text that the reference implementation does not support")}