macOS

anthropic/anthropic.go

@@ -1,778 +0,0 @@
-package anthropic
-
-import (
-	"crypto/rand"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"log/slog"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/ollama/ollama/api"
-)
-
-// Error types matching Anthropic API
-type Error struct {
-	Type    string `json:"type"`
-	Message string `json:"message"`
-}
-
-type ErrorResponse struct {
-	Type      string `json:"type"` // always "error"
-	Error     Error  `json:"error"`
-	RequestID string `json:"request_id,omitempty"`
-}
-
-// NewError creates a new ErrorResponse with the appropriate error type based on HTTP status code
-func NewError(code int, message string) ErrorResponse {
-	var etype string
-	switch code {
-	case http.StatusBadRequest:
-		etype = "invalid_request_error"
-	case http.StatusUnauthorized:
-		etype = "authentication_error"
-	case http.StatusForbidden:
-		etype = "permission_error"
-	case http.StatusNotFound:
-		etype = "not_found_error"
-	case http.StatusTooManyRequests:
-		etype = "rate_limit_error"
-	case http.StatusServiceUnavailable, 529:
-		etype = "overloaded_error"
-	default:
-		etype = "api_error"
-	}
-
-	return ErrorResponse{
-		Type:      "error",
-		Error:     Error{Type: etype, Message: message},
-		RequestID: generateID("req"),
-	}
-}
-
-// Request types
-
-// MessagesRequest represents an Anthropic Messages API request
-type MessagesRequest struct {
-	Model         string          `json:"model"`
-	MaxTokens     int             `json:"max_tokens"`
-	Messages      []MessageParam  `json:"messages"`
-	System        any             `json:"system,omitempty"` // string or []ContentBlock
-	Stream        bool            `json:"stream,omitempty"`
-	Temperature   *float64        `json:"temperature,omitempty"`
-	TopP          *float64        `json:"top_p,omitempty"`
-	TopK          *int            `json:"top_k,omitempty"`
-	StopSequences []string        `json:"stop_sequences,omitempty"`
-	Tools         []Tool          `json:"tools,omitempty"`
-	ToolChoice    *ToolChoice     `json:"tool_choice,omitempty"`
-	Thinking      *ThinkingConfig `json:"thinking,omitempty"`
-	Metadata      *Metadata       `json:"metadata,omitempty"`
-}
-
-// MessageParam represents a message in the request
-type MessageParam struct {
-	Role    string `json:"role"`    // "user" or "assistant"
-	Content any    `json:"content"` // string or []ContentBlock
-}
-
-// ContentBlock represents a content block in a message.
-// Text and Thinking use pointers so they serialize as the field being present (even if empty)
-// only when set, which is required for SDK streaming accumulation.
-type ContentBlock struct {
-	Type string `json:"type"` // text, image, tool_use, tool_result, thinking
-
-	// For text blocks - pointer so field only appears when set (SDK requires it for accumulation)
-	Text *string `json:"text,omitempty"`
-
-	// For image blocks
-	Source *ImageSource `json:"source,omitempty"`
-
-	// For tool_use blocks
-	ID    string `json:"id,omitempty"`
-	Name  string `json:"name,omitempty"`
-	Input any    `json:"input,omitempty"`
-
-	// For tool_result blocks
-	ToolUseID string `json:"tool_use_id,omitempty"`
-	Content   any    `json:"content,omitempty"` // string or []ContentBlock
-	IsError   bool   `json:"is_error,omitempty"`
-
-	// For thinking blocks - pointer so field only appears when set (SDK requires it for accumulation)
-	Thinking  *string `json:"thinking,omitempty"`
-	Signature string  `json:"signature,omitempty"`
-}
-
-// ImageSource represents the source of an image
-type ImageSource struct {
-	Type      string `json:"type"` // "base64" or "url"
-	MediaType string `json:"media_type,omitempty"`
-	Data      string `json:"data,omitempty"`
-	URL       string `json:"url,omitempty"`
-}
-
-// Tool represents a tool definition
-type Tool struct {
-	Type        string          `json:"type,omitempty"` // "custom" for user-defined tools
-	Name        string          `json:"name"`
-	Description string          `json:"description,omitempty"`
-	InputSchema json.RawMessage `json:"input_schema,omitempty"`
-}
-
-// ToolChoice controls how the model uses tools
-type ToolChoice struct {
-	Type                   string `json:"type"` // "auto", "any", "tool", "none"
-	Name                   string `json:"name,omitempty"`
-	DisableParallelToolUse bool   `json:"disable_parallel_tool_use,omitempty"`
-}
-
-// ThinkingConfig controls extended thinking
-type ThinkingConfig struct {
-	Type         string `json:"type"` // "enabled" or "disabled"
-	BudgetTokens int    `json:"budget_tokens,omitempty"`
-}
-
-// Metadata for the request
-type Metadata struct {
-	UserID string `json:"user_id,omitempty"`
-}
-
-// Response types
-
-// MessagesResponse represents an Anthropic Messages API response
-type MessagesResponse struct {
-	ID           string         `json:"id"`
-	Type         string         `json:"type"` // "message"
-	Role         string         `json:"role"` // "assistant"
-	Model        string         `json:"model"`
-	Content      []ContentBlock `json:"content"`
-	StopReason   string         `json:"stop_reason,omitempty"`
-	StopSequence string         `json:"stop_sequence,omitempty"`
-	Usage        Usage          `json:"usage"`
-}
-
-// Usage contains token usage information
-type Usage struct {
-	InputTokens  int `json:"input_tokens"`
-	OutputTokens int `json:"output_tokens"`
-}
-
-// Streaming event types
-
-// MessageStartEvent is sent at the start of streaming
-type MessageStartEvent struct {
-	Type    string           `json:"type"` // "message_start"
-	Message MessagesResponse `json:"message"`
-}
-
-// ContentBlockStartEvent signals the start of a content block
-type ContentBlockStartEvent struct {
-	Type         string       `json:"type"` // "content_block_start"
-	Index        int          `json:"index"`
-	ContentBlock ContentBlock `json:"content_block"`
-}
-
-// ContentBlockDeltaEvent contains incremental content updates
-type ContentBlockDeltaEvent struct {
-	Type  string `json:"type"` // "content_block_delta"
-	Index int    `json:"index"`
-	Delta Delta  `json:"delta"`
-}
-
-// Delta represents an incremental update
-type Delta struct {
-	Type        string `json:"type"` // "text_delta", "input_json_delta", "thinking_delta", "signature_delta"
-	Text        string `json:"text,omitempty"`
-	PartialJSON string `json:"partial_json,omitempty"`
-	Thinking    string `json:"thinking,omitempty"`
-	Signature   string `json:"signature,omitempty"`
-}
-
-// ContentBlockStopEvent signals the end of a content block
-type ContentBlockStopEvent struct {
-	Type  string `json:"type"` // "content_block_stop"
-	Index int    `json:"index"`
-}
-
-// MessageDeltaEvent contains updates to the message
-type MessageDeltaEvent struct {
-	Type  string       `json:"type"` // "message_delta"
-	Delta MessageDelta `json:"delta"`
-	Usage DeltaUsage   `json:"usage"`
-}
-
-// MessageDelta contains stop information
-type MessageDelta struct {
-	StopReason   string `json:"stop_reason,omitempty"`
-	StopSequence string `json:"stop_sequence,omitempty"`
-}
-
-// DeltaUsage contains cumulative token usage
-type DeltaUsage struct {
-	OutputTokens int `json:"output_tokens"`
-}
-
-// MessageStopEvent signals the end of the message
-type MessageStopEvent struct {
-	Type string `json:"type"` // "message_stop"
-}
-
-// PingEvent is a keepalive event
-type PingEvent struct {
-	Type string `json:"type"` // "ping"
-}
-
-// StreamErrorEvent is an error during streaming
-type StreamErrorEvent struct {
-	Type  string `json:"type"` // "error"
-	Error Error  `json:"error"`
-}
-
-// FromMessagesRequest converts an Anthropic MessagesRequest to an Ollama api.ChatRequest
-func FromMessagesRequest(r MessagesRequest) (*api.ChatRequest, error) {
-	var messages []api.Message
-
-	if r.System != nil {
-		switch sys := r.System.(type) {
-		case string:
-			if sys != "" {
-				messages = append(messages, api.Message{Role: "system", Content: sys})
-			}
-		case []any:
-			// System can be an array of content blocks
-			var content strings.Builder
-			for _, block := range sys {
-				if blockMap, ok := block.(map[string]any); ok {
-					if blockMap["type"] == "text" {
-						if text, ok := blockMap["text"].(string); ok {
-							content.WriteString(text)
-						}
-					}
-				}
-			}
-			if content.Len() > 0 {
-				messages = append(messages, api.Message{Role: "system", Content: content.String()})
-			}
-		}
-	}
-
-	for _, msg := range r.Messages {
-		converted, err := convertMessage(msg)
-		if err != nil {
-			return nil, err
-		}
-		messages = append(messages, converted...)
-	}
-
-	options := make(map[string]any)
-
-	options["num_predict"] = r.MaxTokens
-
-	if r.Temperature != nil {
-		options["temperature"] = *r.Temperature
-	}
-
-	if r.TopP != nil {
-		options["top_p"] = *r.TopP
-	}
-
-	if r.TopK != nil {
-		options["top_k"] = *r.TopK
-	}
-
-	if len(r.StopSequences) > 0 {
-		options["stop"] = r.StopSequences
-	}
-
-	var tools api.Tools
-	for _, t := range r.Tools {
-		tool, err := convertTool(t)
-		if err != nil {
-			return nil, err
-		}
-		tools = append(tools, tool)
-	}
-
-	var think *api.ThinkValue
-	if r.Thinking != nil && r.Thinking.Type == "enabled" {
-		think = &api.ThinkValue{Value: true}
-	}
-
-	stream := r.Stream
-
-	return &api.ChatRequest{
-		Model:    r.Model,
-		Messages: messages,
-		Options:  options,
-		Stream:   &stream,
-		Tools:    tools,
-		Think:    think,
-	}, nil
-}
-
-// convertMessage converts an Anthropic MessageParam to Ollama api.Message(s)
-func convertMessage(msg MessageParam) ([]api.Message, error) {
-	var messages []api.Message
-	role := strings.ToLower(msg.Role)
-
-	switch content := msg.Content.(type) {
-	case string:
-		messages = append(messages, api.Message{Role: role, Content: content})
-
-	case []any:
-		var textContent strings.Builder
-		var images []api.ImageData
-		var toolCalls []api.ToolCall
-		var thinking string
-		var toolResults []api.Message
-
-		for _, block := range content {
-			blockMap, ok := block.(map[string]any)
-			if !ok {
-				return nil, errors.New("invalid content block format")
-			}
-
-			blockType, _ := blockMap["type"].(string)
-
-			switch blockType {
-			case "text":
-				if text, ok := blockMap["text"].(string); ok {
-					textContent.WriteString(text)
-				}
-
-			case "image":
-				source, ok := blockMap["source"].(map[string]any)
-				if !ok {
-					return nil, errors.New("invalid image source")
-				}
-
-				sourceType, _ := source["type"].(string)
-				if sourceType == "base64" {
-					data, _ := source["data"].(string)
-					decoded, err := base64.StdEncoding.DecodeString(data)
-					if err != nil {
-						return nil, fmt.Errorf("invalid base64 image data: %w", err)
-					}
-					images = append(images, decoded)
-				} else {
-					return nil, fmt.Errorf("invalid image source type: %s. Only base64 images are supported.", sourceType)
-				}
-				// URL images would need to be fetched - skip for now
-
-			case "tool_use":
-				id, ok := blockMap["id"].(string)
-				if !ok {
-					return nil, errors.New("tool_use block missing required 'id' field")
-				}
-				name, ok := blockMap["name"].(string)
-				if !ok {
-					return nil, errors.New("tool_use block missing required 'name' field")
-				}
-				tc := api.ToolCall{
-					ID: id,
-					Function: api.ToolCallFunction{
-						Name: name,
-					},
-				}
-				if input, ok := blockMap["input"].(map[string]any); ok {
-					tc.Function.Arguments = mapToArgs(input)
-				}
-				toolCalls = append(toolCalls, tc)
-
-			case "tool_result":
-				toolUseID, _ := blockMap["tool_use_id"].(string)
-				var resultContent string
-
-				switch c := blockMap["content"].(type) {
-				case string:
-					resultContent = c
-				case []any:
-					for _, cb := range c {
-						if cbMap, ok := cb.(map[string]any); ok {
-							if cbMap["type"] == "text" {
-								if text, ok := cbMap["text"].(string); ok {
-									resultContent += text
-								}
-							}
-						}
-					}
-				}
-
-				toolResults = append(toolResults, api.Message{
-					Role:       "tool",
-					Content:    resultContent,
-					ToolCallID: toolUseID,
-				})
-
-			case "thinking":
-				if t, ok := blockMap["thinking"].(string); ok {
-					thinking = t
-				}
-			}
-		}
-
-		if textContent.Len() > 0 || len(images) > 0 || len(toolCalls) > 0 || thinking != "" {
-			m := api.Message{
-				Role:      role,
-				Content:   textContent.String(),
-				Images:    images,
-				ToolCalls: toolCalls,
-				Thinking:  thinking,
-			}
-			messages = append(messages, m)
-		}
-
-		// Add tool results as separate messages
-		messages = append(messages, toolResults...)
-
-	default:
-		return nil, fmt.Errorf("invalid message content type: %T", content)
-	}
-
-	return messages, nil
-}
-
-// convertTool converts an Anthropic Tool to an Ollama api.Tool
-func convertTool(t Tool) (api.Tool, error) {
-	var params api.ToolFunctionParameters
-	if len(t.InputSchema) > 0 {
-		if err := json.Unmarshal(t.InputSchema, &params); err != nil {
-			return api.Tool{}, fmt.Errorf("invalid input_schema for tool %q: %w", t.Name, err)
-		}
-	}
-
-	return api.Tool{
-		Type: "function",
-		Function: api.ToolFunction{
-			Name:        t.Name,
-			Description: t.Description,
-			Parameters:  params,
-		},
-	}, nil
-}
-
-// ToMessagesResponse converts an Ollama api.ChatResponse to an Anthropic MessagesResponse
-func ToMessagesResponse(id string, r api.ChatResponse) MessagesResponse {
-	var content []ContentBlock
-
-	if r.Message.Thinking != "" {
-		content = append(content, ContentBlock{
-			Type:     "thinking",
-			Thinking: ptr(r.Message.Thinking),
-		})
-	}
-
-	if r.Message.Content != "" {
-		content = append(content, ContentBlock{
-			Type: "text",
-			Text: ptr(r.Message.Content),
-		})
-	}
-
-	for _, tc := range r.Message.ToolCalls {
-		content = append(content, ContentBlock{
-			Type:  "tool_use",
-			ID:    tc.ID,
-			Name:  tc.Function.Name,
-			Input: tc.Function.Arguments,
-		})
-	}
-
-	stopReason := mapStopReason(r.DoneReason, len(r.Message.ToolCalls) > 0)
-
-	return MessagesResponse{
-		ID:         id,
-		Type:       "message",
-		Role:       "assistant",
-		Model:      r.Model,
-		Content:    content,
-		StopReason: stopReason,
-		Usage: Usage{
-			InputTokens:  r.Metrics.PromptEvalCount,
-			OutputTokens: r.Metrics.EvalCount,
-		},
-	}
-}
-
-// mapStopReason converts Ollama done_reason to Anthropic stop_reason
-func mapStopReason(reason string, hasToolCalls bool) string {
-	if hasToolCalls {
-		return "tool_use"
-	}
-
-	switch reason {
-	case "stop":
-		return "end_turn"
-	case "length":
-		return "max_tokens"
-	default:
-		if reason != "" {
-			return "stop_sequence"
-		}
-		return ""
-	}
-}
-
-// StreamConverter manages state for converting Ollama streaming responses to Anthropic format
-type StreamConverter struct {
-	ID              string
-	Model           string
-	firstWrite      bool
-	contentIndex    int
-	inputTokens     int
-	outputTokens    int
-	thinkingStarted bool
-	thinkingDone    bool
-	textStarted     bool
-	toolCallsSent   map[string]bool
-}
-
-func NewStreamConverter(id, model string) *StreamConverter {
-	return &StreamConverter{
-		ID:            id,
-		Model:         model,
-		firstWrite:    true,
-		toolCallsSent: make(map[string]bool),
-	}
-}
-
-// StreamEvent represents a streaming event to be sent to the client
-type StreamEvent struct {
-	Event string
-	Data  any
-}
-
-// Process converts an Ollama ChatResponse to Anthropic streaming events
-func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
-	var events []StreamEvent
-
-	if c.firstWrite {
-		c.firstWrite = false
-		c.inputTokens = r.Metrics.PromptEvalCount
-
-		events = append(events, StreamEvent{
-			Event: "message_start",
-			Data: MessageStartEvent{
-				Type: "message_start",
-				Message: MessagesResponse{
-					ID:      c.ID,
-					Type:    "message",
-					Role:    "assistant",
-					Model:   c.Model,
-					Content: []ContentBlock{},
-					Usage: Usage{
-						InputTokens:  c.inputTokens,
-						OutputTokens: 0,
-					},
-				},
-			},
-		})
-	}
-
-	if r.Message.Thinking != "" && !c.thinkingDone {
-		if !c.thinkingStarted {
-			c.thinkingStarted = true
-			events = append(events, StreamEvent{
-				Event: "content_block_start",
-				Data: ContentBlockStartEvent{
-					Type:  "content_block_start",
-					Index: c.contentIndex,
-					ContentBlock: ContentBlock{
-						Type:     "thinking",
-						Thinking: ptr(""),
-					},
-				},
-			})
-		}
-
-		events = append(events, StreamEvent{
-			Event: "content_block_delta",
-			Data: ContentBlockDeltaEvent{
-				Type:  "content_block_delta",
-				Index: c.contentIndex,
-				Delta: Delta{
-					Type:     "thinking_delta",
-					Thinking: r.Message.Thinking,
-				},
-			},
-		})
-	}
-
-	if r.Message.Content != "" {
-		if c.thinkingStarted && !c.thinkingDone {
-			c.thinkingDone = true
-			events = append(events, StreamEvent{
-				Event: "content_block_stop",
-				Data: ContentBlockStopEvent{
-					Type:  "content_block_stop",
-					Index: c.contentIndex,
-				},
-			})
-			c.contentIndex++
-		}
-
-		if !c.textStarted {
-			c.textStarted = true
-			events = append(events, StreamEvent{
-				Event: "content_block_start",
-				Data: ContentBlockStartEvent{
-					Type:  "content_block_start",
-					Index: c.contentIndex,
-					ContentBlock: ContentBlock{
-						Type: "text",
-						Text: ptr(""),
-					},
-				},
-			})
-		}
-
-		events = append(events, StreamEvent{
-			Event: "content_block_delta",
-			Data: ContentBlockDeltaEvent{
-				Type:  "content_block_delta",
-				Index: c.contentIndex,
-				Delta: Delta{
-					Type: "text_delta",
-					Text: r.Message.Content,
-				},
-			},
-		})
-	}
-
-	for _, tc := range r.Message.ToolCalls {
-		if c.toolCallsSent[tc.ID] {
-			continue
-		}
-
-		if c.textStarted {
-			events = append(events, StreamEvent{
-				Event: "content_block_stop",
-				Data: ContentBlockStopEvent{
-					Type:  "content_block_stop",
-					Index: c.contentIndex,
-				},
-			})
-			c.contentIndex++
-			c.textStarted = false
-		}
-
-		argsJSON, err := json.Marshal(tc.Function.Arguments)
-		if err != nil {
-			slog.Error("failed to marshal tool arguments", "error", err, "tool_id", tc.ID)
-			continue
-		}
-
-		events = append(events, StreamEvent{
-			Event: "content_block_start",
-			Data: ContentBlockStartEvent{
-				Type:  "content_block_start",
-				Index: c.contentIndex,
-				ContentBlock: ContentBlock{
-					Type:  "tool_use",
-					ID:    tc.ID,
-					Name:  tc.Function.Name,
-					Input: map[string]any{},
-				},
-			},
-		})
-
-		events = append(events, StreamEvent{
-			Event: "content_block_delta",
-			Data: ContentBlockDeltaEvent{
-				Type:  "content_block_delta",
-				Index: c.contentIndex,
-				Delta: Delta{
-					Type:        "input_json_delta",
-					PartialJSON: string(argsJSON),
-				},
-			},
-		})
-
-		events = append(events, StreamEvent{
-			Event: "content_block_stop",
-			Data: ContentBlockStopEvent{
-				Type:  "content_block_stop",
-				Index: c.contentIndex,
-			},
-		})
-
-		c.toolCallsSent[tc.ID] = true
-		c.contentIndex++
-	}
-
-	if r.Done {
-		if c.textStarted {
-			events = append(events, StreamEvent{
-				Event: "content_block_stop",
-				Data: ContentBlockStopEvent{
-					Type:  "content_block_stop",
-					Index: c.contentIndex,
-				},
-			})
-		} else if c.thinkingStarted && !c.thinkingDone {
-			events = append(events, StreamEvent{
-				Event: "content_block_stop",
-				Data: ContentBlockStopEvent{
-					Type:  "content_block_stop",
-					Index: c.contentIndex,
-				},
-			})
-		}
-
-		c.outputTokens = r.Metrics.EvalCount
-		stopReason := mapStopReason(r.DoneReason, len(c.toolCallsSent) > 0)
-
-		events = append(events, StreamEvent{
-			Event: "message_delta",
-			Data: MessageDeltaEvent{
-				Type: "message_delta",
-				Delta: MessageDelta{
-					StopReason: stopReason,
-				},
-				Usage: DeltaUsage{
-					OutputTokens: c.outputTokens,
-				},
-			},
-		})
-
-		events = append(events, StreamEvent{
-			Event: "message_stop",
-			Data: MessageStopEvent{
-				Type: "message_stop",
-			},
-		})
-	}
-
-	return events
-}
-
-// generateID generates a unique ID with the given prefix using crypto/rand
-func generateID(prefix string) string {
-	b := make([]byte, 12)
-	if _, err := rand.Read(b); err != nil {
-		// Fallback to time-based ID if crypto/rand fails
-		return fmt.Sprintf("%s_%d", prefix, time.Now().UnixNano())
-	}
-	return fmt.Sprintf("%s_%x", prefix, b)
-}
-
-// GenerateMessageID generates a unique message ID
-func GenerateMessageID() string {
-	return generateID("msg")
-}
-
-// ptr returns a pointer to the given string value
-func ptr(s string) *string {
-	return &s
-}
-
-// mapToArgs converts a map to ToolCallFunctionArguments
-func mapToArgs(m map[string]any) api.ToolCallFunctionArguments {
-	args := api.NewToolCallFunctionArguments()
-	for k, v := range m {
-		args.Set(k, v)
-	}
-	return args
-}

anthropic/anthropic_test.go

@@ -1,953 +0,0 @@
-package anthropic
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"testing"
-
-	"github.com/google/go-cmp/cmp"
-
-	"github.com/ollama/ollama/api"
-)
-
-const (
-	testImage = `iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=`
-)
-
-// 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
-}
-
-func TestFromMessagesRequest_Basic(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{Role: "user", Content: "Hello"},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Model != "test-model" {
-		t.Errorf("expected model 'test-model', got %q", result.Model)
-	}
-
-	if len(result.Messages) != 1 {
-		t.Fatalf("expected 1 message, got %d", len(result.Messages))
-	}
-
-	if result.Messages[0].Role != "user" || result.Messages[0].Content != "Hello" {
-		t.Errorf("unexpected message: %+v", result.Messages[0])
-	}
-
-	if numPredict, ok := result.Options["num_predict"].(int); !ok || numPredict != 1024 {
-		t.Errorf("expected num_predict 1024, got %v", result.Options["num_predict"])
-	}
-}
-
-func TestFromMessagesRequest_WithSystemPrompt(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		System:    "You are a helpful assistant.",
-		Messages: []MessageParam{
-			{Role: "user", Content: "Hello"},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 2 {
-		t.Fatalf("expected 2 messages, got %d", len(result.Messages))
-	}
-
-	if result.Messages[0].Role != "system" || result.Messages[0].Content != "You are a helpful assistant." {
-		t.Errorf("unexpected system message: %+v", result.Messages[0])
-	}
-}
-
-func TestFromMessagesRequest_WithSystemPromptArray(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		System: []any{
-			map[string]any{"type": "text", "text": "You are helpful."},
-			map[string]any{"type": "text", "text": " Be concise."},
-		},
-		Messages: []MessageParam{
-			{Role: "user", Content: "Hello"},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 2 {
-		t.Fatalf("expected 2 messages, got %d", len(result.Messages))
-	}
-
-	if result.Messages[0].Content != "You are helpful. Be concise." {
-		t.Errorf("unexpected system message content: %q", result.Messages[0].Content)
-	}
-}
-
-func TestFromMessagesRequest_WithOptions(t *testing.T) {
-	temp := 0.7
-	topP := 0.9
-	topK := 40
-	req := MessagesRequest{
-		Model:         "test-model",
-		MaxTokens:     2048,
-		Messages:      []MessageParam{{Role: "user", Content: "Hello"}},
-		Temperature:   &temp,
-		TopP:          &topP,
-		TopK:          &topK,
-		StopSequences: []string{"\n", "END"},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Options["temperature"] != 0.7 {
-		t.Errorf("expected temperature 0.7, got %v", result.Options["temperature"])
-	}
-	if result.Options["top_p"] != 0.9 {
-		t.Errorf("expected top_p 0.9, got %v", result.Options["top_p"])
-	}
-	if result.Options["top_k"] != 40 {
-		t.Errorf("expected top_k 40, got %v", result.Options["top_k"])
-	}
-	if diff := cmp.Diff([]string{"\n", "END"}, result.Options["stop"]); diff != "" {
-		t.Errorf("stop sequences mismatch: %s", diff)
-	}
-}
-
-func TestFromMessagesRequest_WithImage(t *testing.T) {
-	imgData, _ := base64.StdEncoding.DecodeString(testImage)
-
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{
-				Role: "user",
-				Content: []any{
-					map[string]any{"type": "text", "text": "What's in this image?"},
-					map[string]any{
-						"type": "image",
-						"source": map[string]any{
-							"type":       "base64",
-							"media_type": "image/png",
-							"data":       testImage,
-						},
-					},
-				},
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 1 {
-		t.Fatalf("expected 1 message, got %d", len(result.Messages))
-	}
-
-	if result.Messages[0].Content != "What's in this image?" {
-		t.Errorf("expected content 'What's in this image?', got %q", result.Messages[0].Content)
-	}
-
-	if len(result.Messages[0].Images) != 1 {
-		t.Fatalf("expected 1 image, got %d", len(result.Messages[0].Images))
-	}
-
-	if string(result.Messages[0].Images[0]) != string(imgData) {
-		t.Error("image data mismatch")
-	}
-}
-
-func TestFromMessagesRequest_WithToolUse(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{Role: "user", Content: "What's the weather in Paris?"},
-			{
-				Role: "assistant",
-				Content: []any{
-					map[string]any{
-						"type":  "tool_use",
-						"id":    "call_123",
-						"name":  "get_weather",
-						"input": map[string]any{"location": "Paris"},
-					},
-				},
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 2 {
-		t.Fatalf("expected 2 messages, got %d", len(result.Messages))
-	}
-
-	if len(result.Messages[1].ToolCalls) != 1 {
-		t.Fatalf("expected 1 tool call, got %d", len(result.Messages[1].ToolCalls))
-	}
-
-	tc := result.Messages[1].ToolCalls[0]
-	if tc.ID != "call_123" {
-		t.Errorf("expected tool call ID 'call_123', got %q", tc.ID)
-	}
-	if tc.Function.Name != "get_weather" {
-		t.Errorf("expected tool name 'get_weather', got %q", tc.Function.Name)
-	}
-}
-
-func TestFromMessagesRequest_WithToolResult(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{
-				Role: "user",
-				Content: []any{
-					map[string]any{
-						"type":        "tool_result",
-						"tool_use_id": "call_123",
-						"content":     "The weather in Paris is sunny, 22°C",
-					},
-				},
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 1 {
-		t.Fatalf("expected 1 message, got %d", len(result.Messages))
-	}
-
-	msg := result.Messages[0]
-	if msg.Role != "tool" {
-		t.Errorf("expected role 'tool', got %q", msg.Role)
-	}
-	if msg.ToolCallID != "call_123" {
-		t.Errorf("expected tool_call_id 'call_123', got %q", msg.ToolCallID)
-	}
-	if msg.Content != "The weather in Paris is sunny, 22°C" {
-		t.Errorf("unexpected content: %q", msg.Content)
-	}
-}
-
-func TestFromMessagesRequest_WithTools(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: "Hello"}},
-		Tools: []Tool{
-			{
-				Name:        "get_weather",
-				Description: "Get current weather",
-				InputSchema: json.RawMessage(`{"type":"object","properties":{"location":{"type":"string"}},"required":["location"]}`),
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Tools) != 1 {
-		t.Fatalf("expected 1 tool, got %d", len(result.Tools))
-	}
-
-	tool := result.Tools[0]
-	if tool.Type != "function" {
-		t.Errorf("expected type 'function', got %q", tool.Type)
-	}
-	if tool.Function.Name != "get_weather" {
-		t.Errorf("expected name 'get_weather', got %q", tool.Function.Name)
-	}
-	if tool.Function.Description != "Get current weather" {
-		t.Errorf("expected description 'Get current weather', got %q", tool.Function.Description)
-	}
-}
-
-func TestFromMessagesRequest_WithThinking(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: "Hello"}},
-		Thinking:  &ThinkingConfig{Type: "enabled", BudgetTokens: 1000},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Think == nil {
-		t.Fatal("expected Think to be set")
-	}
-	if v, ok := result.Think.Value.(bool); !ok || !v {
-		t.Errorf("expected Think.Value to be true, got %v", result.Think.Value)
-	}
-}
-
-// TestFromMessagesRequest_ThinkingOnlyBlock verifies that messages containing only
-// a thinking block (no text, images, or tool calls) are preserved and not dropped.
-func TestFromMessagesRequest_ThinkingOnlyBlock(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{Role: "user", Content: "Hello"},
-			{
-				Role: "assistant",
-				Content: []any{
-					map[string]any{
-						"type":     "thinking",
-						"thinking": "Let me think about this...",
-					},
-				},
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 2 {
-		t.Fatalf("expected 2 messages, got %d", len(result.Messages))
-	}
-
-	assistantMsg := result.Messages[1]
-	if assistantMsg.Thinking != "Let me think about this..." {
-		t.Errorf("expected thinking content, got %q", assistantMsg.Thinking)
-	}
-}
-
-func TestFromMessagesRequest_ToolUseMissingID(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{
-				Role: "assistant",
-				Content: []any{
-					map[string]any{
-						"type": "tool_use",
-						"name": "get_weather",
-					},
-				},
-			},
-		},
-	}
-
-	_, err := FromMessagesRequest(req)
-	if err == nil {
-		t.Fatal("expected error for missing tool_use id")
-	}
-	if err.Error() != "tool_use block missing required 'id' field" {
-		t.Errorf("unexpected error message: %v", err)
-	}
-}
-
-func TestFromMessagesRequest_ToolUseMissingName(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{
-				Role: "assistant",
-				Content: []any{
-					map[string]any{
-						"type": "tool_use",
-						"id":   "call_123",
-					},
-				},
-			},
-		},
-	}
-
-	_, err := FromMessagesRequest(req)
-	if err == nil {
-		t.Fatal("expected error for missing tool_use name")
-	}
-	if err.Error() != "tool_use block missing required 'name' field" {
-		t.Errorf("unexpected error message: %v", err)
-	}
-}
-
-func TestFromMessagesRequest_InvalidToolSchema(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: "Hello"}},
-		Tools: []Tool{
-			{
-				Name:        "bad_tool",
-				InputSchema: json.RawMessage(`{invalid json`),
-			},
-		},
-	}
-
-	_, err := FromMessagesRequest(req)
-	if err == nil {
-		t.Fatal("expected error for invalid tool schema")
-	}
-}
-
-func TestToMessagesResponse_Basic(t *testing.T) {
-	resp := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role:    "assistant",
-			Content: "Hello there!",
-		},
-		Done:       true,
-		DoneReason: "stop",
-		Metrics: api.Metrics{
-			PromptEvalCount: 10,
-			EvalCount:       5,
-		},
-	}
-
-	result := ToMessagesResponse("msg_123", resp)
-
-	if result.ID != "msg_123" {
-		t.Errorf("expected ID 'msg_123', got %q", result.ID)
-	}
-	if result.Type != "message" {
-		t.Errorf("expected type 'message', got %q", result.Type)
-	}
-	if result.Role != "assistant" {
-		t.Errorf("expected role 'assistant', got %q", result.Role)
-	}
-	if len(result.Content) != 1 {
-		t.Fatalf("expected 1 content block, got %d", len(result.Content))
-	}
-	if result.Content[0].Type != "text" || result.Content[0].Text == nil || *result.Content[0].Text != "Hello there!" {
-		t.Errorf("unexpected content: %+v", result.Content[0])
-	}
-	if result.StopReason != "end_turn" {
-		t.Errorf("expected stop_reason 'end_turn', got %q", result.StopReason)
-	}
-	if result.Usage.InputTokens != 10 || result.Usage.OutputTokens != 5 {
-		t.Errorf("unexpected usage: %+v", result.Usage)
-	}
-}
-
-func TestToMessagesResponse_WithToolCalls(t *testing.T) {
-	resp := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role: "assistant",
-			ToolCalls: []api.ToolCall{
-				{
-					ID: "call_123",
-					Function: api.ToolCallFunction{
-						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"location": "Paris"}),
-					},
-				},
-			},
-		},
-		Done:       true,
-		DoneReason: "stop",
-	}
-
-	result := ToMessagesResponse("msg_123", resp)
-
-	if len(result.Content) != 1 {
-		t.Fatalf("expected 1 content block, got %d", len(result.Content))
-	}
-	if result.Content[0].Type != "tool_use" {
-		t.Errorf("expected type 'tool_use', got %q", result.Content[0].Type)
-	}
-	if result.Content[0].ID != "call_123" {
-		t.Errorf("expected ID 'call_123', got %q", result.Content[0].ID)
-	}
-	if result.Content[0].Name != "get_weather" {
-		t.Errorf("expected name 'get_weather', got %q", result.Content[0].Name)
-	}
-	if result.StopReason != "tool_use" {
-		t.Errorf("expected stop_reason 'tool_use', got %q", result.StopReason)
-	}
-}
-
-func TestToMessagesResponse_WithThinking(t *testing.T) {
-	resp := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role:     "assistant",
-			Content:  "The answer is 42.",
-			Thinking: "Let me think about this...",
-		},
-		Done:       true,
-		DoneReason: "stop",
-	}
-
-	result := ToMessagesResponse("msg_123", resp)
-
-	if len(result.Content) != 2 {
-		t.Fatalf("expected 2 content blocks, got %d", len(result.Content))
-	}
-	if result.Content[0].Type != "thinking" {
-		t.Errorf("expected first block type 'thinking', got %q", result.Content[0].Type)
-	}
-	if result.Content[0].Thinking == nil || *result.Content[0].Thinking != "Let me think about this..." {
-		t.Errorf("unexpected thinking content: %v", result.Content[0].Thinking)
-	}
-	if result.Content[1].Type != "text" {
-		t.Errorf("expected second block type 'text', got %q", result.Content[1].Type)
-	}
-}
-
-func TestMapStopReason(t *testing.T) {
-	tests := []struct {
-		reason       string
-		hasToolCalls bool
-		want         string
-	}{
-		{"stop", false, "end_turn"},
-		{"length", false, "max_tokens"},
-		{"stop", true, "tool_use"},
-		{"other", false, "stop_sequence"},
-		{"", false, ""},
-	}
-
-	for _, tt := range tests {
-		got := mapStopReason(tt.reason, tt.hasToolCalls)
-		if got != tt.want {
-			t.Errorf("mapStopReason(%q, %v) = %q, want %q", tt.reason, tt.hasToolCalls, got, tt.want)
-		}
-	}
-}
-
-func TestNewError(t *testing.T) {
-	tests := []struct {
-		code int
-		want string
-	}{
-		{400, "invalid_request_error"},
-		{401, "authentication_error"},
-		{403, "permission_error"},
-		{404, "not_found_error"},
-		{429, "rate_limit_error"},
-		{500, "api_error"},
-		{503, "overloaded_error"},
-		{529, "overloaded_error"},
-	}
-
-	for _, tt := range tests {
-		result := NewError(tt.code, "test message")
-		if result.Type != "error" {
-			t.Errorf("NewError(%d) type = %q, want 'error'", tt.code, result.Type)
-		}
-		if result.Error.Type != tt.want {
-			t.Errorf("NewError(%d) error.type = %q, want %q", tt.code, result.Error.Type, tt.want)
-		}
-		if result.Error.Message != "test message" {
-			t.Errorf("NewError(%d) message = %q, want 'test message'", tt.code, result.Error.Message)
-		}
-		if result.RequestID == "" {
-			t.Errorf("NewError(%d) request_id should not be empty", tt.code)
-		}
-	}
-}
-
-func TestGenerateMessageID(t *testing.T) {
-	id1 := GenerateMessageID()
-	id2 := GenerateMessageID()
-
-	if id1 == "" {
-		t.Error("GenerateMessageID returned empty string")
-	}
-	if id1 == id2 {
-		t.Error("GenerateMessageID returned duplicate IDs")
-	}
-	if len(id1) < 10 {
-		t.Errorf("GenerateMessageID returned short ID: %q", id1)
-	}
-	if id1[:4] != "msg_" {
-		t.Errorf("GenerateMessageID should start with 'msg_', got %q", id1[:4])
-	}
-}
-
-func TestStreamConverter_Basic(t *testing.T) {
-	conv := NewStreamConverter("msg_123", "test-model")
-
-	// First chunk
-	resp1 := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role:    "assistant",
-			Content: "Hello",
-		},
-		Metrics: api.Metrics{PromptEvalCount: 10},
-	}
-
-	events1 := conv.Process(resp1)
-	if len(events1) < 3 {
-		t.Fatalf("expected at least 3 events for first chunk, got %d", len(events1))
-	}
-
-	// Should have message_start, content_block_start, content_block_delta
-	if events1[0].Event != "message_start" {
-		t.Errorf("expected first event 'message_start', got %q", events1[0].Event)
-	}
-	if events1[1].Event != "content_block_start" {
-		t.Errorf("expected second event 'content_block_start', got %q", events1[1].Event)
-	}
-	if events1[2].Event != "content_block_delta" {
-		t.Errorf("expected third event 'content_block_delta', got %q", events1[2].Event)
-	}
-
-	// Final chunk
-	resp2 := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role:    "assistant",
-			Content: " world!",
-		},
-		Done:       true,
-		DoneReason: "stop",
-		Metrics:    api.Metrics{EvalCount: 5},
-	}
-
-	events2 := conv.Process(resp2)
-
-	// Should have content_block_delta, content_block_stop, message_delta, message_stop
-	hasStop := false
-	for _, e := range events2 {
-		if e.Event == "message_stop" {
-			hasStop = true
-		}
-	}
-	if !hasStop {
-		t.Error("expected message_stop event in final chunk")
-	}
-}
-
-func TestStreamConverter_WithToolCalls(t *testing.T) {
-	conv := NewStreamConverter("msg_123", "test-model")
-
-	resp := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role: "assistant",
-			ToolCalls: []api.ToolCall{
-				{
-					ID: "call_123",
-					Function: api.ToolCallFunction{
-						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"location": "Paris"}),
-					},
-				},
-			},
-		},
-		Done:       true,
-		DoneReason: "stop",
-		Metrics:    api.Metrics{PromptEvalCount: 10, EvalCount: 5},
-	}
-
-	events := conv.Process(resp)
-
-	hasToolStart := false
-	hasToolDelta := false
-	for _, e := range events {
-		if e.Event == "content_block_start" {
-			if start, ok := e.Data.(ContentBlockStartEvent); ok {
-				if start.ContentBlock.Type == "tool_use" {
-					hasToolStart = true
-				}
-			}
-		}
-		if e.Event == "content_block_delta" {
-			if delta, ok := e.Data.(ContentBlockDeltaEvent); ok {
-				if delta.Delta.Type == "input_json_delta" {
-					hasToolDelta = true
-				}
-			}
-		}
-	}
-
-	if !hasToolStart {
-		t.Error("expected tool_use content_block_start event")
-	}
-	if !hasToolDelta {
-		t.Error("expected input_json_delta event")
-	}
-}
-
-func TestStreamConverter_ToolCallWithUnmarshalableArgs(t *testing.T) {
-	// Test that unmarshalable arguments (like channels) are handled gracefully
-	// and don't cause a panic or corrupt stream
-	conv := NewStreamConverter("msg_123", "test-model")
-
-	// Create a channel which cannot be JSON marshaled
-	unmarshalable := make(chan int)
-	badArgs := api.NewToolCallFunctionArguments()
-	badArgs.Set("channel", unmarshalable)
-
-	resp := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role: "assistant",
-			ToolCalls: []api.ToolCall{
-				{
-					ID: "call_bad",
-					Function: api.ToolCallFunction{
-						Name:      "bad_function",
-						Arguments: badArgs,
-					},
-				},
-			},
-		},
-		Done:       true,
-		DoneReason: "stop",
-	}
-
-	// Should not panic and should skip the unmarshalable tool call
-	events := conv.Process(resp)
-
-	// Verify no tool_use block was started (since marshal failed before block start)
-	hasToolStart := false
-	for _, e := range events {
-		if e.Event == "content_block_start" {
-			if start, ok := e.Data.(ContentBlockStartEvent); ok {
-				if start.ContentBlock.Type == "tool_use" {
-					hasToolStart = true
-				}
-			}
-		}
-	}
-
-	if hasToolStart {
-		t.Error("expected no tool_use block when arguments cannot be marshaled")
-	}
-}
-
-func TestStreamConverter_MultipleToolCallsWithMixedValidity(t *testing.T) {
-	// Test that valid tool calls still work when mixed with invalid ones
-	conv := NewStreamConverter("msg_123", "test-model")
-
-	unmarshalable := make(chan int)
-	badArgs := api.NewToolCallFunctionArguments()
-	badArgs.Set("channel", unmarshalable)
-
-	resp := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role: "assistant",
-			ToolCalls: []api.ToolCall{
-				{
-					ID: "call_good",
-					Function: api.ToolCallFunction{
-						Name:      "good_function",
-						Arguments: testArgs(map[string]any{"location": "Paris"}),
-					},
-				},
-				{
-					ID: "call_bad",
-					Function: api.ToolCallFunction{
-						Name:      "bad_function",
-						Arguments: badArgs,
-					},
-				},
-			},
-		},
-		Done:       true,
-		DoneReason: "stop",
-	}
-
-	events := conv.Process(resp)
-
-	// Count tool_use blocks - should only have 1 (the valid one)
-	toolStartCount := 0
-	toolDeltaCount := 0
-	for _, e := range events {
-		if e.Event == "content_block_start" {
-			if start, ok := e.Data.(ContentBlockStartEvent); ok {
-				if start.ContentBlock.Type == "tool_use" {
-					toolStartCount++
-					if start.ContentBlock.Name != "good_function" {
-						t.Errorf("expected tool name 'good_function', got %q", start.ContentBlock.Name)
-					}
-				}
-			}
-		}
-		if e.Event == "content_block_delta" {
-			if delta, ok := e.Data.(ContentBlockDeltaEvent); ok {
-				if delta.Delta.Type == "input_json_delta" {
-					toolDeltaCount++
-				}
-			}
-		}
-	}
-
-	if toolStartCount != 1 {
-		t.Errorf("expected 1 tool_use block, got %d", toolStartCount)
-	}
-	if toolDeltaCount != 1 {
-		t.Errorf("expected 1 input_json_delta, got %d", toolDeltaCount)
-	}
-}
-
-// TestContentBlockJSON_EmptyFieldsPresent verifies that empty text and thinking fields
-// are serialized in JSON output. The Anthropic SDK requires these fields to be present
-// (even when empty) in content_block_start events to properly accumulate streaming deltas.
-// Without these fields, the SDK throws: "TypeError: unsupported operand type(s) for +=: 'NoneType' and 'str'"
-func TestContentBlockJSON_EmptyFieldsPresent(t *testing.T) {
-	tests := []struct {
-		name     string
-		block    ContentBlock
-		wantKeys []string
-	}{
-		{
-			name: "text block includes empty text field",
-			block: ContentBlock{
-				Type: "text",
-				Text: ptr(""),
-			},
-			wantKeys: []string{"type", "text"},
-		},
-		{
-			name: "thinking block includes empty thinking field",
-			block: ContentBlock{
-				Type:     "thinking",
-				Thinking: ptr(""),
-			},
-			wantKeys: []string{"type", "thinking"},
-		},
-		{
-			name: "text block with content",
-			block: ContentBlock{
-				Type: "text",
-				Text: ptr("hello"),
-			},
-			wantKeys: []string{"type", "text"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			data, err := json.Marshal(tt.block)
-			if err != nil {
-				t.Fatalf("failed to marshal: %v", err)
-			}
-
-			var result map[string]any
-			if err := json.Unmarshal(data, &result); err != nil {
-				t.Fatalf("failed to unmarshal: %v", err)
-			}
-
-			for _, key := range tt.wantKeys {
-				if _, ok := result[key]; !ok {
-					t.Errorf("expected key %q to be present in JSON output, got: %s", key, string(data))
-				}
-			}
-		})
-	}
-}
-
-// TestStreamConverter_ContentBlockStartIncludesEmptyFields verifies that content_block_start
-// events include the required empty fields for SDK compatibility.
-func TestStreamConverter_ContentBlockStartIncludesEmptyFields(t *testing.T) {
-	t.Run("text block start includes empty text", func(t *testing.T) {
-		conv := NewStreamConverter("msg_123", "test-model")
-
-		resp := api.ChatResponse{
-			Model:   "test-model",
-			Message: api.Message{Role: "assistant", Content: "hello"},
-		}
-
-		events := conv.Process(resp)
-
-		var foundTextStart bool
-		for _, e := range events {
-			if e.Event == "content_block_start" {
-				if start, ok := e.Data.(ContentBlockStartEvent); ok {
-					if start.ContentBlock.Type == "text" {
-						foundTextStart = true
-						// Marshal and verify the text field is present
-						data, _ := json.Marshal(start)
-						var result map[string]any
-						json.Unmarshal(data, &result)
-						cb := result["content_block"].(map[string]any)
-						if _, ok := cb["text"]; !ok {
-							t.Error("content_block_start for text should include 'text' field")
-						}
-					}
-				}
-			}
-		}
-
-		if !foundTextStart {
-			t.Error("expected text content_block_start event")
-		}
-	})
-
-	t.Run("thinking block start includes empty thinking", func(t *testing.T) {
-		conv := NewStreamConverter("msg_123", "test-model")
-
-		resp := api.ChatResponse{
-			Model:   "test-model",
-			Message: api.Message{Role: "assistant", Thinking: "let me think..."},
-		}
-
-		events := conv.Process(resp)
-
-		var foundThinkingStart bool
-		for _, e := range events {
-			if e.Event == "content_block_start" {
-				if start, ok := e.Data.(ContentBlockStartEvent); ok {
-					if start.ContentBlock.Type == "thinking" {
-						foundThinkingStart = true
-						data, _ := json.Marshal(start)
-						var result map[string]any
-						json.Unmarshal(data, &result)
-						cb := result["content_block"].(map[string]any)
-						if _, ok := cb["thinking"]; !ok {
-							t.Error("content_block_start for thinking should include 'thinking' field")
-						}
-					}
-				}
-			}
-		}
-
-		if !foundThinkingStart {
-			t.Error("expected thinking content_block_start event")
-		}
-	})
-}

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 {

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/cmd/app/app.go

@@ -209,6 +209,9 @@ func main() {
 
 	st := &store.Store{}
 
+	// Initialize native settings with store
+	SetSettingsStore(st)
+
 	// Enable CORS in development mode
 	if devMode {
 		os.Setenv("OLLAMA_CORS", "1")
@@ -253,22 +256,27 @@ func main() {
 		done <- osrv.Run(octx)
 	}()
 
+	restartServer := func() {
+		ocancel()
+		<-done
+		octx, ocancel = context.WithCancel(ctx)
+		go func() {
+			done <- osrv.Run(octx)
+		}()
+	}
+
 	uiServer := ui.Server{
-		Token: token,
-		Restart: func() {
-			ocancel()
-			<-done
-			octx, ocancel = context.WithCancel(ctx)
-			go func() {
-				done <- osrv.Run(octx)
-			}()
-		},
+		Token:        token,
+		Restart:      restartServer,
 		Store:        st,
 		ToolRegistry: toolRegistry,
 		Dev:          devMode,
 		Logger:       slog.Default(),
 	}
 
+	// Set restart callback for native settings
+	SetRestartCallback(restartServer)
+
 	srv := &http.Server{
 		Handler: uiServer.Handler(),
 	}

app/cmd/app/app_darwin.m

@@ -1,5 +1,6 @@
 #import "app_darwin.h"
 #import "menu.h"
+#import "settings_darwin.h"
 #import "../../updater/updater_darwin.h"
 #import <AppKit/AppKit.h>
 #import <Cocoa/Cocoa.h>
@@ -252,7 +253,7 @@ bool firstTimeRun,startHidden; // Set in run before initialization
 }
 
 - (void)settingsUI {
-    [self uiRequest:@"/settings"];
+    openNativeSettings();
 }
 
 - (void)openUI {

app/cmd/app/settings_darwin.go

@@ -0,0 +1,438 @@
+//go:build darwin
+
+package main
+
+/*
+#cgo CFLAGS: -x objective-c
+#cgo LDFLAGS: -framework Cocoa
+
+#include <stdlib.h>
+#include "settings_darwin.h"
+*/
+import "C"
+
+import (
+	"context"
+	"crypto/ed25519"
+	"crypto/rand"
+	"encoding/json"
+	"encoding/pem"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+	"unsafe"
+
+	"golang.org/x/crypto/ssh"
+
+	appauth "github.com/ollama/ollama/app/auth"
+	"github.com/ollama/ollama/app/store"
+	"github.com/ollama/ollama/auth"
+	"github.com/ollama/ollama/envconfig"
+)
+
+// settingsStore is a reference to the app's store for settings
+var settingsStore *store.Store
+
+// SetSettingsStore sets the store reference for settings callbacks
+func SetSettingsStore(s *store.Store) {
+	settingsStore = s
+}
+
+//export getSettingsExpose
+func getSettingsExpose() C.bool {
+	if settingsStore == nil {
+		return C.bool(false)
+	}
+	settings, err := settingsStore.Settings()
+	if err != nil {
+		slog.Error("failed to get settings", "error", err)
+		return C.bool(false)
+	}
+	return C.bool(settings.Expose)
+}
+
+//export setSettingsExpose
+func setSettingsExpose(expose C.bool) {
+	if settingsStore == nil {
+		return
+	}
+	settings, err := settingsStore.Settings()
+	if err != nil {
+		slog.Error("failed to get settings", "error", err)
+		return
+	}
+	settings.Expose = bool(expose)
+	if err := settingsStore.SetSettings(settings); err != nil {
+		slog.Error("failed to save settings", "error", err)
+	}
+}
+
+//export getSettingsBrowser
+func getSettingsBrowser() C.bool {
+	if settingsStore == nil {
+		return C.bool(false)
+	}
+	settings, err := settingsStore.Settings()
+	if err != nil {
+		slog.Error("failed to get settings", "error", err)
+		return C.bool(false)
+	}
+	return C.bool(settings.Browser)
+}
+
+//export setSettingsBrowser
+func setSettingsBrowser(browser C.bool) {
+	if settingsStore == nil {
+		return
+	}
+	settings, err := settingsStore.Settings()
+	if err != nil {
+		slog.Error("failed to get settings", "error", err)
+		return
+	}
+	settings.Browser = bool(browser)
+	if err := settingsStore.SetSettings(settings); err != nil {
+		slog.Error("failed to save settings", "error", err)
+	}
+}
+
+//export getSettingsModels
+func getSettingsModels() *C.char {
+	if settingsStore == nil {
+		return C.CString(envconfig.Models())
+	}
+	settings, err := settingsStore.Settings()
+	if err != nil {
+		slog.Error("failed to get settings", "error", err)
+		return C.CString(envconfig.Models())
+	}
+	if settings.Models == "" {
+		return C.CString(envconfig.Models())
+	}
+	return C.CString(settings.Models)
+}
+
+//export setSettingsModels
+func setSettingsModels(path *C.char) {
+	if settingsStore == nil {
+		return
+	}
+	settings, err := settingsStore.Settings()
+	if err != nil {
+		slog.Error("failed to get settings", "error", err)
+		return
+	}
+	settings.Models = C.GoString(path)
+	if err := settingsStore.SetSettings(settings); err != nil {
+		slog.Error("failed to save settings", "error", err)
+	}
+}
+
+//export getSettingsContextLength
+func getSettingsContextLength() C.int {
+	if settingsStore == nil {
+		return C.int(4096)
+	}
+	settings, err := settingsStore.Settings()
+	if err != nil {
+		slog.Error("failed to get settings", "error", err)
+		return C.int(4096)
+	}
+	if settings.ContextLength <= 0 {
+		return C.int(4096)
+	}
+	return C.int(settings.ContextLength)
+}
+
+//export setSettingsContextLength
+func setSettingsContextLength(length C.int) {
+	if settingsStore == nil {
+		return
+	}
+	settings, err := settingsStore.Settings()
+	if err != nil {
+		slog.Error("failed to get settings", "error", err)
+		return
+	}
+	settings.ContextLength = int(length)
+	if err := settingsStore.SetSettings(settings); err != nil {
+		slog.Error("failed to save settings", "error", err)
+	}
+}
+
+// restartCallback is set by the app to restart the ollama server
+var restartCallback func()
+
+// SetRestartCallback sets the function to call when settings change requires a restart
+func SetRestartCallback(cb func()) {
+	restartCallback = cb
+}
+
+//export restartOllamaServer
+func restartOllamaServer() {
+	if restartCallback != nil {
+		slog.Info("restarting ollama server due to settings change")
+		go restartCallback()
+	}
+}
+
+// hasOllamaKey checks if the user has an Ollama key file
+func hasOllamaKey() bool {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return false
+	}
+	keyPath := filepath.Join(home, ".ollama", "id_ed25519")
+	_, err = os.Stat(keyPath)
+	return err == nil
+}
+
+// ensureKeypair generates a new keypair if one doesn't exist
+func ensureKeypair() error {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return err
+	}
+
+	privKeyPath := filepath.Join(home, ".ollama", "id_ed25519")
+
+	// Check if key already exists
+	if _, err := os.Stat(privKeyPath); err == nil {
+		return nil // Key exists
+	}
+
+	// Generate new keypair
+	slog.Info("generating new keypair for ollama account")
+
+	pubKey, privKey, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		return fmt.Errorf("failed to generate key: %w", err)
+	}
+
+	// Marshal private key
+	privKeyBytes, err := ssh.MarshalPrivateKey(privKey, "")
+	if err != nil {
+		return fmt.Errorf("failed to marshal private key: %w", err)
+	}
+
+	// Ensure directory exists
+	if err := os.MkdirAll(filepath.Dir(privKeyPath), 0o755); err != nil {
+		return fmt.Errorf("failed to create directory: %w", err)
+	}
+
+	// Write private key
+	if err := os.WriteFile(privKeyPath, pem.EncodeToMemory(privKeyBytes), 0o600); err != nil {
+		return fmt.Errorf("failed to write private key: %w", err)
+	}
+
+	// Write public key
+	sshPubKey, err := ssh.NewPublicKey(pubKey)
+	if err != nil {
+		return fmt.Errorf("failed to create ssh public key: %w", err)
+	}
+	pubKeyBytes := ssh.MarshalAuthorizedKey(sshPubKey)
+	pubKeyPath := filepath.Join(home, ".ollama", "id_ed25519.pub")
+	if err := os.WriteFile(pubKeyPath, pubKeyBytes, 0o644); err != nil {
+		return fmt.Errorf("failed to write public key: %w", err)
+	}
+
+	slog.Info("keypair generated successfully")
+	return nil
+}
+
+// userResponse matches the API response from ollama.com/api/me
+type userResponse struct {
+	Name      string `json:"name"`
+	Email     string `json:"email"`
+	Plan      string `json:"plan"`
+	AvatarURL string `json:"avatarurl"`
+}
+
+// fetchUserFromAPI fetches user data from ollama.com using signed request
+func fetchUserFromAPI() (*userResponse, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	timestamp := strconv.FormatInt(time.Now().Unix(), 10)
+	signString := fmt.Sprintf("POST,/api/me?ts=%s", timestamp)
+	signature, err := auth.Sign(ctx, []byte(signString))
+	if err != nil {
+		return nil, fmt.Errorf("failed to sign request: %w", err)
+	}
+
+	endpoint := fmt.Sprintf("https://ollama.com/api/me?ts=%s", timestamp)
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", signature))
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to call ollama.com: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("unexpected status: %d", resp.StatusCode)
+	}
+
+	var user userResponse
+	if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
+		return nil, fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	// Make avatar URL absolute
+	if user.AvatarURL != "" && !strings.HasPrefix(user.AvatarURL, "http") {
+		user.AvatarURL = "https://ollama.com/" + user.AvatarURL
+	}
+
+	// Cache the avatar URL
+	cachedAvatarURL = user.AvatarURL
+
+	// Cache the user data
+	if settingsStore != nil {
+		storeUser := store.User{
+			Name:  user.Name,
+			Email: user.Email,
+			Plan:  user.Plan,
+		}
+		if err := settingsStore.SetUser(storeUser); err != nil {
+			slog.Warn("failed to cache user", "error", err)
+		}
+	}
+
+	return &user, nil
+}
+
+//export getAccountName
+func getAccountName() *C.char {
+	// Only return cached data - never block on network
+	if settingsStore == nil {
+		return C.CString("")
+	}
+	user, err := settingsStore.User()
+	if err != nil || user == nil {
+		return C.CString("")
+	}
+	return C.CString(user.Name)
+}
+
+// cachedAvatarURL stores the avatar URL from the last API fetch
+var cachedAvatarURL string
+
+//export getAccountAvatarURL
+func getAccountAvatarURL() *C.char {
+	return C.CString(cachedAvatarURL)
+}
+
+//export getAccountEmail
+func getAccountEmail() *C.char {
+	if settingsStore != nil {
+		user, err := settingsStore.User()
+		if err == nil && user != nil {
+			return C.CString(user.Email)
+		}
+	}
+	return C.CString("")
+}
+
+//export getAccountPlan
+func getAccountPlan() *C.char {
+	if settingsStore != nil {
+		user, err := settingsStore.User()
+		if err == nil && user != nil {
+			return C.CString(user.Plan)
+		}
+	}
+	return C.CString("")
+}
+
+//export signOutAccount
+func signOutAccount() {
+	if settingsStore != nil {
+		if err := settingsStore.ClearUser(); err != nil {
+			slog.Error("failed to clear user", "error", err)
+		}
+	}
+
+	// Also remove the key file
+	home, err := os.UserHomeDir()
+	if err != nil {
+		slog.Error("failed to get home dir", "error", err)
+		return
+	}
+	keyPath := filepath.Join(home, ".ollama", "id_ed25519")
+	if err := os.Remove(keyPath); err != nil && !os.IsNotExist(err) {
+		slog.Error("failed to remove key file", "error", err)
+	}
+}
+
+//export openConnectUrl
+func openConnectUrl() {
+	// Ensure keypair exists (generate if needed)
+	if err := ensureKeypair(); err != nil {
+		slog.Error("failed to ensure keypair", "error", err)
+		// Fallback to basic connect page
+		cmd := exec.Command("open", "https://ollama.com/connect")
+		cmd.Start()
+		return
+	}
+
+	// Build connect URL with public key
+	connectURL, err := appauth.BuildConnectURL("https://ollama.com")
+	if err != nil {
+		slog.Error("failed to build connect URL", "error", err)
+		// Fallback to basic connect page
+		connectURL = "https://ollama.com/connect"
+	}
+
+	cmd := exec.Command("open", connectURL)
+	if err := cmd.Start(); err != nil {
+		slog.Error("failed to open connect URL", "error", err)
+	}
+}
+
+//export refreshAccountFromAPI
+func refreshAccountFromAPI() {
+	if !hasOllamaKey() {
+		return
+	}
+	_, err := fetchUserFromAPI()
+	if err != nil {
+		slog.Debug("failed to refresh account", "error", err)
+	}
+}
+
+//export prefetchAccountData
+func prefetchAccountData() {
+	// Run in background goroutine to not block app startup
+	go func() {
+		if !hasOllamaKey() {
+			return
+		}
+		_, err := fetchUserFromAPI()
+		if err != nil {
+			slog.Debug("failed to prefetch account data", "error", err)
+		} else {
+			slog.Debug("prefetched account data successfully")
+		}
+	}()
+}
+
+// OpenNativeSettings opens the native settings window
+func OpenNativeSettings() {
+	C.openNativeSettings()
+}
+
+// Ensure the CString is freed (caller must free)
+func freeCString(s *C.char) {
+	C.free(unsafe.Pointer(s))
+}

app/cmd/app/settings_darwin.h

@@ -0,0 +1,38 @@
+#import <Cocoa/Cocoa.h>
+
+@interface SettingsWindowController : NSWindowController <NSWindowDelegate>
+
+// General tab
+@property(nonatomic, strong) NSButton *exposeCheckbox;
+@property(nonatomic, strong) NSButton *browserCheckbox;
+@property(nonatomic, strong) NSSlider *contextLengthSlider;
+
+// Models tab
+@property(nonatomic, strong) NSPathControl *modelsPathControl;
+@property(nonatomic, strong) NSButton *modelsPathButton;
+
+// Account tab
+@property(nonatomic, strong) NSView *avatarView;
+@property(nonatomic, strong) NSTextField *avatarInitialLabel;
+@property(nonatomic, strong) NSImageView *avatarImageView;
+@property(nonatomic, strong) NSTextField *accountNameLabel;
+@property(nonatomic, strong) NSTextField *accountEmailLabel;
+@property(nonatomic, strong) NSButton *manageButton;
+@property(nonatomic, strong) NSButton *signOutButton;
+@property(nonatomic, strong) NSButton *signInButton;
+@property(nonatomic, strong) NSView *signedInContainer;
+@property(nonatomic, strong) NSView *signedOutContainer;
+
+// Plan section
+@property(nonatomic, strong) NSView *planContainer;
+@property(nonatomic, strong) NSTextField *planNameLabel;
+@property(nonatomic, strong) NSButton *upgradeButton;
+@property(nonatomic, strong) NSButton *viewUsageButton;
+
++ (instancetype)sharedController;
+- (void)showSettings;
+
+@end
+
+// Go callbacks for settings
+void openNativeSettings(void);

app/cmd/app/settings_windows.go

@@ -0,0 +1,16 @@
+//go:build windows
+
+package main
+
+import "github.com/ollama/ollama/app/store"
+
+// SetSettingsStore sets the store reference for settings callbacks (stub for Windows)
+func SetSettingsStore(s *store.Store) {
+	// TODO: Implement Windows native settings
+}
+
+// SetRestartCallback sets the function to call when settings change requires a restart (stub for Windows)
+func SetRestartCallback(cb func()) {
+	// TODO: Implement Windows native settings
+}
+

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

docs/README.md

@@ -14,7 +14,6 @@
 * [API Reference](https://docs.ollama.com/api)
 * [Modelfile Reference](https://docs.ollama.com/modelfile)
 * [OpenAI Compatibility](https://docs.ollama.com/api/openai-compatibility)
-* [Anthropic Compatibility](./api/anthropic-compatibility.mdx)
 
 ### Resources
 

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/anthropic-compatibility.mdx

@@ -1,406 +0,0 @@
----
-title: Anthropic compatibility
----
-
-Ollama provides compatibility with the [Anthropic Messages API](https://docs.anthropic.com/en/api/messages) to help connect existing applications to Ollama, including tools like Claude Code.
-
-## Recommended models
-
-For coding use cases, models like `glm-4.7:cloud`, `minimax-m2.1:cloud`, and `qwen3-coder` are recommended.
-
-Pull a model before use:
-```shell
-ollama pull qwen3-coder
-ollama pull glm-4.7:cloud
-```
-
-## Usage
-
-### Environment variables
-
-To use Ollama with tools that expect the Anthropic API (like Claude Code), set these environment variables:
-
-```shell
-export ANTHROPIC_BASE_URL=http://localhost:11434
-export ANTHROPIC_API_KEY=ollama  # required but ignored
-```
-
-### Simple `/v1/messages` example
-
-<CodeGroup dropdown>
-
-```python basic.py
-import anthropic
-
-client = anthropic.Anthropic(
-    base_url='http://localhost:11434',
-    api_key='ollama',  # required but ignored
-)
-
-message = client.messages.create(
-    model='qwen3-coder',
-    max_tokens=1024,
-    messages=[
-        {'role': 'user', 'content': 'Hello, how are you?'}
-    ]
-)
-print(message.content[0].text)
-```
-
-```javascript basic.js
-import Anthropic from "@anthropic-ai/sdk";
-
-const anthropic = new Anthropic({
-  baseURL: "http://localhost:11434",
-  apiKey: "ollama", // required but ignored
-});
-
-const message = await anthropic.messages.create({
-  model: "qwen3-coder",
-  max_tokens: 1024,
-  messages: [{ role: "user", content: "Hello, how are you?" }],
-});
-
-console.log(message.content[0].text);
-```
-
-```shell basic.sh
-curl -X POST http://localhost:11434/v1/messages \
--H "Content-Type: application/json" \
--H "x-api-key: ollama" \
--H "anthropic-version: 2023-06-01" \
--d '{
-  "model": "qwen3-coder",
-  "max_tokens": 1024,
-  "messages": [{ "role": "user", "content": "Hello, how are you?" }]
-}'
-```
-
-</CodeGroup>
-
-### Streaming example
-
-<CodeGroup dropdown>
-
-```python streaming.py
-import anthropic
-
-client = anthropic.Anthropic(
-    base_url='http://localhost:11434',
-    api_key='ollama',
-)
-
-with client.messages.stream(
-    model='qwen3-coder',
-    max_tokens=1024,
-    messages=[{'role': 'user', 'content': 'Count from 1 to 10'}]
-) as stream:
-    for text in stream.text_stream:
-        print(text, end='', flush=True)
-```
-
-```javascript streaming.js
-import Anthropic from "@anthropic-ai/sdk";
-
-const anthropic = new Anthropic({
-  baseURL: "http://localhost:11434",
-  apiKey: "ollama",
-});
-
-const stream = await anthropic.messages.stream({
-  model: "qwen3-coder",
-  max_tokens: 1024,
-  messages: [{ role: "user", content: "Count from 1 to 10" }],
-});
-
-for await (const event of stream) {
-  if (
-    event.type === "content_block_delta" &&
-    event.delta.type === "text_delta"
-  ) {
-    process.stdout.write(event.delta.text);
-  }
-}
-```
-
-```shell streaming.sh
-curl -X POST http://localhost:11434/v1/messages \
--H "Content-Type: application/json" \
--d '{
-  "model": "qwen3-coder",
-  "max_tokens": 1024,
-  "stream": true,
-  "messages": [{ "role": "user", "content": "Count from 1 to 10" }]
-}'
-```
-
-</CodeGroup>
-
-### Tool calling example
-
-<CodeGroup dropdown>
-
-```python tools.py
-import anthropic
-
-client = anthropic.Anthropic(
-    base_url='http://localhost:11434',
-    api_key='ollama',
-)
-
-message = client.messages.create(
-    model='qwen3-coder',
-    max_tokens=1024,
-    tools=[
-        {
-            'name': 'get_weather',
-            'description': 'Get the current weather in a location',
-            'input_schema': {
-                'type': 'object',
-                'properties': {
-                    'location': {
-                        'type': 'string',
-                        'description': 'The city and state, e.g. San Francisco, CA'
-                    }
-                },
-                'required': ['location']
-            }
-        }
-    ],
-    messages=[{'role': 'user', 'content': "What's the weather in San Francisco?"}]
-)
-
-for block in message.content:
-    if block.type == 'tool_use':
-        print(f'Tool: {block.name}')
-        print(f'Input: {block.input}')
-```
-
-```javascript tools.js
-import Anthropic from "@anthropic-ai/sdk";
-
-const anthropic = new Anthropic({
-  baseURL: "http://localhost:11434",
-  apiKey: "ollama",
-});
-
-const message = await anthropic.messages.create({
-  model: "qwen3-coder",
-  max_tokens: 1024,
-  tools: [
-    {
-      name: "get_weather",
-      description: "Get the current weather in a location",
-      input_schema: {
-        type: "object",
-        properties: {
-          location: {
-            type: "string",
-            description: "The city and state, e.g. San Francisco, CA",
-          },
-        },
-        required: ["location"],
-      },
-    },
-  ],
-  messages: [{ role: "user", content: "What's the weather in San Francisco?" }],
-});
-
-for (const block of message.content) {
-  if (block.type === "tool_use") {
-    console.log("Tool:", block.name);
-    console.log("Input:", block.input);
-  }
-}
-```
-
-```shell tools.sh
-curl -X POST http://localhost:11434/v1/messages \
--H "Content-Type: application/json" \
--d '{
-  "model": "qwen3-coder",
-  "max_tokens": 1024,
-  "tools": [
-    {
-      "name": "get_weather",
-      "description": "Get the current weather in a location",
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "location": {
-            "type": "string",
-            "description": "The city and state"
-          }
-        },
-        "required": ["location"]
-      }
-    }
-  ],
-  "messages": [{ "role": "user", "content": "What is the weather in San Francisco?" }]
-}'
-```
-
-</CodeGroup>
-
-## Using with Claude Code
-
-[Claude Code](https://code.claude.com/docs/en/overview) can be configured to use Ollama as its backend:
-
-```shell
-ANTHROPIC_BASE_URL=http://localhost:11434 ANTHROPIC_API_KEY=ollama claude --model qwen3-coder
-```
-
-Or set the environment variables in your shell profile:
-
-```shell
-export ANTHROPIC_BASE_URL=http://localhost:11434
-export ANTHROPIC_API_KEY=ollama
-```
-
-Then run Claude Code with any Ollama model:
-
-```shell
-# Local models
-claude --model qwen3-coder
-claude --model gpt-oss:20b
-
-# Cloud models
-claude --model glm-4.7:cloud
-claude --model minimax-m2.1:cloud
-```
-
-## Endpoints
-
-### `/v1/messages`
-
-#### Supported features
-
-- [x] Messages
-- [x] Streaming
-- [x] System prompts
-- [x] Multi-turn conversations
-- [x] Vision (images)
-- [x] Tools (function calling)
-- [x] Tool results
-- [x] Thinking/extended thinking
-
-#### Supported request fields
-
-- [x] `model`
-- [x] `max_tokens`
-- [x] `messages`
-  - [x] Text `content`
-  - [x] Image `content` (base64)
-  - [x] Array of content blocks
-  - [x] `tool_use` blocks
-  - [x] `tool_result` blocks
-  - [x] `thinking` blocks
-- [x] `system` (string or array)
-- [x] `stream`
-- [x] `temperature`
-- [x] `top_p`
-- [x] `top_k`
-- [x] `stop_sequences`
-- [x] `tools`
-- [x] `thinking`
-- [ ] `tool_choice`
-- [ ] `metadata`
-
-#### Supported response fields
-
-- [x] `id`
-- [x] `type`
-- [x] `role`
-- [x] `model`
-- [x] `content` (text, tool_use, thinking blocks)
-- [x] `stop_reason` (end_turn, max_tokens, tool_use)
-- [x] `usage` (input_tokens, output_tokens)
-
-#### Streaming events
-
-- [x] `message_start`
-- [x] `content_block_start`
-- [x] `content_block_delta` (text_delta, input_json_delta, thinking_delta)
-- [x] `content_block_stop`
-- [x] `message_delta`
-- [x] `message_stop`
-- [x] `ping`
-- [x] `error`
-
-## Models
-
-Ollama supports both local and cloud models.
-
-### Local models
-
-Pull a local model before use:
-
-```shell
-ollama pull qwen3-coder
-```
-
-Recommended local models:
-- `qwen3-coder` - Excellent for coding tasks
-- `gpt-oss:20b` - Strong general-purpose model
-
-### Cloud models
-
-Cloud models are available immediately without pulling:
-
-- `glm-4.7:cloud` - High-performance cloud model
-- `minimax-m2.1:cloud` - Fast cloud model
-
-### Default model names
-
-For tooling that relies on default Anthropic model names such as `claude-3-5-sonnet`, use `ollama cp` to copy an existing model name:
-
-```shell
-ollama cp qwen3-coder claude-3-5-sonnet
-```
-
-Afterwards, this new model name can be specified in the `model` field:
-
-```shell
-curl http://localhost:11434/v1/messages \
-    -H "Content-Type: application/json" \
-    -d '{
-        "model": "claude-3-5-sonnet",
-        "max_tokens": 1024,
-        "messages": [
-            {
-                "role": "user",
-                "content": "Hello!"
-            }
-        ]
-    }'
-```
-
-## Differences from the Anthropic API
-
-### Behavior differences
-
-- API key is accepted but not validated
-- `anthropic-version` header is accepted but not used
-- Token counts are approximations based on the underlying model's tokenizer
-
-### Not supported
-
-The following Anthropic API features are not currently supported:
-
-| Feature | Description |
-|---------|-------------|
-| `/v1/messages/count_tokens` | Token counting endpoint |
-| `tool_choice` | Forcing specific tool use or disabling tools |
-| `metadata` | Request metadata (user_id) |
-| Prompt caching | `cache_control` blocks for caching prefixes |
-| Batches API | `/v1/messages/batches` for async batch processing |
-| Citations | `citations` content blocks |
-| PDF support | `document` content blocks with PDF files |
-| Server-sent errors | `error` events during streaming (errors return HTTP status) |
-
-### Partial support
-
-| Feature | Status |
-|---------|--------|
-| Image content | Base64 images supported; URL images not supported |
-| Extended thinking | Basic support; `budget_tokens` accepted but not enforced |

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/docs.json

@@ -32,9 +32,7 @@
     "codeblocks": "system"
   },
   "contextual": {
-    "options": [
-      "copy"
-    ]
+    "options": ["copy"]
   },
   "navbar": {
     "links": [
@@ -54,9 +52,7 @@
       "display": "simple"
     },
     "examples": {
-      "languages": [
-        "curl"
-      ]
+      "languages": ["curl"]
     }
   },
   "redirects": [
@@ -101,7 +97,6 @@
           {
             "group": "Integrations",
             "pages": [
-              "/integrations/claude-code",
               "/integrations/vscode",
               "/integrations/jetbrains",
               "/integrations/codex",
@@ -144,8 +139,7 @@
               "/api/streaming",
               "/api/usage",
               "/api/errors",
-              "/api/openai-compatibility",
-              "/api/anthropic-compatibility"
+              "/api/openai-compatibility"
             ]
           },
           {

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/integrations/claude-code.mdx

@@ -1,69 +0,0 @@
----
-title: Claude Code
----
-
-## Install
-
-Install [Claude Code](https://code.claude.com/docs/en/overview):
-
-<CodeGroup>
-
-```shell macOS / Linux
-curl -fsSL https://claude.ai/install.sh | bash
-```
-
-```powershell Windows
-irm https://claude.ai/install.ps1 | iex
-```
-
-</CodeGroup>
-
-## Usage with Ollama
-
-Claude Code connects to Ollama using the Anthropic-compatible API.
-
-1. Set the environment variables:
-
-```shell
-export ANTHROPIC_BASE_URL=http://localhost:11434
-export ANTHROPIC_API_KEY=ollama
-```
-
-2. Run Claude Code with an Ollama model:
-
-```shell
-claude --model qwen3-coder
-```
-
-Or run with environment variables inline:
-
-```shell
-ANTHROPIC_BASE_URL=http://localhost:11434 ANTHROPIC_API_KEY=ollama claude --model qwen3-coder
-```
-
-## Connecting to ollama.com
-
-1. Create an [API key](https://ollama.com/settings/keys) on ollama.com
-2. Set the environment variables:
-
-```shell
-export ANTHROPIC_BASE_URL=https://ollama.com
-export ANTHROPIC_API_KEY=<your-api-key>
-```
-
-3. Run Claude Code with a cloud model:
-
-```shell
-claude --model glm-4.7:cloud
-```
-
-## Recommended Models
-
-### Cloud models
-- `glm-4.7:cloud` - High-performance cloud model
-- `minimax-m2.1:cloud` - Fast cloud model
-- `qwen3-coder:480b` - Large coding model
-
-### Local models
-- `qwen3-coder` - Excellent for coding tasks
-- `gpt-oss:20b` - Strong general-purpose model

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
 

go.mod

@@ -28,7 +28,6 @@ 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
@@ -37,8 +36,6 @@ require (
 
 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 +45,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

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=

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

middleware/anthropic.go

@@ -1,149 +0,0 @@
-package middleware
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-
-	"github.com/ollama/ollama/anthropic"
-	"github.com/ollama/ollama/api"
-)
-
-// AnthropicWriter wraps the response writer to transform Ollama responses to Anthropic format
-type AnthropicWriter struct {
-	BaseWriter
-	stream    bool
-	id        string
-	model     string
-	converter *anthropic.StreamConverter
-}
-
-func (w *AnthropicWriter) writeError(data []byte) (int, error) {
-	var errData struct {
-		Error string `json:"error"`
-	}
-	if err := json.Unmarshal(data, &errData); err != nil {
-		return 0, err
-	}
-
-	w.ResponseWriter.Header().Set("Content-Type", "application/json")
-	err := json.NewEncoder(w.ResponseWriter).Encode(anthropic.NewError(w.ResponseWriter.Status(), errData.Error))
-	if err != nil {
-		return 0, err
-	}
-
-	return len(data), nil
-}
-
-func (w *AnthropicWriter) writeEvent(eventType string, data any) error {
-	d, err := json.Marshal(data)
-	if err != nil {
-		return err
-	}
-	_, err = w.ResponseWriter.Write([]byte(fmt.Sprintf("event: %s\ndata: %s\n\n", eventType, d)))
-	if err != nil {
-		return err
-	}
-	if f, ok := w.ResponseWriter.(http.Flusher); ok {
-		f.Flush()
-	}
-	return nil
-}
-
-func (w *AnthropicWriter) writeResponse(data []byte) (int, error) {
-	var chatResponse api.ChatResponse
-	err := json.Unmarshal(data, &chatResponse)
-	if err != nil {
-		return 0, err
-	}
-
-	if w.stream {
-		w.ResponseWriter.Header().Set("Content-Type", "text/event-stream")
-
-		events := w.converter.Process(chatResponse)
-		for _, event := range events {
-			if err := w.writeEvent(event.Event, event.Data); err != nil {
-				return 0, err
-			}
-		}
-		return len(data), nil
-	}
-
-	w.ResponseWriter.Header().Set("Content-Type", "application/json")
-	response := anthropic.ToMessagesResponse(w.id, chatResponse)
-	return len(data), json.NewEncoder(w.ResponseWriter).Encode(response)
-}
-
-func (w *AnthropicWriter) Write(data []byte) (int, error) {
-	code := w.ResponseWriter.Status()
-	if code != http.StatusOK {
-		return w.writeError(data)
-	}
-
-	return w.writeResponse(data)
-}
-
-// AnthropicMessagesMiddleware handles Anthropic Messages API requests
-func AnthropicMessagesMiddleware() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		var req anthropic.MessagesRequest
-		err := c.ShouldBindJSON(&req)
-		if err != nil {
-			c.AbortWithStatusJSON(http.StatusBadRequest, anthropic.NewError(http.StatusBadRequest, err.Error()))
-			return
-		}
-
-		if req.Model == "" {
-			c.AbortWithStatusJSON(http.StatusBadRequest, anthropic.NewError(http.StatusBadRequest, "model is required"))
-			return
-		}
-
-		if req.MaxTokens <= 0 {
-			c.AbortWithStatusJSON(http.StatusBadRequest, anthropic.NewError(http.StatusBadRequest, "max_tokens is required and must be positive"))
-			return
-		}
-
-		if len(req.Messages) == 0 {
-			c.AbortWithStatusJSON(http.StatusBadRequest, anthropic.NewError(http.StatusBadRequest, "messages is required"))
-			return
-		}
-
-		chatReq, err := anthropic.FromMessagesRequest(req)
-		if err != nil {
-			c.AbortWithStatusJSON(http.StatusBadRequest, anthropic.NewError(http.StatusBadRequest, err.Error()))
-			return
-		}
-
-		var b bytes.Buffer
-		if err := json.NewEncoder(&b).Encode(chatReq); err != nil {
-			c.AbortWithStatusJSON(http.StatusInternalServerError, anthropic.NewError(http.StatusInternalServerError, err.Error()))
-			return
-		}
-
-		c.Request.Body = io.NopCloser(&b)
-
-		messageID := anthropic.GenerateMessageID()
-
-		w := &AnthropicWriter{
-			BaseWriter: BaseWriter{ResponseWriter: c.Writer},
-			stream:     req.Stream,
-			id:         messageID,
-			model:      req.Model,
-			converter:  anthropic.NewStreamConverter(messageID, req.Model),
-		}
-
-		if req.Stream {
-			c.Writer.Header().Set("Content-Type", "text/event-stream")
-			c.Writer.Header().Set("Cache-Control", "no-cache")
-			c.Writer.Header().Set("Connection", "keep-alive")
-		}
-
-		c.Writer = w
-
-		c.Next()
-	}
-}

middleware/anthropic_test.go

@@ -1,584 +0,0 @@
-package middleware
-
-import (
-	"bytes"
-	"encoding/json"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/gin-gonic/gin"
-	"github.com/google/go-cmp/cmp"
-	"github.com/google/go-cmp/cmp/cmpopts"
-
-	"github.com/ollama/ollama/anthropic"
-	"github.com/ollama/ollama/api"
-)
-
-func captureAnthropicRequest(capturedRequest any) gin.HandlerFunc {
-	return func(c *gin.Context) {
-		bodyBytes, _ := io.ReadAll(c.Request.Body)
-		c.Request.Body = io.NopCloser(bytes.NewReader(bodyBytes))
-		_ = json.Unmarshal(bodyBytes, capturedRequest)
-		c.Next()
-	}
-}
-
-// testProps creates ToolPropertiesMap from a map (convenience function for tests)
-func testProps(m map[string]api.ToolProperty) *api.ToolPropertiesMap {
-	props := api.NewToolPropertiesMap()
-	for k, v := range m {
-		props.Set(k, v)
-	}
-	return props
-}
-
-func TestAnthropicMessagesMiddleware(t *testing.T) {
-	type testCase struct {
-		name string
-		body string
-		req  api.ChatRequest
-		err  anthropic.ErrorResponse
-	}
-
-	var capturedRequest *api.ChatRequest
-	stream := true
-
-	testCases := []testCase{
-		{
-			name: "basic message",
-			body: `{
-				"model": "test-model",
-				"max_tokens": 1024,
-				"messages": [
-					{"role": "user", "content": "Hello"}
-				]
-			}`,
-			req: api.ChatRequest{
-				Model: "test-model",
-				Messages: []api.Message{
-					{Role: "user", Content: "Hello"},
-				},
-				Options: map[string]any{"num_predict": 1024},
-				Stream:  &False,
-			},
-		},
-		{
-			name: "with system prompt",
-			body: `{
-				"model": "test-model",
-				"max_tokens": 1024,
-				"system": "You are helpful.",
-				"messages": [
-					{"role": "user", "content": "Hello"}
-				]
-			}`,
-			req: api.ChatRequest{
-				Model: "test-model",
-				Messages: []api.Message{
-					{Role: "system", Content: "You are helpful."},
-					{Role: "user", Content: "Hello"},
-				},
-				Options: map[string]any{"num_predict": 1024},
-				Stream:  &False,
-			},
-		},
-		{
-			name: "with options",
-			body: `{
-				"model": "test-model",
-				"max_tokens": 2048,
-				"temperature": 0.7,
-				"top_p": 0.9,
-				"top_k": 40,
-				"stop_sequences": ["\n", "END"],
-				"messages": [
-					{"role": "user", "content": "Hello"}
-				]
-			}`,
-			req: api.ChatRequest{
-				Model: "test-model",
-				Messages: []api.Message{
-					{Role: "user", Content: "Hello"},
-				},
-				Options: map[string]any{
-					"num_predict": 2048,
-					"temperature": 0.7,
-					"top_p":       0.9,
-					"top_k":       40,
-					"stop":        []string{"\n", "END"},
-				},
-				Stream: &False,
-			},
-		},
-		{
-			name: "streaming",
-			body: `{
-				"model": "test-model",
-				"max_tokens": 1024,
-				"stream": true,
-				"messages": [
-					{"role": "user", "content": "Hello"}
-				]
-			}`,
-			req: api.ChatRequest{
-				Model: "test-model",
-				Messages: []api.Message{
-					{Role: "user", Content: "Hello"},
-				},
-				Options: map[string]any{"num_predict": 1024},
-				Stream:  &stream,
-			},
-		},
-		{
-			name: "with tools",
-			body: `{
-				"model": "test-model",
-				"max_tokens": 1024,
-				"messages": [
-					{"role": "user", "content": "What's the weather?"}
-				],
-				"tools": [{
-					"name": "get_weather",
-					"description": "Get current weather",
-					"input_schema": {
-						"type": "object",
-						"properties": {
-							"location": {"type": "string"}
-						},
-						"required": ["location"]
-					}
-				}]
-			}`,
-			req: api.ChatRequest{
-				Model: "test-model",
-				Messages: []api.Message{
-					{Role: "user", Content: "What's the weather?"},
-				},
-				Tools: []api.Tool{
-					{
-						Type: "function",
-						Function: api.ToolFunction{
-							Name:        "get_weather",
-							Description: "Get current weather",
-							Parameters: api.ToolFunctionParameters{
-								Type:     "object",
-								Required: []string{"location"},
-								Properties: testProps(map[string]api.ToolProperty{
-									"location": {Type: api.PropertyType{"string"}},
-								}),
-							},
-						},
-					},
-				},
-				Options: map[string]any{"num_predict": 1024},
-				Stream:  &False,
-			},
-		},
-		{
-			name: "with tool result",
-			body: `{
-				"model": "test-model",
-				"max_tokens": 1024,
-				"messages": [
-					{"role": "user", "content": "What's the weather?"},
-					{"role": "assistant", "content": [
-						{"type": "tool_use", "id": "call_123", "name": "get_weather", "input": {"location": "Paris"}}
-					]},
-					{"role": "user", "content": [
-						{"type": "tool_result", "tool_use_id": "call_123", "content": "Sunny, 22°C"}
-					]}
-				]
-			}`,
-			req: api.ChatRequest{
-				Model: "test-model",
-				Messages: []api.Message{
-					{Role: "user", Content: "What's the weather?"},
-					{
-						Role: "assistant",
-						ToolCalls: []api.ToolCall{
-							{
-								ID: "call_123",
-								Function: api.ToolCallFunction{
-									Name:      "get_weather",
-									Arguments: testArgs(map[string]any{"location": "Paris"}),
-								},
-							},
-						},
-					},
-					{Role: "tool", Content: "Sunny, 22°C", ToolCallID: "call_123"},
-				},
-				Options: map[string]any{"num_predict": 1024},
-				Stream:  &False,
-			},
-		},
-		{
-			name: "with thinking enabled",
-			body: `{
-				"model": "test-model",
-				"max_tokens": 1024,
-				"thinking": {"type": "enabled", "budget_tokens": 1000},
-				"messages": [
-					{"role": "user", "content": "Hello"}
-				]
-			}`,
-			req: api.ChatRequest{
-				Model: "test-model",
-				Messages: []api.Message{
-					{Role: "user", Content: "Hello"},
-				},
-				Options: map[string]any{"num_predict": 1024},
-				Stream:  &False,
-				Think:   &api.ThinkValue{Value: true},
-			},
-		},
-		{
-			name: "missing model error",
-			body: `{
-				"max_tokens": 1024,
-				"messages": [
-					{"role": "user", "content": "Hello"}
-				]
-			}`,
-			err: anthropic.ErrorResponse{
-				Type: "error",
-				Error: anthropic.Error{
-					Type:    "invalid_request_error",
-					Message: "model is required",
-				},
-			},
-		},
-		{
-			name: "missing max_tokens error",
-			body: `{
-				"model": "test-model",
-				"messages": [
-					{"role": "user", "content": "Hello"}
-				]
-			}`,
-			err: anthropic.ErrorResponse{
-				Type: "error",
-				Error: anthropic.Error{
-					Type:    "invalid_request_error",
-					Message: "max_tokens is required and must be positive",
-				},
-			},
-		},
-		{
-			name: "missing messages error",
-			body: `{
-				"model": "test-model",
-				"max_tokens": 1024
-			}`,
-			err: anthropic.ErrorResponse{
-				Type: "error",
-				Error: anthropic.Error{
-					Type:    "invalid_request_error",
-					Message: "messages is required",
-				},
-			},
-		},
-		{
-			name: "tool_use missing id error",
-			body: `{
-				"model": "test-model",
-				"max_tokens": 1024,
-				"messages": [
-					{"role": "assistant", "content": [
-						{"type": "tool_use", "name": "test"}
-					]}
-				]
-			}`,
-			err: anthropic.ErrorResponse{
-				Type: "error",
-				Error: anthropic.Error{
-					Type:    "invalid_request_error",
-					Message: "tool_use block missing required 'id' field",
-				},
-			},
-		},
-	}
-
-	endpoint := func(c *gin.Context) {
-		c.Status(http.StatusOK)
-	}
-
-	gin.SetMode(gin.TestMode)
-	router := gin.New()
-	router.Use(AnthropicMessagesMiddleware(), captureAnthropicRequest(&capturedRequest))
-	router.Handle(http.MethodPost, "/v1/messages", endpoint)
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			req, _ := http.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader(tc.body))
-			req.Header.Set("Content-Type", "application/json")
-
-			defer func() { capturedRequest = nil }()
-
-			resp := httptest.NewRecorder()
-			router.ServeHTTP(resp, req)
-
-			if tc.err.Type != "" {
-				// Expect error
-				if resp.Code == http.StatusOK {
-					t.Fatalf("expected error response, got 200 OK")
-				}
-				var errResp anthropic.ErrorResponse
-				if err := json.Unmarshal(resp.Body.Bytes(), &errResp); err != nil {
-					t.Fatalf("failed to unmarshal error: %v", err)
-				}
-				if errResp.Type != tc.err.Type {
-					t.Errorf("expected error type %q, got %q", tc.err.Type, errResp.Type)
-				}
-				if errResp.Error.Type != tc.err.Error.Type {
-					t.Errorf("expected error.type %q, got %q", tc.err.Error.Type, errResp.Error.Type)
-				}
-				if errResp.Error.Message != tc.err.Error.Message {
-					t.Errorf("expected error.message %q, got %q", tc.err.Error.Message, errResp.Error.Message)
-				}
-				return
-			}
-
-			if resp.Code != http.StatusOK {
-				t.Fatalf("unexpected status code: %d, body: %s", resp.Code, resp.Body.String())
-			}
-
-			if capturedRequest == nil {
-				t.Fatal("request was not captured")
-			}
-
-			// Compare relevant fields
-			if capturedRequest.Model != tc.req.Model {
-				t.Errorf("model mismatch: got %q, want %q", capturedRequest.Model, tc.req.Model)
-			}
-
-			if diff := cmp.Diff(tc.req.Messages, capturedRequest.Messages,
-				cmpopts.IgnoreUnexported(api.ToolCallFunctionArguments{}, api.ToolPropertiesMap{})); diff != "" {
-				t.Errorf("messages mismatch (-want +got):\n%s", diff)
-			}
-
-			if tc.req.Stream != nil && capturedRequest.Stream != nil {
-				if *tc.req.Stream != *capturedRequest.Stream {
-					t.Errorf("stream mismatch: got %v, want %v", *capturedRequest.Stream, *tc.req.Stream)
-				}
-			}
-
-			if tc.req.Think != nil {
-				if capturedRequest.Think == nil {
-					t.Error("expected Think to be set")
-				} else if capturedRequest.Think.Value != tc.req.Think.Value {
-					t.Errorf("Think mismatch: got %v, want %v", capturedRequest.Think.Value, tc.req.Think.Value)
-				}
-			}
-		})
-	}
-}
-
-func TestAnthropicMessagesMiddleware_Headers(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	t.Run("streaming sets correct headers", func(t *testing.T) {
-		router := gin.New()
-		router.Use(AnthropicMessagesMiddleware())
-		router.POST("/v1/messages", func(c *gin.Context) {
-			// Check headers were set
-			if c.Writer.Header().Get("Content-Type") != "text/event-stream" {
-				t.Errorf("expected Content-Type text/event-stream, got %q", c.Writer.Header().Get("Content-Type"))
-			}
-			if c.Writer.Header().Get("Cache-Control") != "no-cache" {
-				t.Errorf("expected Cache-Control no-cache, got %q", c.Writer.Header().Get("Cache-Control"))
-			}
-			c.Status(http.StatusOK)
-		})
-
-		body := `{"model": "test", "max_tokens": 100, "stream": true, "messages": [{"role": "user", "content": "Hi"}]}`
-		req, _ := http.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader(body))
-		req.Header.Set("Content-Type", "application/json")
-
-		resp := httptest.NewRecorder()
-		router.ServeHTTP(resp, req)
-	})
-}
-
-func TestAnthropicMessagesMiddleware_InvalidJSON(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-	router := gin.New()
-	router.Use(AnthropicMessagesMiddleware())
-	router.POST("/v1/messages", func(c *gin.Context) {
-		c.Status(http.StatusOK)
-	})
-
-	req, _ := http.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader(`{invalid json`))
-	req.Header.Set("Content-Type", "application/json")
-
-	resp := httptest.NewRecorder()
-	router.ServeHTTP(resp, req)
-
-	if resp.Code != http.StatusBadRequest {
-		t.Errorf("expected status 400, got %d", resp.Code)
-	}
-
-	var errResp anthropic.ErrorResponse
-	if err := json.Unmarshal(resp.Body.Bytes(), &errResp); err != nil {
-		t.Fatalf("failed to unmarshal error: %v", err)
-	}
-
-	if errResp.Type != "error" {
-		t.Errorf("expected type 'error', got %q", errResp.Type)
-	}
-	if errResp.Error.Type != "invalid_request_error" {
-		t.Errorf("expected error type 'invalid_request_error', got %q", errResp.Error.Type)
-	}
-}
-
-func TestAnthropicWriter_NonStreaming(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	router := gin.New()
-	router.Use(AnthropicMessagesMiddleware())
-	router.POST("/v1/messages", func(c *gin.Context) {
-		// Simulate Ollama response
-		resp := api.ChatResponse{
-			Model: "test-model",
-			Message: api.Message{
-				Role:    "assistant",
-				Content: "Hello there!",
-			},
-			Done:       true,
-			DoneReason: "stop",
-			Metrics: api.Metrics{
-				PromptEvalCount: 10,
-				EvalCount:       5,
-			},
-		}
-		data, _ := json.Marshal(resp)
-		c.Writer.WriteHeader(http.StatusOK)
-		_, _ = c.Writer.Write(data)
-	})
-
-	body := `{"model": "test-model", "max_tokens": 100, "messages": [{"role": "user", "content": "Hi"}]}`
-	req, _ := http.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader(body))
-	req.Header.Set("Content-Type", "application/json")
-
-	resp := httptest.NewRecorder()
-	router.ServeHTTP(resp, req)
-
-	if resp.Code != http.StatusOK {
-		t.Fatalf("expected status 200, got %d", resp.Code)
-	}
-
-	var result anthropic.MessagesResponse
-	if err := json.Unmarshal(resp.Body.Bytes(), &result); err != nil {
-		t.Fatalf("failed to unmarshal response: %v", err)
-	}
-
-	if result.Type != "message" {
-		t.Errorf("expected type 'message', got %q", result.Type)
-	}
-	if result.Role != "assistant" {
-		t.Errorf("expected role 'assistant', got %q", result.Role)
-	}
-	if len(result.Content) != 1 {
-		t.Fatalf("expected 1 content block, got %d", len(result.Content))
-	}
-	if result.Content[0].Text == nil || *result.Content[0].Text != "Hello there!" {
-		t.Errorf("expected text 'Hello there!', got %v", result.Content[0].Text)
-	}
-	if result.StopReason != "end_turn" {
-		t.Errorf("expected stop_reason 'end_turn', got %q", result.StopReason)
-	}
-	if result.Usage.InputTokens != 10 {
-		t.Errorf("expected input_tokens 10, got %d", result.Usage.InputTokens)
-	}
-	if result.Usage.OutputTokens != 5 {
-		t.Errorf("expected output_tokens 5, got %d", result.Usage.OutputTokens)
-	}
-}
-
-// TestAnthropicWriter_ErrorFromRoutes tests error handling when routes.go sends
-// gin.H{"error": "message"} without a StatusCode field (which is the common case)
-func TestAnthropicWriter_ErrorFromRoutes(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-
-	tests := []struct {
-		name          string
-		statusCode    int
-		errorPayload  any
-		wantErrorType string
-		wantMessage   string
-	}{
-		// routes.go sends errors without StatusCode in JSON, so we must use HTTP status
-		{
-			name:          "404 with gin.H error (model not found)",
-			statusCode:    http.StatusNotFound,
-			errorPayload:  gin.H{"error": "model 'nonexistent' not found"},
-			wantErrorType: "not_found_error",
-			wantMessage:   "model 'nonexistent' not found",
-		},
-		{
-			name:          "400 with gin.H error (bad request)",
-			statusCode:    http.StatusBadRequest,
-			errorPayload:  gin.H{"error": "model is required"},
-			wantErrorType: "invalid_request_error",
-			wantMessage:   "model is required",
-		},
-		{
-			name:          "500 with gin.H error (internal error)",
-			statusCode:    http.StatusInternalServerError,
-			errorPayload:  gin.H{"error": "something went wrong"},
-			wantErrorType: "api_error",
-			wantMessage:   "something went wrong",
-		},
-		{
-			name:       "404 with api.StatusError",
-			statusCode: http.StatusNotFound,
-			errorPayload: api.StatusError{
-				StatusCode:   http.StatusNotFound,
-				ErrorMessage: "model not found via StatusError",
-			},
-			wantErrorType: "not_found_error",
-			wantMessage:   "model not found via StatusError",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			router := gin.New()
-			router.Use(AnthropicMessagesMiddleware())
-			router.POST("/v1/messages", func(c *gin.Context) {
-				// Simulate what routes.go does - set status and write error JSON
-				data, _ := json.Marshal(tt.errorPayload)
-				c.Writer.WriteHeader(tt.statusCode)
-				_, _ = c.Writer.Write(data)
-			})
-
-			body := `{"model": "test-model", "max_tokens": 100, "messages": [{"role": "user", "content": "Hi"}]}`
-			req, _ := http.NewRequest(http.MethodPost, "/v1/messages", strings.NewReader(body))
-			req.Header.Set("Content-Type", "application/json")
-
-			resp := httptest.NewRecorder()
-			router.ServeHTTP(resp, req)
-
-			if resp.Code != tt.statusCode {
-				t.Errorf("expected status %d, got %d", tt.statusCode, resp.Code)
-			}
-
-			var errResp anthropic.ErrorResponse
-			if err := json.Unmarshal(resp.Body.Bytes(), &errResp); err != nil {
-				t.Fatalf("failed to unmarshal error response: %v\nbody: %s", err, resp.Body.String())
-			}
-
-			if errResp.Type != "error" {
-				t.Errorf("expected type 'error', got %q", errResp.Type)
-			}
-			if errResp.Error.Type != tt.wantErrorType {
-				t.Errorf("expected error type %q, got %q", tt.wantErrorType, errResp.Error.Type)
-			}
-			if errResp.Error.Message != tt.wantMessage {
-				t.Errorf("expected message %q, got %q", tt.wantMessage, errResp.Error.Message)
-			}
-		})
-	}
-}

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/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

@@ -166,7 +166,7 @@ func (p *FunctionGemmaParser) parseToolCall(content string) (api.ToolCall, error
 
 // parseArguments parses the key:value,key:value format
 func (p *FunctionGemmaParser) parseArguments(argsStr string) api.ToolCallFunctionArguments {
-	args := api.NewToolCallFunctionArguments()
+	args := make(api.ToolCallFunctionArguments)
 	if argsStr == "" {
 		return args
 	}
@@ -185,7 +185,7 @@ func (p *FunctionGemmaParser) parseArguments(argsStr string) api.ToolCallFunctio
 		value := part[colonIdx+1:]
 
 		// Parse the value
-		args.Set(key, p.parseValue(value))
+		args[key] = p.parseValue(value)
 	}
 
 	return args

model/parsers/functiongemma_test.go

@@ -3,7 +3,6 @@ package parsers
 import (
 	"testing"
 
-	"github.com/google/go-cmp/cmp"
 	"github.com/ollama/ollama/api"
 	"github.com/stretchr/testify/assert"
 )
@@ -37,9 +36,9 @@ func TestFunctionGemmaParser(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"}},
-							}),
+							},
 						},
 					},
 				},
@@ -48,7 +47,7 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "Paris"}),
+						Arguments: api.ToolCallFunctionArguments{"city": "Paris"},
 					},
 				},
 			},
@@ -67,7 +66,7 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "Paris"}),
+						Arguments: api.ToolCallFunctionArguments{"city": "Paris"},
 					},
 				},
 			},
@@ -85,7 +84,7 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "add",
-						Arguments: testArgs(map[string]any{"a": int64(1), "b": int64(2)}),
+						Arguments: api.ToolCallFunctionArguments{"a": int64(1), "b": int64(2)},
 					},
 				},
 			},
@@ -103,7 +102,7 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "set_flag",
-						Arguments: testArgs(map[string]any{"enabled": true, "verbose": false}),
+						Arguments: api.ToolCallFunctionArguments{"enabled": true, "verbose": false},
 					},
 				},
 			},
@@ -125,13 +124,13 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "Paris"}),
+						Arguments: api.ToolCallFunctionArguments{"city": "Paris"},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "London"}),
+						Arguments: api.ToolCallFunctionArguments{"city": "London"},
 					},
 				},
 			},
@@ -153,7 +152,7 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "process",
-						Arguments: testArgs(map[string]any{"items": []any{"a", "b", "c"}}),
+						Arguments: api.ToolCallFunctionArguments{"items": []any{"a", "b", "c"}},
 					},
 				},
 			},
@@ -174,9 +173,9 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "update",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"data": map[string]any{"name": "test", "value": int64(42)},
-						}),
+						},
 					},
 				},
 			},
@@ -199,7 +198,7 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_time",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 			},
@@ -225,7 +224,7 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "set_temp",
-						Arguments: testArgs(map[string]any{"value": 3.14}),
+						Arguments: api.ToolCallFunctionArguments{"value": 3.14},
 					},
 				},
 			},
@@ -243,7 +242,7 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "test",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 			},
@@ -262,7 +261,7 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "greet",
-						Arguments: testArgs(map[string]any{"name": "日本語"}),
+						Arguments: api.ToolCallFunctionArguments{"name": "日本語"},
 					},
 				},
 			},
@@ -282,11 +281,11 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "search",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"query":  "test",
 							"limit":  int64(10),
 							"offset": int64(0),
-						}),
+						},
 					},
 				},
 			},
@@ -309,14 +308,14 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name: "create",
-						Arguments: testArgs(map[string]any{
+						Arguments: api.ToolCallFunctionArguments{
 							"config": map[string]any{
 								"settings": map[string]any{
 									"enabled": true,
 									"name":    "test",
 								},
 							},
-						}),
+						},
 					},
 				},
 			},
@@ -346,13 +345,13 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: testArgs(map[string]any{"city": "Paris"}),
+						Arguments: api.ToolCallFunctionArguments{"city": "Paris"},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Name:      "get_time",
-						Arguments: testArgs(map[string]any{"timezone": "UTC"}),
+						Arguments: api.ToolCallFunctionArguments{"timezone": "UTC"},
 					},
 				},
 			},
@@ -373,13 +372,13 @@ func TestFunctionGemmaParser(t *testing.T) {
 				{
 					Function: api.ToolCallFunction{
 						Name:      "first",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 				{
 					Function: api.ToolCallFunction{
 						Name:      "second",
-						Arguments: api.NewToolCallFunctionArguments(),
+						Arguments: api.ToolCallFunctionArguments{},
 					},
 				},
 			},
@@ -412,9 +411,7 @@ func TestFunctionGemmaParser(t *testing.T) {
 			}
 
 			assert.Equal(t, tt.expectedText, allContent)
-			if diff := cmp.Diff(tt.expectedCalls, allCalls, argsComparer); diff != "" {
-				t.Errorf("calls mismatch (-want +got):\n%s", diff)
-			}
+			assert.Equal(t, tt.expectedCalls, allCalls)
 		})
 	}
 }

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/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

@@ -136,7 +136,7 @@ func (r *FunctionGemmaRenderer) renderToolDeclaration(tool api.Tool) string {
 		needsComma := false
 
 		// Only include properties:{} if there are actual properties
-		if fn.Parameters.Properties != nil && fn.Parameters.Properties.Len() > 0 {
+		if len(fn.Parameters.Properties) > 0 {
 			sb.WriteString("properties:{")
 			r.writeProperties(&sb, fn.Parameters.Properties)
 			sb.WriteString("}")
@@ -172,16 +172,16 @@ func (r *FunctionGemmaRenderer) renderToolDeclaration(tool api.Tool) string {
 	return sb.String()
 }
 
-func (r *FunctionGemmaRenderer) writeProperties(sb *strings.Builder, props *api.ToolPropertiesMap) {
-	keys := make([]string, 0, props.Len())
-	for k := range props.All() {
+func (r *FunctionGemmaRenderer) writeProperties(sb *strings.Builder, props map[string]api.ToolProperty) {
+	keys := make([]string, 0, len(props))
+	for k := range props {
 		keys = append(keys, k)
 	}
 	sort.Strings(keys)
 
 	first := true
 	for _, name := range keys {
-		prop, _ := props.Get(name)
+		prop := props[name]
 		if !first {
 			sb.WriteString(",")
 		}
@@ -203,15 +203,15 @@ 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 := make([]string, 0, len(tc.Function.Arguments))
+	for k := range tc.Function.Arguments {
 		keys = append(keys, k)
 	}
 	sort.Strings(keys)
 
 	first := true
 	for _, key := range keys {
-		value, _ := tc.Function.Arguments.Get(key)
+		value := tc.Function.Arguments[key]
 		if !first {
 			sb.WriteString(",")
 		}

model/renderers/functiongemma_test.go

@@ -51,9 +51,9 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Description: "Get weather",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
+							},
 						},
 					},
 				},
@@ -75,9 +75,9 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Description: "Get weather",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
+							},
 						},
 					},
 				},
@@ -107,9 +107,9 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Description: "Get weather",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
+							},
 						},
 					},
 				},
@@ -126,7 +126,7 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						{
 							Function: api.ToolCallFunction{
 								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"city": "Paris"}),
+								Arguments: api.ToolCallFunctionArguments{"city": "Paris"},
 							},
 						},
 					},
@@ -141,9 +141,9 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Description: "Get weather",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
+							},
 						},
 					},
 				},
@@ -161,7 +161,7 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						{
 							Function: api.ToolCallFunction{
 								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"city": "Paris"}),
+								Arguments: api.ToolCallFunctionArguments{"city": "Paris"},
 							},
 						},
 					},
@@ -176,9 +176,9 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Description: "Get weather",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
+							},
 						},
 					},
 				},
@@ -195,7 +195,7 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						{
 							Function: api.ToolCallFunction{
 								Name:      "add",
-								Arguments: testArgs(map[string]any{"a": float64(1), "b": float64(2)}),
+								Arguments: api.ToolCallFunctionArguments{"a": float64(1), "b": float64(2)},
 							},
 						},
 					},
@@ -210,10 +210,10 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Description: "Add numbers",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"a": {Type: api.PropertyType{"number"}},
 								"b": {Type: api.PropertyType{"number"}},
-							}),
+							},
 						},
 					},
 				},
@@ -239,10 +239,10 @@ func TestFunctionGemmaRenderer(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: "City Name"},
 								"country": {Type: api.PropertyType{"string"}, Description: "Country Name"},
-							}),
+							},
 						},
 					},
 				},
@@ -263,9 +263,9 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Description: "Get weather",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
+							},
 						},
 					},
 				},
@@ -276,9 +276,9 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Description: "Get current time",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"timezone": {Type: api.PropertyType{"string"}, Description: "Timezone"},
-							}),
+							},
 						},
 					},
 				},
@@ -296,13 +296,13 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						{
 							Function: api.ToolCallFunction{
 								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"city": "Paris"}),
+								Arguments: api.ToolCallFunctionArguments{"city": "Paris"},
 							},
 						},
 						{
 							Function: api.ToolCallFunction{
 								Name:      "get_time",
-								Arguments: testArgs(map[string]any{"timezone": "UTC"}),
+								Arguments: api.ToolCallFunctionArguments{"timezone": "UTC"},
 							},
 						},
 					},
@@ -318,9 +318,9 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Description: "Get weather",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
+							},
 						},
 					},
 				},
@@ -331,9 +331,9 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Description: "Get current time",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"timezone": {Type: api.PropertyType{"string"}, Description: "Timezone"},
-							}),
+							},
 						},
 					},
 				},
@@ -351,7 +351,7 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						{
 							Function: api.ToolCallFunction{
 								Name:      "get_weather",
-								Arguments: testArgs(map[string]any{"city": "Paris"}),
+								Arguments: api.ToolCallFunctionArguments{"city": "Paris"},
 							},
 						},
 					},
@@ -367,9 +367,9 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Description: "Get weather",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"city": {Type: api.PropertyType{"string"}, Description: "City"},
-							}),
+							},
 						},
 					},
 				},
@@ -391,7 +391,7 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Description: "",
 						Parameters: api.ToolFunctionParameters{
 							Type:       "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{}),
+							Properties: map[string]api.ToolProperty{},
 						},
 					},
 				},
@@ -430,7 +430,7 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						{
 							Function: api.ToolCallFunction{
 								Name:      "set_flag",
-								Arguments: testArgs(map[string]any{"enabled": true}),
+								Arguments: api.ToolCallFunctionArguments{"enabled": true},
 							},
 						},
 					},
@@ -445,9 +445,9 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Description: "Set a flag",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"enabled": {Type: api.PropertyType{"boolean"}, Description: "Flag value"},
-							}),
+							},
 						},
 					},
 				},
@@ -468,11 +468,11 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Parameters: api.ToolFunctionParameters{
 							Type:     "object",
 							Required: []string{"a", "b", "c"},
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: 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"},
-							}),
+							},
 						},
 					},
 				},
@@ -492,9 +492,9 @@ func TestFunctionGemmaRenderer(t *testing.T) {
 						Description: "Test",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsMap(map[string]api.ToolProperty{
+							Properties: map[string]api.ToolProperty{
 								"items": {Type: api.PropertyType{"array"}, Description: "List of items"},
-							}),
+							},
 						},
 					},
 				},

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: testArgs(map[string]any{
+								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: testPropsMap(map[string]api.ToolProperty{
+							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/testhelpers_test.go

@@ -1,36 +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
-}

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"},
 					},
 				},
 			},

server/routes.go

@@ -752,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))
@@ -793,12 +787,9 @@ func (s *Server) EmbedHandler(c *gin.Context) {
 	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
 	}
 
@@ -806,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) {
@@ -1544,9 +1535,6 @@ func (s *Server) GenerateRoutes(rc *ollama.Registry) (http.Handler, error) {
 	r.GET("/v1/models/:model", middleware.RetrieveMiddleware(), s.ShowHandler)
 	r.POST("/v1/responses", middleware.ResponsesMiddleware(), s.ChatHandler)
 
-	// Inference (Anthropic compatibility)
-	r.POST("/v1/messages", middleware.AnthropicMessagesMiddleware(), s.ChatHandler)
-
 	if rc != nil {
 		// wrap old with new
 		rs := &registry.Local{
@@ -2407,3 +2395,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)
 			}
 		})
 	}

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,118 +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)
-}
-
-// 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 map[string]api.ToolProperty `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 map[string]any
-}
-
-// 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: 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: 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) {

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