Skip to content

Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.

address comments

Devon Rifkin472feec2ff50
diff --git a/model/parsers/parsers.go b/model/parsers/parsers.go
index 001cac442..e6dbd1f4f 100644
--- a/model/parsers/parsers.go
+++ b/model/parsers/parsers.go
@@ -4,13 +4,13 @@ import (
"github.com/ollama/ollama/api"
)
-type BuiltinParser interface {
+type Parser interface {
Add(s string, tools []api.Tool) (content string, thinking string, calls []api.ToolCall, err error)
HasToolSupport() bool
HasThinkingSupport() bool
}
-func ParserForName(name string) BuiltinParser {
+func ParserForName(name string) Parser {
switch name {
case "qwen3-coder":
parser := &Qwen3CoderParser{}
diff --git a/model/parsers/qwen3coder_test.go b/model/parsers/qwen3coder_test.go
index c0dad28d1..2389c77b5 100644
--- a/model/parsers/qwen3coder_test.go
+++ b/model/parsers/qwen3coder_test.go
@@ -307,7 +307,7 @@ true
"x": 3.14,
"y": 42,
"enabled": true,
- "items": []interface{}{"a", "b", "c"},
+ "items": []any{"a", "b", "c"},
},
},
},
@@ -510,44 +510,44 @@ func TestQwenToolCallValueParsing(t *testing.T) {
desc: "array of strings",
paramType: api.PropertyType{"array"},
raw: `["foo", "bar", "baz"]`,
- want: []interface{}{"foo", "bar", "baz"},
+ want: []any{"foo", "bar", "baz"},
},
{
desc: "array of numbers",
paramType: api.PropertyType{"array"},
raw: `[1, 2.5, 3]`,
- want: []interface{}{float64(1), 2.5, float64(3)},
+ want: []any{float64(1), 2.5, float64(3)},
},
{
desc: "array of mixed types",
paramType: api.PropertyType{"array"},
raw: `["string", 123, true, null]`,
- want: []interface{}{"string", float64(123), true, nil},
+ want: []any{"string", float64(123), true, nil},
},
{
desc: "empty array",
paramType: api.PropertyType{"array"},
raw: `[]`,
- want: []interface{}{},
+ want: []any{},
},
// Object parsing tests
{
desc: "simple object",
paramType: api.PropertyType{"object"},
raw: `{"key": "value", "number": 42}`,
- want: map[string]interface{}{"key": "value", "number": float64(42)},
+ want: map[string]any{"key": "value", "number": float64(42)},
},
{
desc: "nested object",
paramType: api.PropertyType{"object"},
raw: `{"outer": {"inner": "value"}}`,
- want: map[string]interface{}{"outer": map[string]interface{}{"inner": "value"}},
+ want: map[string]any{"outer": map[string]any{"inner": "value"}},
},
{
desc: "empty object",
paramType: api.PropertyType{"object"},
raw: `{}`,
- want: map[string]interface{}{},
+ want: map[string]any{},
},
// Error cases and fallback behavior
{
@@ -689,19 +689,19 @@ func TestQwenToolCallValueParsing(t *testing.T) {
desc: "array or object union - valid array",
paramType: api.PropertyType{"array", "object"},
raw: `[1, 2, 3]`,
- want: []interface{}{float64(1), float64(2), float64(3)},
+ want: []any{float64(1), float64(2), float64(3)},
},
{
desc: "array or object union - valid object",
paramType: api.PropertyType{"array", "object"},
raw: `{"key": "value"}`,
- want: map[string]interface{}{"key": "value"},
+ want: map[string]any{"key": "value"},
},
{
desc: "object or array union - valid array (precedence test)",
paramType: api.PropertyType{"object", "array"},
raw: `[1, 2, 3]`,
- want: []interface{}{float64(1), float64(2), float64(3)},
+ want: []any{float64(1), float64(2), float64(3)},
},
{
desc: "complex multi-type union - null",
diff --git a/model/renderers/qwen3coder.go b/model/renderers/qwen3coder.go
index 074def0eb..df3b3a45b 100644
--- a/model/renderers/qwen3coder.go
+++ b/model/renderers/qwen3coder.go
@@ -17,13 +17,13 @@ var (
// renderAdditionalKeys renders all JSON fields except the ones in handledKeys
// This follows the same approach from the reference implementation, which gives
// a particular key ordering
-func renderAdditionalKeys(obj interface{}, handledKeys map[string]bool) string {
+func renderAdditionalKeys(obj any, handledKeys map[string]bool) string {
data, err := json.Marshal(obj)
if err != nil {
return ""
}
- var m map[string]interface{}
+ var m map[string]any
if err := json.Unmarshal(data, &m); err != nil {
return ""
}
@@ -36,7 +36,7 @@ func renderAdditionalKeys(obj interface{}, handledKeys map[string]bool) string {
// Check if value is a map or array (needs JSON serialization)
switch v := value.(type) {
- case map[string]interface{}, []interface{}:
+ case map[string]any, []any:
jsonBytes, _ := json.Marshal(v)
// TODO(drifkin): it would be nice to format the JSON here similarly to
// python's default json.dumps behavior (spaces after commas and colons).
diff --git a/server/routes.go b/server/routes.go
index 849d2ede8..a4fa00475 100644
--- a/server/routes.go
+++ b/server/routes.go
@@ -1618,7 +1618,7 @@ func (s *Server) ChatHandler(c *gin.Context) {
}
msgs = filterThinkTags(msgs, m)
- var builtinParser parsers.BuiltinParser
+ var builtinParser parsers.Parser
if m.Config.Parser != "" {
builtinParser = parsers.ParserForName(m.Config.Parser)
}