uip

api: expose usage data

api/client.go

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

api/types.go

@@ -19,12 +19,6 @@ import (
 	"github.com/ollama/ollama/types/model"
 )
 
-// SkillRef is an alias for model.SkillRef representing a skill reference.
-type SkillRef = model.SkillRef
-
-// MCPRef is an alias for model.MCPRef representing an MCP server reference.
-type MCPRef = model.MCPRef
-
 // StatusError is an error with an HTTP status code and message.
 type StatusError struct {
 	StatusCode   int
@@ -696,18 +690,6 @@ type CreateRequest struct {
 	// Requires is the minimum version of Ollama required by the model.
 	Requires string `json:"requires,omitempty"`
 
-	// Skills is a list of skill references for the agent (local paths or registry refs)
-	Skills []SkillRef `json:"skills,omitempty"`
-
-	// MCPs is a list of MCP server references for the agent
-	MCPs []MCPRef `json:"mcps,omitempty"`
-
-	// AgentType defines the type of agent (e.g., "conversational", "task-based")
-	AgentType string `json:"agent_type,omitempty"`
-
-	// Entrypoint specifies an external command to run instead of the built-in chat loop
-	Entrypoint string `json:"entrypoint,omitempty"`
-
 	// Info is a map of additional information for the model
 	Info map[string]any `json:"info,omitempty"`
 
@@ -759,10 +741,6 @@ type ShowResponse struct {
 	Capabilities  []model.Capability `json:"capabilities,omitempty"`
 	ModifiedAt    time.Time          `json:"modified_at,omitempty"`
 	Requires      string             `json:"requires,omitempty"`
-	Skills        []SkillRef         `json:"skills,omitempty"`
-	MCPs          []MCPRef           `json:"mcps,omitempty"`
-	AgentType     string             `json:"agent_type,omitempty"`
-	Entrypoint    string             `json:"entrypoint,omitempty"`
 }
 
 // CopyRequest is the request passed to [Client.Copy].
@@ -814,6 +792,33 @@ type ProcessResponse struct {
 	Models []ProcessModelResponse `json:"models"`
 }
 
+// UsageResponse is the response from [Client.Usage].
+type UsageResponse struct {
+	GPUs []GPUUsage `json:"gpus,omitempty"`
+}
+
+// GPUUsage contains GPU/device memory usage breakdown.
+type GPUUsage struct {
+	Name    string `json:"name"`    // Device name (e.g., "Apple M2 Max", "NVIDIA GeForce RTX 4090")
+	Backend string `json:"backend"` // CUDA, ROCm, Metal, etc.
+	Total   uint64 `json:"total"`
+	Free    uint64 `json:"free"`
+	Used    uint64 `json:"used"`  // Memory used by Ollama
+	Other   uint64 `json:"other"` // Memory used by other processes
+}
+
+// UsageStats contains usage statistics.
+type UsageStats struct {
+	Requests         int64            `json:"requests"`
+	TokensInput      int64            `json:"tokens_input"`
+	TokensOutput     int64            `json:"tokens_output"`
+	TotalTokens      int64            `json:"total_tokens"`
+	Models           map[string]int64 `json:"models,omitempty"`
+	Sources          map[string]int64 `json:"sources,omitempty"`
+	ToolCalls        int64            `json:"tool_calls,omitempty"`
+	StructuredOutput int64            `json:"structured_output,omitempty"`
+}
+
 // ListModelResponse is a single model description in [ListResponse].
 type ListModelResponse struct {
 	Name        string       `json:"name"`

cmd/agent_loop_test.go

@@ -1,402 +0,0 @@
-package cmd
-
-import (
-	"testing"
-
-	"github.com/google/go-cmp/cmp"
-	"github.com/ollama/ollama/api"
-)
-
-// TestToolMessage verifies that tool messages are constructed correctly
-// with ToolName and ToolCallID preserved from the tool call.
-func TestToolMessage(t *testing.T) {
-	tests := []struct {
-		name     string
-		call     api.ToolCall
-		content  string
-		expected api.Message
-	}{
-		{
-			name: "basic tool message with ID",
-			call: api.ToolCall{
-				ID: "call_abc123",
-				Function: api.ToolCallFunction{
-					Name: "get_weather",
-					Arguments: api.ToolCallFunctionArguments{
-						"location": "Paris",
-					},
-				},
-			},
-			content: "Sunny, 22°C",
-			expected: api.Message{
-				Role:       "tool",
-				Content:    "Sunny, 22°C",
-				ToolName:   "get_weather",
-				ToolCallID: "call_abc123",
-			},
-		},
-		{
-			name: "tool message without ID",
-			call: api.ToolCall{
-				Function: api.ToolCallFunction{
-					Name: "calculate",
-					Arguments: api.ToolCallFunctionArguments{
-						"expression": "2+2",
-					},
-				},
-			},
-			content: "4",
-			expected: api.Message{
-				Role:     "tool",
-				Content:  "4",
-				ToolName: "calculate",
-				// ToolCallID should be empty when call.ID is empty
-			},
-		},
-		{
-			name: "MCP tool message",
-			call: api.ToolCall{
-				ID: "call_mcp123",
-				Function: api.ToolCallFunction{
-					Name: "mcp_websearch_search",
-					Arguments: api.ToolCallFunctionArguments{
-						"query": "ollama agents",
-					},
-				},
-			},
-			content: "Found 10 results",
-			expected: api.Message{
-				Role:       "tool",
-				Content:    "Found 10 results",
-				ToolName:   "mcp_websearch_search",
-				ToolCallID: "call_mcp123",
-			},
-		},
-		{
-			name: "skill tool message",
-			call: api.ToolCall{
-				ID: "call_skill456",
-				Function: api.ToolCallFunction{
-					Name: "run_skill_script",
-					Arguments: api.ToolCallFunctionArguments{
-						"skill":   "calculator",
-						"command": "python scripts/calc.py 2+2",
-					},
-				},
-			},
-			content: "Result: 4",
-			expected: api.Message{
-				Role:       "tool",
-				Content:    "Result: 4",
-				ToolName:   "run_skill_script",
-				ToolCallID: "call_skill456",
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := toolMessage(tt.call, tt.content)
-			if diff := cmp.Diff(tt.expected, result); diff != "" {
-				t.Errorf("toolMessage() mismatch (-want +got):\n%s", diff)
-			}
-		})
-	}
-}
-
-// TestAssistantMessageWithThinking verifies that assistant messages
-// in the tool loop should include thinking content.
-func TestAssistantMessageConstruction(t *testing.T) {
-	tests := []struct {
-		name        string
-		content     string
-		thinking    string
-		toolCalls   []api.ToolCall
-		expectedMsg api.Message
-	}{
-		{
-			name:     "assistant with thinking and tool calls",
-			content:  "",
-			thinking: "I need to check the weather for Paris.",
-			toolCalls: []api.ToolCall{
-				{
-					ID: "call_1",
-					Function: api.ToolCallFunction{
-						Name:      "get_weather",
-						Arguments: api.ToolCallFunctionArguments{"city": "Paris"},
-					},
-				},
-			},
-			expectedMsg: api.Message{
-				Role:     "assistant",
-				Content:  "",
-				Thinking: "I need to check the weather for Paris.",
-				ToolCalls: []api.ToolCall{
-					{
-						ID: "call_1",
-						Function: api.ToolCallFunction{
-							Name:      "get_weather",
-							Arguments: api.ToolCallFunctionArguments{"city": "Paris"},
-						},
-					},
-				},
-			},
-		},
-		{
-			name:     "assistant with content, thinking, and tool calls",
-			content:  "Let me check that for you.",
-			thinking: "User wants weather info.",
-			toolCalls: []api.ToolCall{
-				{
-					ID: "call_2",
-					Function: api.ToolCallFunction{
-						Name:      "search",
-						Arguments: api.ToolCallFunctionArguments{"query": "weather"},
-					},
-				},
-			},
-			expectedMsg: api.Message{
-				Role:     "assistant",
-				Content:  "Let me check that for you.",
-				Thinking: "User wants weather info.",
-				ToolCalls: []api.ToolCall{
-					{
-						ID: "call_2",
-						Function: api.ToolCallFunction{
-							Name:      "search",
-							Arguments: api.ToolCallFunctionArguments{"query": "weather"},
-						},
-					},
-				},
-			},
-		},
-		{
-			name:     "assistant with multiple tool calls",
-			content:  "",
-			thinking: "I'll check both cities.",
-			toolCalls: []api.ToolCall{
-				{
-					ID: "call_a",
-					Function: api.ToolCallFunction{
-						Name:      "get_weather",
-						Arguments: api.ToolCallFunctionArguments{"city": "Paris"},
-					},
-				},
-				{
-					ID: "call_b",
-					Function: api.ToolCallFunction{
-						Name:      "get_weather",
-						Arguments: api.ToolCallFunctionArguments{"city": "London"},
-					},
-				},
-			},
-			expectedMsg: api.Message{
-				Role:     "assistant",
-				Content:  "",
-				Thinking: "I'll check both cities.",
-				ToolCalls: []api.ToolCall{
-					{
-						ID: "call_a",
-						Function: api.ToolCallFunction{
-							Name:      "get_weather",
-							Arguments: api.ToolCallFunctionArguments{"city": "Paris"},
-						},
-					},
-					{
-						ID: "call_b",
-						Function: api.ToolCallFunction{
-							Name:      "get_weather",
-							Arguments: api.ToolCallFunctionArguments{"city": "London"},
-						},
-					},
-				},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Simulate the assistant message construction as done in chat()
-			assistantMsg := api.Message{
-				Role:      "assistant",
-				Content:   tt.content,
-				Thinking:  tt.thinking,
-				ToolCalls: tt.toolCalls,
-			}
-
-			if diff := cmp.Diff(tt.expectedMsg, assistantMsg); diff != "" {
-				t.Errorf("assistant message mismatch (-want +got):\n%s", diff)
-			}
-		})
-	}
-}
-
-// TestMessageStitchingOrder verifies that messages in a tool loop
-// are stitched in the correct order:
-// 1. User message
-// 2. Assistant message with tool calls (and thinking)
-// 3. Tool result messages (one per tool call, in order)
-// 4. Next assistant response
-func TestMessageStitchingOrder(t *testing.T) {
-	// Simulate a complete tool loop conversation
-	messages := []api.Message{
-		// Initial user message
-		{Role: "user", Content: "What's the weather in Paris and London?"},
-		// Assistant's first response with tool calls
-		{
-			Role:     "assistant",
-			Content:  "",
-			Thinking: "I need to check the weather for both cities.",
-			ToolCalls: []api.ToolCall{
-				{ID: "call_1", Function: api.ToolCallFunction{Name: "get_weather", Arguments: api.ToolCallFunctionArguments{"city": "Paris"}}},
-				{ID: "call_2", Function: api.ToolCallFunction{Name: "get_weather", Arguments: api.ToolCallFunctionArguments{"city": "London"}}},
-			},
-		},
-		// Tool results (in order matching tool calls)
-		{Role: "tool", Content: "Sunny, 22°C", ToolName: "get_weather", ToolCallID: "call_1"},
-		{Role: "tool", Content: "Rainy, 15°C", ToolName: "get_weather", ToolCallID: "call_2"},
-		// Final assistant response
-		{Role: "assistant", Content: "Paris is sunny at 22°C, and London is rainy at 15°C.", Thinking: "Got the data, now summarizing."},
-	}
-
-	// Verify structure
-	expectedRoles := []string{"user", "assistant", "tool", "tool", "assistant"}
-	for i, msg := range messages {
-		if msg.Role != expectedRoles[i] {
-			t.Errorf("message %d: expected role %q, got %q", i, expectedRoles[i], msg.Role)
-		}
-	}
-
-	// Verify tool results match tool calls in order
-	assistantWithTools := messages[1]
-	toolResults := []api.Message{messages[2], messages[3]}
-
-	if len(toolResults) != len(assistantWithTools.ToolCalls) {
-		t.Errorf("expected %d tool results for %d tool calls", len(assistantWithTools.ToolCalls), len(toolResults))
-	}
-
-	for i, result := range toolResults {
-		expectedToolCallID := assistantWithTools.ToolCalls[i].ID
-		if result.ToolCallID != expectedToolCallID {
-			t.Errorf("tool result %d: expected ToolCallID %q, got %q", i, expectedToolCallID, result.ToolCallID)
-		}
-		expectedToolName := assistantWithTools.ToolCalls[i].Function.Name
-		if result.ToolName != expectedToolName {
-			t.Errorf("tool result %d: expected ToolName %q, got %q", i, expectedToolName, result.ToolName)
-		}
-	}
-
-	// Verify thinking is present in assistant messages
-	if messages[1].Thinking == "" {
-		t.Error("first assistant message should have thinking content")
-	}
-	if messages[4].Thinking == "" {
-		t.Error("final assistant message should have thinking content")
-	}
-}
-
-// TestMultiTurnToolLoop verifies message stitching across multiple
-// tool call iterations.
-func TestMultiTurnToolLoop(t *testing.T) {
-	messages := []api.Message{
-		{Role: "user", Content: "What's 2+2 and also what's the weather in Paris?"},
-		// First tool call: calculate
-		{
-			Role:     "assistant",
-			Thinking: "I'll start with the calculation.",
-			ToolCalls: []api.ToolCall{
-				{ID: "calc_1", Function: api.ToolCallFunction{Name: "calculate", Arguments: api.ToolCallFunctionArguments{"expr": "2+2"}}},
-			},
-		},
-		{Role: "tool", Content: "4", ToolName: "calculate", ToolCallID: "calc_1"},
-		// Second tool call: weather
-		{
-			Role:     "assistant",
-			Thinking: "Got the calculation. Now checking weather.",
-			ToolCalls: []api.ToolCall{
-				{ID: "weather_1", Function: api.ToolCallFunction{Name: "get_weather", Arguments: api.ToolCallFunctionArguments{"city": "Paris"}}},
-			},
-		},
-		{Role: "tool", Content: "Sunny, 20°C", ToolName: "get_weather", ToolCallID: "weather_1"},
-		// Final response
-		{Role: "assistant", Content: "2+2 equals 4, and Paris is sunny at 20°C."},
-	}
-
-	// Count message types
-	roleCounts := map[string]int{}
-	for _, msg := range messages {
-		roleCounts[msg.Role]++
-	}
-
-	if roleCounts["user"] != 1 {
-		t.Errorf("expected 1 user message, got %d", roleCounts["user"])
-	}
-	if roleCounts["assistant"] != 3 {
-		t.Errorf("expected 3 assistant messages, got %d", roleCounts["assistant"])
-	}
-	if roleCounts["tool"] != 2 {
-		t.Errorf("expected 2 tool messages, got %d", roleCounts["tool"])
-	}
-
-	// Verify each tool message follows an assistant with matching tool call
-	for i, msg := range messages {
-		if msg.Role == "tool" {
-			// Find preceding assistant message with tool calls
-			var precedingAssistant *api.Message
-			for j := i - 1; j >= 0; j-- {
-				if messages[j].Role == "assistant" && len(messages[j].ToolCalls) > 0 {
-					precedingAssistant = &messages[j]
-					break
-				}
-			}
-
-			if precedingAssistant == nil {
-				t.Errorf("tool message at index %d has no preceding assistant with tool calls", i)
-				continue
-			}
-
-			// Verify tool result matches one of the tool calls
-			found := false
-			for _, tc := range precedingAssistant.ToolCalls {
-				if tc.ID == msg.ToolCallID {
-					found = true
-					break
-				}
-			}
-			if !found {
-				t.Errorf("tool message at index %d has ToolCallID %q not found in preceding tool calls", i, msg.ToolCallID)
-			}
-		}
-	}
-}
-
-// TestSkillCatalogRunToolCallPreservesFields tests that skill catalog
-// returns tool messages with correct fields.
-func TestSkillCatalogToolMessageFields(t *testing.T) {
-	// Create a minimal test for toolMessage function
-	call := api.ToolCall{
-		ID: "test_id_123",
-		Function: api.ToolCallFunction{
-			Name: "run_skill_script",
-			Arguments: api.ToolCallFunctionArguments{
-				"skill":   "test-skill",
-				"command": "echo hello",
-			},
-		},
-	}
-
-	msg := toolMessage(call, "hello")
-
-	if msg.Role != "tool" {
-		t.Errorf("expected role 'tool', got %q", msg.Role)
-	}
-	if msg.Content != "hello" {
-		t.Errorf("expected content 'hello', got %q", msg.Content)
-	}
-	if msg.ToolName != "run_skill_script" {
-		t.Errorf("expected ToolName 'run_skill_script', got %q", msg.ToolName)
-	}
-	if msg.ToolCallID != "test_id_123" {
-		t.Errorf("expected ToolCallID 'test_id_123', got %q", msg.ToolCallID)
-	}
-}

cmd/cmd.go

@@ -15,7 +15,6 @@ import (
 	"net"
 	"net/http"
 	"os"
-	"os/exec"
 	"os/signal"
 	"path/filepath"
 	"runtime"
@@ -496,16 +495,6 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 
 	opts.ParentModel = info.Details.ParentModel
 
-	// Check if this is an agent
-	isAgent := info.AgentType != "" || len(info.Skills) > 0 || len(info.MCPs) > 0 || info.Entrypoint != ""
-	if isAgent {
-		opts.IsAgent = true
-		opts.AgentType = info.AgentType
-		opts.Skills = info.Skills
-		opts.MCPs = info.MCPs
-		opts.Entrypoint = info.Entrypoint
-	}
-
 	// Check if this is an embedding model
 	isEmbeddingModel := slices.Contains(info.Capabilities, model.CapabilityEmbedding)
 
@@ -531,10 +520,7 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 
 	// Check for experimental flag
 	isExperimental, _ := cmd.Flags().GetBool("experimental")
-	// If agent has entrypoint, run it instead of chat loop
-	if opts.Entrypoint != "" {
-		return runEntrypoint(cmd, opts)
-	}
+	yoloMode, _ := cmd.Flags().GetBool("yolo")
 
 	if interactive {
 		if err := loadOrUnloadModel(cmd, &opts); err != nil {
@@ -562,69 +548,16 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 			}
 		}
 
-		// Use experimental agent loop with
+		// Use experimental agent loop with tools
 		if isExperimental {
-			return xcmd.GenerateInteractive(cmd, opts.Model, opts.WordWrap, opts.Options, opts.Think, opts.HideThinking, opts.KeepAlive)
+			return xcmd.GenerateInteractive(cmd, opts.Model, opts.WordWrap, opts.Options, opts.Think, opts.HideThinking, opts.KeepAlive, yoloMode)
 		}
 
 		return generateInteractive(cmd, opts)
 	}
-
-	// For agents, use chat API even in non-interactive mode to support tools
-	if opts.IsAgent {
-		opts.Messages = append(opts.Messages, api.Message{Role: "user", Content: opts.Prompt})
-		_, err := chat(cmd, opts)
-		return err
-	}
-
 	return generate(cmd, opts)
 }
 
-// runEntrypoint executes the agent's entrypoint command instead of the built-in chat loop.
-func runEntrypoint(cmd *cobra.Command, opts runOptions) error {
-	entrypoint := opts.Entrypoint
-
-	// Check if entrypoint contains $PROMPT placeholder
-	hasPlaceholder := strings.Contains(entrypoint, "$PROMPT")
-
-	if hasPlaceholder && opts.Prompt != "" {
-		// Replace $PROMPT with the actual prompt
-		entrypoint = strings.ReplaceAll(entrypoint, "$PROMPT", opts.Prompt)
-	} else if hasPlaceholder {
-		// No prompt provided but placeholder exists - remove placeholder
-		entrypoint = strings.ReplaceAll(entrypoint, "$PROMPT", "")
-	}
-
-	// Parse entrypoint into command and args
-	parts := strings.Fields(entrypoint)
-	if len(parts) == 0 {
-		return fmt.Errorf("empty entrypoint")
-	}
-
-	command := parts[0]
-	args := parts[1:]
-
-	// If user provided a prompt and no placeholder was used, append it as argument
-	if opts.Prompt != "" && !hasPlaceholder {
-		args = append(args, opts.Prompt)
-	}
-
-	// Look up command in PATH
-	execPath, err := exec.LookPath(command)
-	if err != nil {
-		return fmt.Errorf("entrypoint command not found: %s", command)
-	}
-
-	// Create subprocess
-	proc := exec.Command(execPath, args...)
-	proc.Stdin = os.Stdin
-	proc.Stdout = os.Stdout
-	proc.Stderr = os.Stderr
-
-	// Run and wait
-	return proc.Run()
-}
-
 func SigninHandler(cmd *cobra.Command, args []string) error {
 	client, err := api.ClientFromEnvironment()
 	if err != nil {
@@ -984,96 +917,47 @@ func showInfo(resp *api.ShowResponse, verbose bool, w io.Writer) error {
 		fmt.Fprintln(w)
 	}
 
-	// Only show Model section if there's actual model info (not for entrypoint-only agents)
-	hasModelInfo := resp.RemoteHost != "" || resp.ModelInfo != nil || resp.Details.Family != "" || resp.Details.ParameterSize != "" || resp.Details.QuantizationLevel != ""
-	if hasModelInfo {
-		tableRender("Model", func() (rows [][]string) {
-			if resp.RemoteHost != "" {
-				rows = append(rows, []string{"", "Remote model", resp.RemoteModel})
-				rows = append(rows, []string{"", "Remote URL", resp.RemoteHost})
-			}
+	tableRender("Model", func() (rows [][]string) {
+		if resp.RemoteHost != "" {
+			rows = append(rows, []string{"", "Remote model", resp.RemoteModel})
+			rows = append(rows, []string{"", "Remote URL", resp.RemoteHost})
+		}
 
-			if resp.ModelInfo != nil {
-				arch := resp.ModelInfo["general.architecture"].(string)
-				rows = append(rows, []string{"", "architecture", arch})
+		if resp.ModelInfo != nil {
+			arch := resp.ModelInfo["general.architecture"].(string)
+			rows = append(rows, []string{"", "architecture", arch})
 
-				var paramStr string
-				if resp.Details.ParameterSize != "" {
-					paramStr = resp.Details.ParameterSize
-				} else if v, ok := resp.ModelInfo["general.parameter_count"]; ok {
-					if f, ok := v.(float64); ok {
-						paramStr = format.HumanNumber(uint64(f))
-					}
-				}
-				rows = append(rows, []string{"", "parameters", paramStr})
-
-				if v, ok := resp.ModelInfo[fmt.Sprintf("%s.context_length", arch)]; ok {
-					if f, ok := v.(float64); ok {
-						rows = append(rows, []string{"", "context length", strconv.FormatFloat(f, 'f', -1, 64)})
-					}
-				}
-
-				if v, ok := resp.ModelInfo[fmt.Sprintf("%s.embedding_length", arch)]; ok {
-					if f, ok := v.(float64); ok {
-						rows = append(rows, []string{"", "embedding length", strconv.FormatFloat(f, 'f', -1, 64)})
-					}
-				}
-			} else {
-				rows = append(rows, []string{"", "architecture", resp.Details.Family})
-				rows = append(rows, []string{"", "parameters", resp.Details.ParameterSize})
-			}
-			rows = append(rows, []string{"", "quantization", resp.Details.QuantizationLevel})
-			if resp.Requires != "" {
-				rows = append(rows, []string{"", "requires", resp.Requires})
-			}
-			return
-		})
-	}
-
-	// Display agent information if this is an agent
-	if resp.AgentType != "" || len(resp.Skills) > 0 || len(resp.MCPs) > 0 || resp.Entrypoint != "" {
-		tableRender("Agent", func() (rows [][]string) {
-			if resp.AgentType != "" {
-				rows = append(rows, []string{"", "type", resp.AgentType})
-			}
-			if resp.Entrypoint != "" {
-				rows = append(rows, []string{"", "entrypoint", resp.Entrypoint})
-			}
-			if len(resp.Skills) > 0 {
-				for i, skill := range resp.Skills {
-					label := "skill"
-					if i > 0 {
-						label = ""
-					}
-					// Show skill name or digest
-					skillDisplay := skill.Name
-					if skillDisplay == "" && skill.Digest != "" {
-						skillDisplay = skill.Digest[:12] + "..."
-					}
-					rows = append(rows, []string{"", label, skillDisplay})
+			var paramStr string
+			if resp.Details.ParameterSize != "" {
+				paramStr = resp.Details.ParameterSize
+			} else if v, ok := resp.ModelInfo["general.parameter_count"]; ok {
+				if f, ok := v.(float64); ok {
+					paramStr = format.HumanNumber(uint64(f))
 				}
 			}
-			if len(resp.MCPs) > 0 {
-				for i, mcp := range resp.MCPs {
-					label := "mcp"
-					if i > 0 {
-						label = ""
-					}
-					// Show MCP name and command
-					mcpDisplay := mcp.Name
-					if mcp.Command != "" {
-						cmdLine := mcp.Command
-						if len(mcp.Args) > 0 {
-							cmdLine += " " + strings.Join(mcp.Args, " ")
-						}
-						mcpDisplay += " (" + cmdLine + ")"
-					}
-					rows = append(rows, []string{"", label, mcpDisplay})
+			rows = append(rows, []string{"", "parameters", paramStr})
+
+			if v, ok := resp.ModelInfo[fmt.Sprintf("%s.context_length", arch)]; ok {
+				if f, ok := v.(float64); ok {
+					rows = append(rows, []string{"", "context length", strconv.FormatFloat(f, 'f', -1, 64)})
 				}
 			}
-			return
-		})
-	}
+
+			if v, ok := resp.ModelInfo[fmt.Sprintf("%s.embedding_length", arch)]; ok {
+				if f, ok := v.(float64); ok {
+					rows = append(rows, []string{"", "embedding length", strconv.FormatFloat(f, 'f', -1, 64)})
+				}
+			}
+		} else {
+			rows = append(rows, []string{"", "architecture", resp.Details.Family})
+			rows = append(rows, []string{"", "parameters", resp.Details.ParameterSize})
+		}
+		rows = append(rows, []string{"", "quantization", resp.Details.QuantizationLevel})
+		if resp.Requires != "" {
+			rows = append(rows, []string{"", "requires", resp.Requires})
+		}
+		return
+	})
 
 	if len(resp.Capabilities) > 0 {
 		tableRender("Capabilities", func() (rows [][]string) {
@@ -1315,11 +1199,6 @@ type runOptions struct {
 	Think        *api.ThinkValue
 	HideThinking bool
 	ShowConnect  bool
-	IsAgent      bool
-	AgentType    string
-	Skills       []api.SkillRef
-	MCPs         []api.MCPRef
-	Entrypoint   string
 }
 
 func (r runOptions) Copy() runOptions {
@@ -1349,12 +1228,6 @@ func (r runOptions) Copy() runOptions {
 		think = &cThink
 	}
 
-	var skills []api.SkillRef
-	if r.Skills != nil {
-		skills = make([]api.SkillRef, len(r.Skills))
-		copy(skills, r.Skills)
-	}
-
 	return runOptions{
 		Model:        r.Model,
 		ParentModel:  r.ParentModel,
@@ -1370,9 +1243,6 @@ func (r runOptions) Copy() runOptions {
 		Think:        think,
 		HideThinking: r.HideThinking,
 		ShowConnect:  r.ShowConnect,
-		IsAgent:      r.IsAgent,
-		AgentType:    r.AgentType,
-		Skills:       skills,
 	}
 }
 
@@ -1456,65 +1326,6 @@ func chat(cmd *cobra.Command, opts runOptions) (*api.Message, error) {
 		return nil, err
 	}
 
-	// Load skills for agents
-	var skillsCatalog *skillCatalog
-	if opts.IsAgent && len(opts.Skills) > 0 {
-		skillsCatalog, err = loadSkillsFromRefs(opts.Skills)
-		if err != nil {
-			return nil, fmt.Errorf("failed to load skills: %w", err)
-		}
-		if skillsCatalog != nil && len(skillsCatalog.Skills) > 0 {
-			var skillNames []string
-			for _, s := range skillsCatalog.Skills {
-				skillNames = append(skillNames, s.Name)
-			}
-			fmt.Fprintf(os.Stderr, "Loaded skills: %s\n", strings.Join(skillNames, ", "))
-		}
-	}
-
-	// Load MCP servers for agents (from opts and global config)
-	var mcpMgr *mcpManager
-	allMCPs := opts.MCPs
-
-	// Load global MCPs from ~/.ollama/mcp.json
-	if globalConfig, err := loadMCPConfig(); err == nil && len(globalConfig.MCPServers) > 0 {
-		for name, srv := range globalConfig.MCPServers {
-			// Skip disabled MCPs
-			if srv.Disabled {
-				continue
-			}
-			// Check if already in opts.MCPs (model takes precedence)
-			found := false
-			for _, m := range opts.MCPs {
-				if m.Name == name {
-					found = true
-					break
-				}
-			}
-			if !found {
-				allMCPs = append(allMCPs, api.MCPRef{
-					Name:    name,
-					Command: srv.Command,
-					Args:    srv.Args,
-					Env:     srv.Env,
-					Type:    srv.Type,
-				})
-			}
-		}
-	}
-
-	if len(allMCPs) > 0 {
-		mcpMgr = newMCPManager()
-		if err := mcpMgr.loadMCPsFromRefs(allMCPs); err != nil {
-			return nil, fmt.Errorf("failed to load MCP servers: %w", err)
-		}
-		if mcpMgr.ToolCount() > 0 {
-			fmt.Fprintf(os.Stderr, "Loaded MCP servers: %s (%d tools)\n",
-				strings.Join(mcpMgr.ServerNames(), ", "), mcpMgr.ToolCount())
-		}
-		defer mcpMgr.Shutdown()
-	}
-
 	p := progress.NewProgress(os.Stderr)
 	defer p.StopAndClear()
 
@@ -1538,7 +1349,6 @@ func chat(cmd *cobra.Command, opts runOptions) (*api.Message, error) {
 	var fullResponse strings.Builder
 	var thinkTagOpened bool = false
 	var thinkTagClosed bool = false
-	var pendingToolCalls []api.ToolCall
 
 	role := "assistant"
 
@@ -1579,13 +1389,7 @@ func chat(cmd *cobra.Command, opts runOptions) (*api.Message, error) {
 		if response.Message.ToolCalls != nil {
 			toolCalls := response.Message.ToolCalls
 			if len(toolCalls) > 0 {
-				if skillsCatalog != nil || mcpMgr != nil {
-					// Store tool calls for execution after response is complete
-					pendingToolCalls = append(pendingToolCalls, toolCalls...)
-				} else {
-					// No skills catalog or MCP, just display tool calls
-					fmt.Print(renderToolCalls(toolCalls, false))
-				}
+				fmt.Print(renderToolCalls(toolCalls, false))
 			}
 		}
 
@@ -1598,161 +1402,31 @@ func chat(cmd *cobra.Command, opts runOptions) (*api.Message, error) {
 		opts.Format = `"` + opts.Format + `"`
 	}
 
-	// Prepare messages with agent-specific system prompt
-	messages := opts.Messages
-	if skillsCatalog != nil {
-		// Add skills system prompt as the first system message
-		skillsPrompt := skillsCatalog.SystemPrompt()
-		if skillsPrompt != "" {
-			// Insert skills prompt at the beginning, or append to existing system message
-			if len(messages) > 0 && messages[0].Role == "system" {
-				// Append to existing system message
-				messages[0].Content = messages[0].Content + "\n\n" + skillsPrompt
-			} else {
-				// Insert new system message at the beginning
-				systemMsg := api.Message{Role: "system", Content: skillsPrompt}
-				messages = append([]api.Message{systemMsg}, messages...)
-			}
-		}
+	req := &api.ChatRequest{
+		Model:    opts.Model,
+		Messages: opts.Messages,
+		Format:   json.RawMessage(opts.Format),
+		Options:  opts.Options,
+		Think:    opts.Think,
 	}
 
-	// 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,
+	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
 		}
 
-		// Add tools for agents (combine skills and MCP tools)
-		var allTools api.Tools
-		if skillsCatalog != nil {
-			allTools = append(allTools, skillsCatalog.Tools()...)
+		// this error should ideally be wrapped properly by the client
+		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
 		}
-		if mcpMgr != nil {
-			allTools = append(allTools, mcpMgr.Tools()...)
-		}
-		if len(allTools) > 0 {
-			req.Tools = allTools
-		}
-
-		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
-			}
-
-			// this error should ideally be wrapped properly by the client
-			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 || (skillsCatalog == nil && mcpMgr == nil) {
-			break
-		}
-
-		// Execute tool calls and continue the conversation
-		fmt.Fprintf(os.Stderr, "\n")
-
-		// Add assistant's tool call message to history (include thinking for proper rendering)
-		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 {
-			// Show what's being executed
-			switch call.Function.Name {
-			case "run_skill_script":
-				skillVal, _ := call.Function.Arguments.Get("skill")
-				skill, _ := skillVal.(string)
-				commandVal, _ := call.Function.Arguments.Get("command")
-				command, _ := commandVal.(string)
-				fmt.Fprintf(os.Stderr, "Running script in %s: %s\n", skill, command)
-			case "read_skill_file":
-				skillVal, _ := call.Function.Arguments.Get("skill")
-				skill, _ := skillVal.(string)
-				pathVal, _ := call.Function.Arguments.Get("path")
-				path, _ := pathVal.(string)
-				fmt.Fprintf(os.Stderr, "Reading file from %s: %s\n", skill, path)
-			default:
-				fmt.Fprintf(os.Stderr, "Executing: %s\n", call.Function.Name)
-			}
-
-			var result api.Message
-			var handled bool
-			var err error
-
-			// Try skill catalog first
-			if skillsCatalog != nil {
-				result, handled, err = skillsCatalog.RunToolCall(call)
-			}
-
-			// If not handled by skills, try MCP
-			if !handled && mcpMgr != nil {
-				result, handled, err = mcpMgr.RunToolCall(call)
-			}
-
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-				// Add error result
-				toolResults = append(toolResults, api.Message{
-					Role:    "tool",
-					Content: fmt.Sprintf("Error: %v", err),
-				})
-				continue
-			}
-			if !handled {
-				fmt.Fprintf(os.Stderr, "Warning: Unknown tool %s\n", call.Function.Name)
-				toolResults = append(toolResults, api.Message{
-					Role:    "tool",
-					Content: fmt.Sprintf("Unknown tool: %s", call.Function.Name),
-				})
-				continue
-			}
-
-			// Display tool output
-			if result.Content != "" {
-				fmt.Fprintf(os.Stderr, "Output:\n%s\n", result.Content)
-			}
-
-			// Add tool result to messages (preserves ToolName, ToolCallID from result)
-			toolResults = append(toolResults, result)
-		}
-
-		// 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)
+		return nil, err
 	}
 
 	if len(opts.Messages) > 0 {
@@ -2091,6 +1765,7 @@ func NewCLI() *cobra.Command {
 	runCmd.Flags().Bool("truncate", false, "For embedding models: truncate inputs exceeding context length (default: true). Set --truncate=false to error instead")
 	runCmd.Flags().Int("dimensions", 0, "Truncate output embeddings to specified dimension (embedding models only)")
 	runCmd.Flags().Bool("experimental", false, "Enable experimental agent loop with tools")
+	runCmd.Flags().BoolP("yolo", "y", false, "Skip all tool approval prompts (use with caution)")
 
 	stopCmd := &cobra.Command{
 		Use:     "stop MODEL",
@@ -2158,6 +1833,7 @@ func NewCLI() *cobra.Command {
 		PreRunE: checkServerHeartbeat,
 		RunE:    ListRunningHandler,
 	}
+
 	copyCmd := &cobra.Command{
 		Use:     "cp SOURCE DESTINATION",
 		Short:   "Copy a model",
@@ -2245,8 +1921,6 @@ func NewCLI() *cobra.Command {
 		copyCmd,
 		deleteCmd,
 		runnerCmd,
-		NewSkillCommand(),
-		NewMCPCommand(),
 	)
 
 	return rootCmd

cmd/interactive.go

@@ -34,9 +34,6 @@ func generateInteractive(cmd *cobra.Command, opts runOptions) error {
 		fmt.Fprintln(os.Stderr, "Available Commands:")
 		fmt.Fprintln(os.Stderr, "  /set            Set session variables")
 		fmt.Fprintln(os.Stderr, "  /show           Show model information")
-		fmt.Fprintln(os.Stderr, "  /skills         Show available skills")
-		fmt.Fprintln(os.Stderr, "  /skill          Add or remove skills dynamically")
-		fmt.Fprintln(os.Stderr, "  /mcp            Show/add/remove MCP servers")
 		fmt.Fprintln(os.Stderr, "  /load <model>   Load a session or model")
 		fmt.Fprintln(os.Stderr, "  /save <model>   Save your current session")
 		fmt.Fprintln(os.Stderr, "  /clear          Clear session context")
@@ -447,411 +444,6 @@ func generateInteractive(cmd *cobra.Command, opts runOptions) error {
 			} else {
 				usageShow()
 			}
-		case strings.HasPrefix(line, "/skill "):
-			args := strings.Fields(line)
-			if len(args) < 2 {
-				fmt.Fprintln(os.Stderr, "Usage:")
-				fmt.Fprintln(os.Stderr, "  /skill add <path>      Add a skill from local path")
-				fmt.Fprintln(os.Stderr, "  /skill remove <name>   Remove a skill by name")
-				fmt.Fprintln(os.Stderr, "  /skill list            List current skills")
-				continue
-			}
-
-			switch args[1] {
-			case "add":
-				if len(args) < 3 {
-					fmt.Println("Usage: /skill add <path>")
-					continue
-				}
-				skillPath := args[2]
-
-				// Expand ~ to home directory
-				if strings.HasPrefix(skillPath, "~") {
-					home, err := os.UserHomeDir()
-					if err != nil {
-						fmt.Printf("Error expanding path: %v\n", err)
-						continue
-					}
-					skillPath = filepath.Join(home, skillPath[1:])
-				}
-
-				// Make absolute
-				absPath, err := filepath.Abs(skillPath)
-				if err != nil {
-					fmt.Printf("Error resolving path: %v\n", err)
-					continue
-				}
-
-				// Verify SKILL.md exists
-				skillMdPath := filepath.Join(absPath, "SKILL.md")
-				if _, err := os.Stat(skillMdPath); err != nil {
-					fmt.Printf("Error: %s does not contain SKILL.md\n", skillPath)
-					continue
-				}
-
-				// Extract skill name from SKILL.md
-				content, err := os.ReadFile(skillMdPath)
-				if err != nil {
-					fmt.Printf("Error reading SKILL.md: %v\n", err)
-					continue
-				}
-				skillName, _ := extractSkillMetadata(string(content))
-				if skillName == "" {
-					skillName = filepath.Base(absPath)
-				}
-
-				// Check if already added
-				for _, s := range opts.Skills {
-					if s.Name == skillName {
-						fmt.Printf("Skill '%s' is already loaded\n", skillName)
-						continue
-					}
-				}
-
-				// Add to skills (using path as Name, no digest for local skills)
-				opts.Skills = append(opts.Skills, api.SkillRef{Name: absPath})
-				opts.IsAgent = true // Enable agent mode if not already
-				fmt.Printf("Added skill '%s' from %s\n", skillName, skillPath)
-
-			case "remove", "rm":
-				if len(args) < 3 {
-					fmt.Println("Usage: /skill remove <name>")
-					continue
-				}
-				skillName := args[2]
-
-				found := false
-				newSkills := make([]api.SkillRef, 0, len(opts.Skills))
-				for _, s := range opts.Skills {
-					// Match by name or by path basename
-					name := s.Name
-					if strings.Contains(name, string(os.PathSeparator)) {
-						name = filepath.Base(name)
-					}
-					if name == skillName || s.Name == skillName {
-						found = true
-						fmt.Printf("Removed skill '%s'\n", skillName)
-					} else {
-						newSkills = append(newSkills, s)
-					}
-				}
-				if !found {
-					fmt.Printf("Skill '%s' not found\n", skillName)
-				} else {
-					opts.Skills = newSkills
-				}
-
-			case "list", "ls":
-				if len(opts.Skills) == 0 {
-					fmt.Println("No skills loaded in this session.")
-				} else {
-					fmt.Println("Skills loaded in this session:")
-					for _, skill := range opts.Skills {
-						if skill.Digest != "" {
-							fmt.Printf("  %s (%s)\n", skill.Name, skill.Digest[:19])
-						} else {
-							// For local paths, show basename
-							name := skill.Name
-							if strings.Contains(name, string(os.PathSeparator)) {
-								name = filepath.Base(name) + " (local: " + skill.Name + ")"
-							}
-							fmt.Printf("  %s\n", name)
-						}
-					}
-				}
-				fmt.Println()
-
-			default:
-				fmt.Printf("Unknown skill command '%s'. Use /skill add, /skill remove, or /skill list\n", args[1])
-			}
-			continue
-
-		case strings.HasPrefix(line, "/skills"):
-			// Show skills from model (bundled) + session skills
-			client, err := api.ClientFromEnvironment()
-			if err != nil {
-				fmt.Println("error: couldn't connect to ollama server")
-				return err
-			}
-			req := &api.ShowRequest{
-				Name: opts.Model,
-			}
-			resp, err := client.Show(cmd.Context(), req)
-			if err != nil {
-				fmt.Println("error: couldn't get model info")
-				return err
-			}
-
-			// Combine model skills with session skills
-			allSkills := make([]api.SkillRef, 0)
-			allSkills = append(allSkills, resp.Skills...)
-
-			// Add session skills that aren't already in model skills
-			for _, sessionSkill := range opts.Skills {
-				found := false
-				for _, modelSkill := range resp.Skills {
-					if modelSkill.Name == sessionSkill.Name || modelSkill.Digest == sessionSkill.Digest {
-						found = true
-						break
-					}
-				}
-				if !found {
-					allSkills = append(allSkills, sessionSkill)
-				}
-			}
-
-			if len(allSkills) == 0 {
-				fmt.Println("No skills available.")
-			} else {
-				fmt.Println("Available Skills:")
-				for _, skill := range allSkills {
-					if skill.Digest != "" {
-						fmt.Printf("  %s (%s)\n", skill.Name, skill.Digest[:19])
-					} else {
-						name := skill.Name
-						if strings.Contains(name, string(os.PathSeparator)) {
-							name = filepath.Base(name) + " (session)"
-						}
-						fmt.Printf("  %s\n", name)
-					}
-				}
-			}
-			fmt.Println()
-			continue
-
-		case strings.HasPrefix(line, "/mcp"):
-			args := strings.Fields(line)
-
-			// If just "/mcp" with no args, show all MCP servers
-			if len(args) == 1 {
-				// Show MCPs from model (bundled) + global config
-				client, err := api.ClientFromEnvironment()
-				if err != nil {
-					fmt.Println("error: couldn't connect to ollama server")
-					return err
-				}
-				req := &api.ShowRequest{
-					Name: opts.Model,
-				}
-				resp, err := client.Show(cmd.Context(), req)
-				if err != nil {
-					fmt.Println("error: couldn't get model info")
-					return err
-				}
-
-				// Combine model MCPs with global config MCPs
-				allMCPs := make([]api.MCPRef, 0)
-				allMCPs = append(allMCPs, resp.MCPs...)
-
-				// Load global config
-				globalConfig, _ := loadMCPConfig()
-				globalMCPNames := make(map[string]bool)
-
-				if globalConfig != nil {
-					for name, srv := range globalConfig.MCPServers {
-						// Check if already in model MCPs
-						found := false
-						for _, modelMCP := range resp.MCPs {
-							if modelMCP.Name == name {
-								found = true
-								break
-							}
-						}
-						if !found {
-							allMCPs = append(allMCPs, api.MCPRef{
-								Name:    name,
-								Command: srv.Command,
-								Args:    srv.Args,
-								Env:     srv.Env,
-								Type:    srv.Type,
-							})
-						}
-						globalMCPNames[name] = true
-					}
-				}
-
-				if len(allMCPs) == 0 {
-					fmt.Println("No MCP servers available.")
-					fmt.Println("Use '/mcp add <name> <command> [args...]' to add one.")
-				} else {
-					fmt.Println("Available MCP Servers:")
-					for _, mcp := range allMCPs {
-						cmdLine := mcp.Command
-						if len(mcp.Args) > 0 {
-							cmdLine += " " + strings.Join(mcp.Args, " ")
-						}
-						source := ""
-						disabled := ""
-						// Check if it's from model or global config
-						isFromModel := false
-						for _, modelMCP := range resp.MCPs {
-							if modelMCP.Name == mcp.Name {
-								isFromModel = true
-								break
-							}
-						}
-						if isFromModel {
-							source = " (model)"
-						} else if globalMCPNames[mcp.Name] {
-							source = " (global)"
-							// Check if disabled
-							if srv, ok := globalConfig.MCPServers[mcp.Name]; ok && srv.Disabled {
-								disabled = " [disabled]"
-							}
-						}
-						fmt.Printf("  %s: %s%s%s\n", mcp.Name, cmdLine, source, disabled)
-					}
-				}
-				fmt.Println()
-				continue
-			}
-
-			switch args[1] {
-			case "add":
-				if len(args) < 4 {
-					fmt.Println("Usage: /mcp add <name> <command> [args...]")
-					continue
-				}
-				mcpName := args[2]
-				mcpCommand := args[3]
-				mcpArgs := args[4:]
-
-				// Load global config
-				config, err := loadMCPConfig()
-				if err != nil {
-					fmt.Printf("Error loading MCP config: %v\n", err)
-					continue
-				}
-
-				// Check if already exists
-				if _, exists := config.MCPServers[mcpName]; exists {
-					fmt.Printf("Warning: overwriting existing MCP server '%s'\n", mcpName)
-				}
-
-				// Add to global config
-				config.MCPServers[mcpName] = MCPServerConfig{
-					Type:    "stdio",
-					Command: mcpCommand,
-					Args:    mcpArgs,
-				}
-
-				// Save config
-				if err := saveMCPConfig(config); err != nil {
-					fmt.Printf("Error saving MCP config: %v\n", err)
-					continue
-				}
-
-				cmdLine := mcpCommand
-				if len(mcpArgs) > 0 {
-					cmdLine += " " + strings.Join(mcpArgs, " ")
-				}
-				fmt.Printf("Added MCP server '%s' (%s) to %s\n", mcpName, cmdLine, getMCPConfigPath())
-				fmt.Println("Note: MCP server will be started on next message.")
-
-			case "remove", "rm":
-				if len(args) < 3 {
-					fmt.Println("Usage: /mcp remove <name>")
-					continue
-				}
-				mcpName := args[2]
-
-				// Load global config
-				config, err := loadMCPConfig()
-				if err != nil {
-					fmt.Printf("Error loading MCP config: %v\n", err)
-					continue
-				}
-
-				if _, exists := config.MCPServers[mcpName]; !exists {
-					fmt.Printf("MCP server '%s' not found in global config\n", mcpName)
-					continue
-				}
-
-				delete(config.MCPServers, mcpName)
-
-				if err := saveMCPConfig(config); err != nil {
-					fmt.Printf("Error saving MCP config: %v\n", err)
-					continue
-				}
-
-				fmt.Printf("Removed MCP server '%s' from %s\n", mcpName, getMCPConfigPath())
-				fmt.Println("Note: Changes will take effect on next message.")
-
-			case "disable":
-				if len(args) < 3 {
-					fmt.Println("Usage: /mcp disable <name>")
-					continue
-				}
-				mcpName := args[2]
-
-				config, err := loadMCPConfig()
-				if err != nil {
-					fmt.Printf("Error loading MCP config: %v\n", err)
-					continue
-				}
-
-				srv, exists := config.MCPServers[mcpName]
-				if !exists {
-					fmt.Printf("MCP server '%s' not found in global config\n", mcpName)
-					continue
-				}
-
-				if srv.Disabled {
-					fmt.Printf("MCP server '%s' is already disabled\n", mcpName)
-					continue
-				}
-
-				srv.Disabled = true
-				config.MCPServers[mcpName] = srv
-
-				if err := saveMCPConfig(config); err != nil {
-					fmt.Printf("Error saving MCP config: %v\n", err)
-					continue
-				}
-
-				fmt.Printf("Disabled MCP server '%s'\n", mcpName)
-				fmt.Println("Note: Changes will take effect on next message.")
-
-			case "enable":
-				if len(args) < 3 {
-					fmt.Println("Usage: /mcp enable <name>")
-					continue
-				}
-				mcpName := args[2]
-
-				config, err := loadMCPConfig()
-				if err != nil {
-					fmt.Printf("Error loading MCP config: %v\n", err)
-					continue
-				}
-
-				srv, exists := config.MCPServers[mcpName]
-				if !exists {
-					fmt.Printf("MCP server '%s' not found in global config\n", mcpName)
-					continue
-				}
-
-				if !srv.Disabled {
-					fmt.Printf("MCP server '%s' is already enabled\n", mcpName)
-					continue
-				}
-
-				srv.Disabled = false
-				config.MCPServers[mcpName] = srv
-
-				if err := saveMCPConfig(config); err != nil {
-					fmt.Printf("Error saving MCP config: %v\n", err)
-					continue
-				}
-
-				fmt.Printf("Enabled MCP server '%s'\n", mcpName)
-				fmt.Println("Note: Changes will take effect on next message.")
-
-			default:
-				fmt.Printf("Unknown mcp command '%s'. Use /mcp, /mcp add, /mcp remove, /mcp disable, or /mcp enable\n", args[1])
-			}
-			continue
-
 		case strings.HasPrefix(line, "/help"), strings.HasPrefix(line, "/?"):
 			args := strings.Fields(line)
 			if len(args) > 1 {
@@ -860,20 +452,6 @@ func generateInteractive(cmd *cobra.Command, opts runOptions) error {
 					usageSet()
 				case "show", "/show":
 					usageShow()
-				case "skill", "/skill":
-					fmt.Fprintln(os.Stderr, "Available Commands:")
-					fmt.Fprintln(os.Stderr, "  /skill add <path>      Add a skill from local path")
-					fmt.Fprintln(os.Stderr, "  /skill remove <name>   Remove a skill by name")
-					fmt.Fprintln(os.Stderr, "  /skill list            List current session skills")
-					fmt.Fprintln(os.Stderr, "")
-				case "mcp", "/mcp":
-					fmt.Fprintln(os.Stderr, "Available Commands:")
-					fmt.Fprintln(os.Stderr, "  /mcp                                  Show all MCP servers")
-					fmt.Fprintln(os.Stderr, "  /mcp add <name> <command> [args...]   Add an MCP server to global config")
-					fmt.Fprintln(os.Stderr, "  /mcp remove <name>                    Remove an MCP server from global config")
-					fmt.Fprintln(os.Stderr, "  /mcp disable <name>                   Disable an MCP server (keep in config)")
-					fmt.Fprintln(os.Stderr, "  /mcp enable <name>                    Re-enable a disabled MCP server")
-					fmt.Fprintln(os.Stderr, "")
 				case "shortcut", "shortcuts":
 					usageShortcuts()
 				}

cmd/skill_cmd.go

@@ -1,570 +0,0 @@
-package cmd
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"text/tabwriter"
-	"time"
-
-	"github.com/spf13/cobra"
-
-	"github.com/ollama/ollama/api"
-	"github.com/ollama/ollama/format"
-	"github.com/ollama/ollama/progress"
-	"github.com/ollama/ollama/server"
-	"github.com/ollama/ollama/types/model"
-)
-
-// SkillPushHandler handles the skill push command.
-func SkillPushHandler(cmd *cobra.Command, args []string) error {
-	if len(args) != 2 {
-		return fmt.Errorf("usage: ollama skill push NAME[:TAG] PATH")
-	}
-
-	name := args[0]
-	path := args[1]
-
-	// Expand path
-	if strings.HasPrefix(path, "~") {
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return fmt.Errorf("expanding home directory: %w", err)
-		}
-		path = filepath.Join(home, path[1:])
-	}
-
-	absPath, err := filepath.Abs(path)
-	if err != nil {
-		return fmt.Errorf("resolving path: %w", err)
-	}
-
-	// Validate skill directory
-	skillMdPath := filepath.Join(absPath, "SKILL.md")
-	if _, err := os.Stat(skillMdPath); err != nil {
-		return fmt.Errorf("skill directory must contain SKILL.md: %w", err)
-	}
-
-	// Parse skill name (will set Kind="skill")
-	n := server.ParseSkillName(name)
-	if n.Model == "" {
-		return fmt.Errorf("invalid skill name: %s", name)
-	}
-
-	p := progress.NewProgress(os.Stderr)
-	defer p.Stop()
-
-	// Create skill layer
-	displayName := n.DisplayShortest()
-	status := fmt.Sprintf("Creating skill layer for %s", displayName)
-	spinner := progress.NewSpinner(status)
-	p.Add(status, spinner)
-
-	layer, err := server.CreateSkillLayer(absPath)
-	if err != nil {
-		return fmt.Errorf("creating skill layer: %w", err)
-	}
-
-	spinner.Stop()
-
-	// Create skill manifest
-	manifest, configLayer, err := createSkillManifest(absPath, layer)
-	if err != nil {
-		return fmt.Errorf("creating skill manifest: %w", err)
-	}
-
-	// Write manifest locally
-	manifestPath, err := server.GetSkillManifestPath(n)
-	if err != nil {
-		return fmt.Errorf("getting manifest path: %w", err)
-	}
-
-	if err := os.MkdirAll(filepath.Dir(manifestPath), 0o755); err != nil {
-		return fmt.Errorf("creating manifest directory: %w", err)
-	}
-
-	manifestJSON, err := json.Marshal(manifest)
-	if err != nil {
-		return fmt.Errorf("marshaling manifest: %w", err)
-	}
-
-	if err := os.WriteFile(manifestPath, manifestJSON, 0o644); err != nil {
-		return fmt.Errorf("writing manifest: %w", err)
-	}
-
-	fmt.Fprintf(os.Stderr, "Skill %s created locally\n", displayName)
-	fmt.Fprintf(os.Stderr, "  Config: %s (%s)\n", configLayer.Digest, format.HumanBytes(configLayer.Size))
-	fmt.Fprintf(os.Stderr, "  Layer:  %s (%s)\n", layer.Digest, format.HumanBytes(layer.Size))
-
-	// Push to registry
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return fmt.Errorf("creating client: %w", err)
-	}
-
-	insecure, _ := cmd.Flags().GetBool("insecure")
-
-	// For now, we'll use the existing push mechanism
-	fmt.Fprintf(os.Stderr, "\nPushing to registry...\n")
-
-	fn := func(resp api.ProgressResponse) error {
-		if resp.Digest != "" {
-			bar := progress.NewBar(resp.Status, resp.Total, resp.Completed)
-			p.Add(resp.Digest, bar)
-		} else if resp.Status != "" {
-			spinner := progress.NewSpinner(resp.Status)
-			p.Add(resp.Status, spinner)
-		}
-		return nil
-	}
-
-	req := &api.PushRequest{
-		Model:    displayName,
-		Insecure: insecure,
-	}
-
-	if err := client.Push(context.Background(), req, fn); err != nil {
-		// If push fails, still show success for local creation
-		fmt.Fprintf(os.Stderr, "\nNote: Local skill created but push failed: %v\n", err)
-		fmt.Fprintf(os.Stderr, "You can try pushing later with: ollama skill push %s\n", name)
-		return nil
-	}
-
-	fmt.Fprintf(os.Stderr, "Successfully pushed %s\n", displayName)
-	return nil
-}
-
-// SkillPullHandler handles the skill pull command.
-func SkillPullHandler(cmd *cobra.Command, args []string) error {
-	if len(args) != 1 {
-		return fmt.Errorf("usage: ollama skill pull NAME[:TAG]")
-	}
-
-	name := args[0]
-	n := server.ParseSkillName(name)
-	if n.Model == "" {
-		return fmt.Errorf("invalid skill name: %s", name)
-	}
-
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return fmt.Errorf("creating client: %w", err)
-	}
-
-	insecure, _ := cmd.Flags().GetBool("insecure")
-
-	p := progress.NewProgress(os.Stderr)
-	defer p.Stop()
-
-	fn := func(resp api.ProgressResponse) error {
-		if resp.Digest != "" {
-			bar := progress.NewBar(resp.Status, resp.Total, resp.Completed)
-			p.Add(resp.Digest, bar)
-		} else if resp.Status != "" {
-			spinner := progress.NewSpinner(resp.Status)
-			p.Add(resp.Status, spinner)
-		}
-		return nil
-	}
-
-	displayName := n.DisplayShortest()
-	req := &api.PullRequest{
-		Model:    displayName,
-		Insecure: insecure,
-	}
-
-	if err := client.Pull(context.Background(), req, fn); err != nil {
-		return fmt.Errorf("pulling skill: %w", err)
-	}
-
-	fmt.Fprintf(os.Stderr, "Successfully pulled %s\n", displayName)
-	return nil
-}
-
-// SkillListHandler handles the skill list command.
-func SkillListHandler(cmd *cobra.Command, args []string) error {
-	skills, err := listLocalSkills()
-	if err != nil {
-		return fmt.Errorf("listing skills: %w", err)
-	}
-
-	if len(skills) == 0 {
-		fmt.Println("No skills installed")
-		return nil
-	}
-
-	w := tabwriter.NewWriter(os.Stdout, 0, 0, 3, ' ', 0)
-	fmt.Fprintln(w, "NAME\tTAG\tSIZE\tMODIFIED")
-
-	for _, skill := range skills {
-		fmt.Fprintf(w, "%s/%s\t%s\t%s\t%s\n",
-			skill.Namespace,
-			skill.Name,
-			skill.Tag,
-			format.HumanBytes(skill.Size),
-			format.HumanTime(skill.ModifiedAt, "Never"),
-		)
-	}
-
-	return w.Flush()
-}
-
-// SkillRemoveHandler handles the skill rm command.
-func SkillRemoveHandler(cmd *cobra.Command, args []string) error {
-	if len(args) == 0 {
-		return fmt.Errorf("usage: ollama skill rm NAME[:TAG] [NAME[:TAG]...]")
-	}
-
-	for _, name := range args {
-		n := server.ParseSkillName(name)
-		if n.Model == "" {
-			fmt.Fprintf(os.Stderr, "Invalid skill name: %s\n", name)
-			continue
-		}
-
-		displayName := n.DisplayShortest()
-		manifestPath, err := server.GetSkillManifestPath(n)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting manifest path for %s: %v\n", name, err)
-			continue
-		}
-
-		if _, err := os.Stat(manifestPath); os.IsNotExist(err) {
-			fmt.Fprintf(os.Stderr, "Skill not found: %s\n", displayName)
-			continue
-		}
-
-		if err := os.Remove(manifestPath); err != nil {
-			fmt.Fprintf(os.Stderr, "Error removing %s: %v\n", displayName, err)
-			continue
-		}
-
-		// Clean up empty parent directories
-		dir := filepath.Dir(manifestPath)
-		for dir != filepath.Join(os.Getenv("HOME"), ".ollama", "models", "manifests") {
-			entries, _ := os.ReadDir(dir)
-			if len(entries) == 0 {
-				os.Remove(dir)
-				dir = filepath.Dir(dir)
-			} else {
-				break
-			}
-		}
-
-		fmt.Fprintf(os.Stderr, "Deleted '%s'\n", displayName)
-	}
-
-	return nil
-}
-
-// SkillShowHandler handles the skill show command.
-func SkillShowHandler(cmd *cobra.Command, args []string) error {
-	if len(args) != 1 {
-		return fmt.Errorf("usage: ollama skill show NAME[:TAG]")
-	}
-
-	name := args[0]
-	n := server.ParseSkillName(name)
-	if n.Model == "" {
-		return fmt.Errorf("invalid skill name: %s", name)
-	}
-
-	displayName := n.DisplayShortest()
-	manifestPath, err := server.GetSkillManifestPath(n)
-	if err != nil {
-		return fmt.Errorf("getting manifest path: %w", err)
-	}
-
-	data, err := os.ReadFile(manifestPath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return fmt.Errorf("skill not found: %s", displayName)
-		}
-		return fmt.Errorf("reading manifest: %w", err)
-	}
-
-	var manifest server.Manifest
-	if err := json.Unmarshal(data, &manifest); err != nil {
-		return fmt.Errorf("parsing manifest: %w", err)
-	}
-
-	fmt.Printf("Skill: %s\n\n", displayName)
-
-	fmt.Println("Layers:")
-	for _, layer := range manifest.Layers {
-		fmt.Printf("  %s  %s  %s\n", layer.MediaType, layer.Digest[:19], format.HumanBytes(layer.Size))
-	}
-
-	// Try to read and display SKILL.md content
-	if len(manifest.Layers) > 0 {
-		for _, layer := range manifest.Layers {
-			if layer.MediaType == server.MediaTypeSkill {
-				skillPath, err := server.GetSkillsPath(layer.Digest)
-				if err == nil {
-					skillMdPath := filepath.Join(skillPath, "SKILL.md")
-					if content, err := os.ReadFile(skillMdPath); err == nil {
-						fmt.Println("\nContent:")
-						fmt.Println(string(content))
-					}
-				}
-			}
-		}
-	}
-
-	return nil
-}
-
-// SkillInfo represents information about an installed skill.
-type SkillInfo struct {
-	Namespace  string
-	Name       string
-	Tag        string
-	Size       int64
-	ModifiedAt time.Time
-}
-
-// listLocalSkills returns a list of locally installed skills.
-// Skills are stored with 5-part paths: host/namespace/kind/model/tag
-// where kind is "skill".
-func listLocalSkills() ([]SkillInfo, error) {
-	manifestsPath := filepath.Join(os.Getenv("HOME"), ".ollama", "models", "manifests")
-
-	var skills []SkillInfo
-
-	// Walk through all registries
-	registries, err := os.ReadDir(manifestsPath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return skills, nil
-		}
-		return nil, err
-	}
-
-	for _, registry := range registries {
-		if !registry.IsDir() {
-			continue
-		}
-
-		// Walk namespaces
-		namespaces, err := os.ReadDir(filepath.Join(manifestsPath, registry.Name()))
-		if err != nil {
-			continue
-		}
-
-		for _, namespace := range namespaces {
-			if !namespace.IsDir() {
-				continue
-			}
-
-			// Walk kinds looking for "skill"
-			kinds, err := os.ReadDir(filepath.Join(manifestsPath, registry.Name(), namespace.Name()))
-			if err != nil {
-				continue
-			}
-
-			for _, kind := range kinds {
-				if !kind.IsDir() {
-					continue
-				}
-
-				// Only process skill kind
-				if kind.Name() != server.SkillNamespace {
-					continue
-				}
-
-				// Walk skill names (model names)
-				skillNames, err := os.ReadDir(filepath.Join(manifestsPath, registry.Name(), namespace.Name(), kind.Name()))
-				if err != nil {
-					continue
-				}
-
-				for _, skillName := range skillNames {
-					if !skillName.IsDir() {
-						continue
-					}
-
-					// Walk tags
-					tags, err := os.ReadDir(filepath.Join(manifestsPath, registry.Name(), namespace.Name(), kind.Name(), skillName.Name()))
-					if err != nil {
-						continue
-					}
-
-					for _, tag := range tags {
-						manifestPath := filepath.Join(manifestsPath, registry.Name(), namespace.Name(), kind.Name(), skillName.Name(), tag.Name())
-						fi, err := os.Stat(manifestPath)
-						if err != nil || fi.IsDir() {
-							continue
-						}
-
-						// Read manifest to get size
-						data, err := os.ReadFile(manifestPath)
-						if err != nil {
-							continue
-						}
-
-						var manifest server.Manifest
-						if err := json.Unmarshal(data, &manifest); err != nil {
-							continue
-						}
-
-						var totalSize int64
-						for _, layer := range manifest.Layers {
-							totalSize += layer.Size
-						}
-
-						// Build display name using model.Name
-						n := model.Name{
-							Host:      registry.Name(),
-							Namespace: namespace.Name(),
-							Kind:      kind.Name(),
-							Model:     skillName.Name(),
-							Tag:       tag.Name(),
-						}
-
-						skills = append(skills, SkillInfo{
-							Namespace:  n.Namespace + "/" + n.Kind,
-							Name:       n.Model,
-							Tag:        n.Tag,
-							Size:       totalSize,
-							ModifiedAt: fi.ModTime(),
-						})
-					}
-				}
-			}
-		}
-	}
-
-	return skills, nil
-}
-
-// createSkillManifest creates a manifest for a standalone skill.
-func createSkillManifest(skillDir string, layer server.Layer) (*server.Manifest, *server.Layer, error) {
-	// Read SKILL.md to extract metadata
-	skillMdPath := filepath.Join(skillDir, "SKILL.md")
-	content, err := os.ReadFile(skillMdPath)
-	if err != nil {
-		return nil, nil, fmt.Errorf("reading SKILL.md: %w", err)
-	}
-
-	// Extract name and description from frontmatter
-	name, description := extractSkillMetadata(string(content))
-	if name == "" {
-		return nil, nil, errors.New("skill name not found in SKILL.md frontmatter")
-	}
-
-	// Create config
-	config := map[string]any{
-		"name":         name,
-		"description":  description,
-		"architecture": "amd64",
-		"os":           "linux",
-	}
-
-	configJSON, err := json.Marshal(config)
-	if err != nil {
-		return nil, nil, fmt.Errorf("marshaling config: %w", err)
-	}
-
-	// Create config layer
-	configLayer, err := server.NewLayer(strings.NewReader(string(configJSON)), "application/vnd.docker.container.image.v1+json")
-	if err != nil {
-		return nil, nil, fmt.Errorf("creating config layer: %w", err)
-	}
-
-	manifest := &server.Manifest{
-		SchemaVersion: 2,
-		MediaType:     "application/vnd.docker.distribution.manifest.v2+json",
-		Config:        configLayer,
-		Layers:        []server.Layer{layer},
-	}
-
-	return manifest, &configLayer, nil
-}
-
-// extractSkillMetadata extracts name and description from SKILL.md frontmatter.
-func extractSkillMetadata(content string) (name, description string) {
-	lines := strings.Split(content, "\n")
-
-	inFrontmatter := false
-	for _, line := range lines {
-		trimmed := strings.TrimSpace(line)
-
-		if trimmed == "---" {
-			if !inFrontmatter {
-				inFrontmatter = true
-				continue
-			} else {
-				break // End of frontmatter
-			}
-		}
-
-		if inFrontmatter {
-			if strings.HasPrefix(trimmed, "name:") {
-				name = strings.TrimSpace(strings.TrimPrefix(trimmed, "name:"))
-			} else if strings.HasPrefix(trimmed, "description:") {
-				description = strings.TrimSpace(strings.TrimPrefix(trimmed, "description:"))
-			}
-		}
-	}
-
-	return name, description
-}
-
-// NewSkillCommand creates the skill parent command with subcommands.
-func NewSkillCommand() *cobra.Command {
-	skillCmd := &cobra.Command{
-		Use:   "skill",
-		Short: "Manage skills",
-		Long:  "Commands for managing agent skills (push, pull, list, rm, show)",
-	}
-
-	pushCmd := &cobra.Command{
-		Use:     "push NAME[:TAG] PATH",
-		Short:   "Push a skill to a registry",
-		Long:    "Package a local skill directory and push it to a registry",
-		Args:    cobra.ExactArgs(2),
-		PreRunE: checkServerHeartbeat,
-		RunE:    SkillPushHandler,
-	}
-	pushCmd.Flags().Bool("insecure", false, "Use an insecure registry")
-
-	pullCmd := &cobra.Command{
-		Use:     "pull NAME[:TAG]",
-		Short:   "Pull a skill from a registry",
-		Args:    cobra.ExactArgs(1),
-		PreRunE: checkServerHeartbeat,
-		RunE:    SkillPullHandler,
-	}
-	pullCmd.Flags().Bool("insecure", false, "Use an insecure registry")
-
-	listCmd := &cobra.Command{
-		Use:     "list",
-		Aliases: []string{"ls"},
-		Short:   "List installed skills",
-		Args:    cobra.NoArgs,
-		RunE:    SkillListHandler,
-	}
-
-	rmCmd := &cobra.Command{
-		Use:     "rm NAME[:TAG] [NAME[:TAG]...]",
-		Aliases: []string{"remove", "delete"},
-		Short:   "Remove a skill",
-		Args:    cobra.MinimumNArgs(1),
-		RunE:    SkillRemoveHandler,
-	}
-
-	showCmd := &cobra.Command{
-		Use:   "show NAME[:TAG]",
-		Short: "Show skill details",
-		Args:  cobra.ExactArgs(1),
-		RunE:  SkillShowHandler,
-	}
-
-	skillCmd.AddCommand(pushCmd, pullCmd, listCmd, rmCmd, showCmd)
-
-	return skillCmd
-}

cmd/skills.go

@@ -1,591 +0,0 @@
-package cmd
-
-import (
-	"bufio"
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io/fs"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"regexp"
-	"sort"
-	"strings"
-	"time"
-
-	"gopkg.in/yaml.v3"
-
-	"github.com/ollama/ollama/api"
-	"github.com/ollama/ollama/server"
-)
-
-const (
-	skillFileName       = "SKILL.md"
-	maxSkillDescription = 1024
-	maxSkillNameLength  = 64
-)
-
-var skillNamePattern = regexp.MustCompile(`^[a-z0-9]+(?:-[a-z0-9]+)*$`)
-
-type skillMetadata struct {
-	Name        string `yaml:"name"`
-	Description string `yaml:"description"`
-}
-
-type skillDefinition struct {
-	Name        string
-	Description string
-	Content     string // Full SKILL.md content (without frontmatter)
-	Dir         string
-	SkillPath   string
-}
-
-type skillCatalog struct {
-	Skills []skillDefinition
-	byName map[string]skillDefinition
-}
-
-func loadSkills(paths []string) (*skillCatalog, error) {
-	if len(paths) == 0 {
-		return nil, nil
-	}
-
-	var skills []skillDefinition
-	byName := make(map[string]skillDefinition)
-	for _, root := range paths {
-		info, err := os.Stat(root)
-		if err != nil {
-			return nil, fmt.Errorf("skills directory %q: %w", root, err)
-		}
-		if !info.IsDir() {
-			return nil, fmt.Errorf("skills path %q is not a directory", root)
-		}
-
-		err = filepath.WalkDir(root, func(path string, entry fs.DirEntry, walkErr error) error {
-			if walkErr != nil {
-				return walkErr
-			}
-			if entry.IsDir() {
-				return nil
-			}
-			if entry.Name() != skillFileName {
-				return nil
-			}
-
-			skillDir := filepath.Dir(path)
-			skill, err := parseSkillFile(path, skillDir)
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "Warning: skipping skill at %s: %v\n", path, err)
-				return nil
-			}
-
-			if _, exists := byName[skill.Name]; exists {
-				fmt.Fprintf(os.Stderr, "Warning: duplicate skill name %q at %s\n", skill.Name, path)
-				return nil
-			}
-
-			byName[skill.Name] = skill
-			skills = append(skills, skill)
-			return nil
-		})
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	if len(skills) == 0 {
-		return nil, nil
-	}
-
-	sort.Slice(skills, func(i, j int) bool {
-		return skills[i].Name < skills[j].Name
-	})
-
-	return &skillCatalog{Skills: skills, byName: byName}, nil
-}
-
-// loadSkillsFromRefs loads skills from a list of SkillRef objects.
-// Skills can be referenced by:
-//   - Digest: loaded from the extracted skill cache (for bundled/pulled skills)
-//   - Name (local path): loaded from the filesystem (for development)
-func loadSkillsFromRefs(refs []api.SkillRef) (*skillCatalog, error) {
-	if len(refs) == 0 {
-		return nil, nil
-	}
-
-	var skills []skillDefinition
-	byName := make(map[string]skillDefinition)
-
-	for _, ref := range refs {
-		var skillDir string
-
-		if ref.Digest != "" {
-			// Load from extracted skill cache
-			path, err := server.GetSkillsPath(ref.Digest)
-			if err != nil {
-				return nil, fmt.Errorf("getting skill path for %s: %w", ref.Digest, err)
-			}
-
-			// Check if skill is already extracted
-			skillMdPath := filepath.Join(path, skillFileName)
-			if _, err := os.Stat(skillMdPath); os.IsNotExist(err) {
-				// Try to extract the skill blob
-				path, err = server.ExtractSkillBlob(ref.Digest)
-				if err != nil {
-					return nil, fmt.Errorf("extracting skill %s: %w", ref.Digest, err)
-				}
-			}
-
-			skillDir = path
-		} else if ref.Name != "" {
-			// Check if this is a local path or a registry reference
-			if !server.IsLocalSkillPath(ref.Name) {
-				// Registry reference without a digest - skill needs to be pulled first
-				// This happens when an agent references a skill that hasn't been bundled
-				return nil, fmt.Errorf("skill %q is a registry reference but has no digest - the agent may need to be recreated or the skill pulled separately", ref.Name)
-			}
-
-			// Local path - resolve it
-			skillPath := ref.Name
-			if strings.HasPrefix(skillPath, "~") {
-				home, err := os.UserHomeDir()
-				if err != nil {
-					return nil, fmt.Errorf("expanding home directory: %w", err)
-				}
-				skillPath = filepath.Join(home, skillPath[1:])
-			}
-
-			absPath, err := filepath.Abs(skillPath)
-			if err != nil {
-				return nil, fmt.Errorf("resolving skill path %q: %w", ref.Name, err)
-			}
-
-			// Check if this is a directory containing skills or a single skill
-			info, err := os.Stat(absPath)
-			if err != nil {
-				return nil, fmt.Errorf("skill path %q: %w", ref.Name, err)
-			}
-
-			if info.IsDir() {
-				// Check if it's a skill directory (has SKILL.md) or a parent of skill directories
-				skillMdPath := filepath.Join(absPath, skillFileName)
-				if _, err := os.Stat(skillMdPath); err == nil {
-					// Direct skill directory
-					skillDir = absPath
-				} else {
-					// Parent directory - walk to find skill subdirectories
-					err := filepath.WalkDir(absPath, func(path string, entry fs.DirEntry, walkErr error) error {
-						if walkErr != nil {
-							return walkErr
-						}
-						if entry.IsDir() {
-							return nil
-						}
-						if entry.Name() != skillFileName {
-							return nil
-						}
-
-						skillSubDir := filepath.Dir(path)
-						skill, err := parseSkillFile(path, skillSubDir)
-						if err != nil {
-							fmt.Fprintf(os.Stderr, "Warning: skipping skill at %s: %v\n", path, err)
-							return nil
-						}
-
-						if _, exists := byName[skill.Name]; exists {
-							fmt.Fprintf(os.Stderr, "Warning: duplicate skill name %q at %s\n", skill.Name, path)
-							return nil
-						}
-
-						byName[skill.Name] = skill
-						skills = append(skills, skill)
-						return nil
-					})
-					if err != nil {
-						return nil, err
-					}
-					continue
-				}
-			} else {
-				return nil, fmt.Errorf("skill path %q is not a directory", ref.Name)
-			}
-		} else {
-			// Both empty - skip
-			continue
-		}
-
-		// Parse the skill from skillDir if set
-		if skillDir != "" {
-			skillMdPath := filepath.Join(skillDir, skillFileName)
-			skill, err := parseSkillFile(skillMdPath, skillDir)
-			if err != nil {
-				return nil, fmt.Errorf("parsing skill at %s: %w", skillDir, err)
-			}
-
-			if _, exists := byName[skill.Name]; exists {
-				fmt.Fprintf(os.Stderr, "Warning: duplicate skill name %q\n", skill.Name)
-				continue
-			}
-
-			byName[skill.Name] = skill
-			skills = append(skills, skill)
-		}
-	}
-
-	if len(skills) == 0 {
-		return nil, nil
-	}
-
-	sort.Slice(skills, func(i, j int) bool {
-		return skills[i].Name < skills[j].Name
-	})
-
-	return &skillCatalog{Skills: skills, byName: byName}, nil
-}
-
-func parseSkillFile(path, skillDir string) (skillDefinition, error) {
-	rawContent, err := os.ReadFile(path)
-	if err != nil {
-		return skillDefinition{}, err
-	}
-
-	frontmatter, bodyContent, err := extractFrontmatterAndContent(string(rawContent))
-	if err != nil {
-		return skillDefinition{}, err
-	}
-
-	var meta skillMetadata
-	if err := yaml.Unmarshal([]byte(frontmatter), &meta); err != nil {
-		return skillDefinition{}, fmt.Errorf("invalid frontmatter: %w", err)
-	}
-
-	if err := validateSkillMetadata(meta, skillDir); err != nil {
-		return skillDefinition{}, err
-	}
-
-	absPath, err := filepath.Abs(path)
-	if err != nil {
-		return skillDefinition{}, err
-	}
-	absDir, err := filepath.Abs(skillDir)
-	if err != nil {
-		return skillDefinition{}, err
-	}
-
-	return skillDefinition{
-		Name:        meta.Name,
-		Description: meta.Description,
-		Content:     bodyContent,
-		Dir:         absDir,
-		SkillPath:   absPath,
-	}, nil
-}
-
-func extractFrontmatterAndContent(content string) (frontmatter string, body string, err error) {
-	scanner := bufio.NewScanner(strings.NewReader(content))
-	if !scanner.Scan() {
-		return "", "", errors.New("empty SKILL.md")
-	}
-	if strings.TrimSpace(scanner.Text()) != "---" {
-		return "", "", errors.New("missing YAML frontmatter")
-	}
-
-	var fmLines []string
-	foundEnd := false
-	for scanner.Scan() {
-		line := scanner.Text()
-		if strings.TrimSpace(line) == "---" {
-			foundEnd = true
-			break
-		}
-		fmLines = append(fmLines, line)
-	}
-	if !foundEnd {
-		return "", "", errors.New("frontmatter not terminated")
-	}
-
-	// Collect remaining content as body
-	var bodyLines []string
-	for scanner.Scan() {
-		bodyLines = append(bodyLines, scanner.Text())
-	}
-
-	return strings.Join(fmLines, "\n"), strings.TrimSpace(strings.Join(bodyLines, "\n")), nil
-}
-
-func validateSkillMetadata(meta skillMetadata, skillDir string) error {
-	name := strings.TrimSpace(meta.Name)
-	description := strings.TrimSpace(meta.Description)
-
-	switch {
-	case name == "":
-		return errors.New("missing skill name")
-	case len(name) > maxSkillNameLength:
-		return fmt.Errorf("skill name exceeds %d characters", maxSkillNameLength)
-	case !skillNamePattern.MatchString(name):
-		return fmt.Errorf("invalid skill name %q", name)
-	}
-
-	if description == "" {
-		return errors.New("missing skill description")
-	}
-	if len(description) > maxSkillDescription {
-		return fmt.Errorf("skill description exceeds %d characters", maxSkillDescription)
-	}
-
-	// Skip directory name check for digest-based paths (extracted from blobs)
-	dirName := filepath.Base(skillDir)
-	if !strings.HasPrefix(dirName, "sha256-") && dirName != name {
-		return fmt.Errorf("skill directory %q does not match name %q", dirName, name)
-	}
-
-	return nil
-}
-
-func (c *skillCatalog) SystemPrompt() string {
-	if c == nil || len(c.Skills) == 0 {
-		return ""
-	}
-
-	var b strings.Builder
-	b.WriteString("# Skills\n\n")
-	b.WriteString("You have the following skills loaded. Each skill provides instructions and may include executable scripts.\n\n")
-	b.WriteString("## Available Tools\n\n")
-	b.WriteString("- `run_skill_script`: Execute a script bundled with a skill. Use this when the skill instructions tell you to run a script.\n")
-	b.WriteString("- `read_skill_file`: Read additional files from a skill directory.\n\n")
-
-	for _, skill := range c.Skills {
-		fmt.Fprintf(&b, "## Skill: %s\n\n", skill.Name)
-		fmt.Fprintf(&b, "%s\n\n", skill.Content)
-		b.WriteString("---\n\n")
-	}
-
-	return b.String()
-}
-
-func (c *skillCatalog) Tools() api.Tools {
-	if c == nil || len(c.Skills) == 0 {
-		return nil
-	}
-
-	runScriptProps := api.NewToolPropertiesMap()
-	runScriptProps.Set("skill", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "The name of the skill containing the script",
-	})
-	runScriptProps.Set("command", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "The command to execute (e.g., 'python scripts/calculate.py 25 4' or './scripts/run.sh')",
-	})
-
-	readFileProps := api.NewToolPropertiesMap()
-	readFileProps.Set("skill", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "The name of the skill containing the file",
-	})
-	readFileProps.Set("path", api.ToolProperty{
-		Type:        api.PropertyType{"string"},
-		Description: "The relative path to the file within the skill directory",
-	})
-
-	return api.Tools{
-		{
-			Type: "function",
-			Function: api.ToolFunction{
-				Name:        "run_skill_script",
-				Description: "Execute a script or command within a skill's directory. Use this to run Python scripts, shell scripts, or other executables bundled with a skill.",
-				Parameters: api.ToolFunctionParameters{
-					Type:       "object",
-					Required:   []string{"skill", "command"},
-					Properties: runScriptProps,
-				},
-			},
-		},
-		{
-			Type: "function",
-			Function: api.ToolFunction{
-				Name:        "read_skill_file",
-				Description: "Read a file from a skill's directory. Use this to read additional documentation, reference files, or data files bundled with a skill.",
-				Parameters: api.ToolFunctionParameters{
-					Type:       "object",
-					Required:   []string{"skill", "path"},
-					Properties: readFileProps,
-				},
-			},
-		},
-	}
-}
-
-func (c *skillCatalog) RunToolCall(call api.ToolCall) (api.Message, bool, error) {
-	switch call.Function.Name {
-	case "read_skill_file":
-		skillName, err := requireStringArg(call.Function.Arguments, "skill")
-		if err != nil {
-			return toolMessage(call, err.Error()), true, nil
-		}
-		relPath, err := requireStringArg(call.Function.Arguments, "path")
-		if err != nil {
-			return toolMessage(call, err.Error()), true, nil
-		}
-		skill, ok := c.byName[skillName]
-		if !ok {
-			return toolMessage(call, fmt.Sprintf("unknown skill %q", skillName)), true, nil
-		}
-		content, err := readSkillFile(skill.Dir, relPath)
-		if err != nil {
-			return toolMessage(call, err.Error()), true, nil
-		}
-		return toolMessage(call, content), true, nil
-
-	case "run_skill_script":
-		skillName, err := requireStringArg(call.Function.Arguments, "skill")
-		if err != nil {
-			return toolMessage(call, err.Error()), true, nil
-		}
-		command, err := requireStringArg(call.Function.Arguments, "command")
-		if err != nil {
-			return toolMessage(call, err.Error()), true, nil
-		}
-		skill, ok := c.byName[skillName]
-		if !ok {
-			return toolMessage(call, fmt.Sprintf("unknown skill %q", skillName)), true, nil
-		}
-		output, err := runSkillScript(skill.Dir, command)
-		if err != nil {
-			return toolMessage(call, fmt.Sprintf("error: %v\noutput: %s", err, output)), true, nil
-		}
-		return toolMessage(call, output), true, nil
-
-	default:
-		return api.Message{}, false, nil
-	}
-}
-
-// runSkillScript executes a shell command within a skill's directory.
-//
-// SECURITY LIMITATIONS (TODO):
-//   - No sandboxing: commands run with full user permissions
-//   - No path validation: model can run any command, not just scripts in skill dir
-//   - Shell injection risk: sh -c is used, malicious input could be crafted
-//   - No executable allowlist: any program can be called (curl, rm, etc.)
-//   - No environment isolation: scripts inherit full environment variables
-//
-// POTENTIAL IMPROVEMENTS:
-//   - Restrict commands to only reference files within skill directory
-//   - Allowlist specific executables (python3, node, bash)
-//   - Use sandboxing (Docker, nsjail, seccomp)
-//   - Require explicit script registration in SKILL.md frontmatter
-//   - Add per-skill configurable timeouts
-func runSkillScript(skillDir, command string) (string, error) {
-	// Validate the skill directory exists
-	absSkillDir, err := filepath.Abs(skillDir)
-	if err != nil {
-		return "", err
-	}
-	if _, err := os.Stat(absSkillDir); err != nil {
-		return "", fmt.Errorf("skill directory not found: %w", err)
-	}
-
-	// Create command with timeout
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	cmd := exec.CommandContext(ctx, "sh", "-c", command)
-	cmd.Dir = absSkillDir
-
-	// Inject the current working directory (where ollama run was called from)
-	// as an environment variable so scripts can reference files in that directory
-	workingDir, err := os.Getwd()
-	if err != nil {
-		return "", fmt.Errorf("failed to get working directory: %w", err)
-	}
-	cmd.Env = append(os.Environ(), "OLLAMA_WORKING_DIR="+workingDir)
-
-	// Capture both stdout and stderr
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-
-	err = cmd.Run()
-
-	// Combine output
-	output := stdout.String()
-	if stderr.Len() > 0 {
-		if output != "" {
-			output += "\n"
-		}
-		output += stderr.String()
-	}
-
-	if err != nil {
-		if ctx.Err() == context.DeadlineExceeded {
-			return output, fmt.Errorf("command timed out after 30 seconds")
-		}
-		return output, err
-	}
-
-	return output, nil
-}
-
-func readSkillFile(skillDir, relPath string) (string, error) {
-	relPath = filepath.Clean(strings.TrimSpace(relPath))
-	if relPath == "" {
-		return "", errors.New("path is required")
-	}
-	if filepath.IsAbs(relPath) {
-		return "", errors.New("path must be relative to the skill directory")
-	}
-
-	target := filepath.Join(skillDir, relPath)
-	absTarget, err := filepath.Abs(target)
-	if err != nil {
-		return "", err
-	}
-	absSkillDir, err := filepath.Abs(skillDir)
-	if err != nil {
-		return "", err
-	}
-	rel, err := filepath.Rel(absSkillDir, absTarget)
-	if err != nil {
-		return "", err
-	}
-	if strings.HasPrefix(rel, "..") {
-		return "", errors.New("path escapes the skill directory")
-	}
-
-	content, err := os.ReadFile(absTarget)
-	if err != nil {
-		return "", fmt.Errorf("failed to read %q: %w", relPath, err)
-	}
-
-	return string(content), nil
-}
-
-func requireStringArg(args api.ToolCallFunctionArguments, name string) (string, error) {
-	value, ok := args.Get(name)
-	if !ok {
-		return "", fmt.Errorf("missing required argument %q", name)
-	}
-	str, ok := value.(string)
-	if !ok {
-		return "", fmt.Errorf("argument %q must be a string", name)
-	}
-	if strings.TrimSpace(str) == "" {
-		return "", fmt.Errorf("argument %q cannot be empty", name)
-	}
-	return str, nil
-}
-
-func toolMessage(call api.ToolCall, content string) api.Message {
-	msg := api.Message{
-		Role:     "tool",
-		Content:  content,
-		ToolName: call.Function.Name,
-	}
-	if call.ID != "" {
-		msg.ToolCallID = call.ID
-	}
-	return msg
-}

docs/skills.md

@@ -1,548 +0,0 @@
-# Ollama Skills
-
-Skills are reusable capability packages that extend what agents can do. They bundle instructions, scripts, and data that teach an agent how to perform specific tasks.
-
-## Quick Start
-
-### Creating a Skill
-
-Create a directory with a `SKILL.md` file:
-
-```
-my-skill/
-├── SKILL.md          # Required: Instructions for the agent
-└── scripts/          # Optional: Executable scripts
-    └── run.py
-```
-
-The `SKILL.md` file must have YAML frontmatter:
-
-```markdown
----
-name: my-skill
-description: A brief description of what this skill does
----
-
-# My Skill
-
-## Purpose
-Explain what this skill does and when to use it.
-
-## Instructions
-Step-by-step instructions for the agent on how to use this skill.
-
-## Examples
-Show example inputs and expected outputs.
-```
-
-### Using Skills in an Agent
-
-Reference skills in your Agentfile:
-
-```dockerfile
-FROM llama3.2:3b
-AGENT_TYPE conversational
-
-# Local skill (bundled with agent)
-SKILL ./path/to/my-skill
-
-# Registry skill (pulled from ollama.com)
-SKILL library/skill/calculator:1.0.0
-
-# User skill from registry
-SKILL myname/skill/calculator:1.0.0
-
-SYSTEM You are a helpful assistant.
-```
-
-### Managing Skills
-
-```bash
-# Push a skill to the registry (uses your namespace)
-ollama skill push myname/skill/calculator:1.0.0 ./my-skill
-
-# Pull a skill from the official library
-ollama skill pull skill/calculator:1.0.0
-
-# Pull a skill from a user's namespace
-ollama skill pull myname/skill/calculator:1.0.0
-
-# List installed skills
-ollama skill list
-
-# Show skill details
-ollama skill show skill/calculator:1.0.0
-
-# Remove a skill
-ollama skill rm skill/calculator:1.0.0
-```
-
-### Dynamic Skills in Chat
-
-You can add and remove skills dynamically during an interactive chat session:
-
-```
->>> /skills
-Available Skills:
-  calculator (sha256:abc123def456...)
-
->>> /skill add ./my-local-skill
-Added skill 'my-skill' from ./my-local-skill
-
->>> /skill list
-Skills loaded in this session:
-  my-skill (local: /path/to/my-local-skill)
-
->>> /skill remove my-skill
-Removed skill 'my-skill'
-```
-
-| Command | Description |
-|---------|-------------|
-| `/skills` | Show all available skills (model + session) |
-| `/skill add <path>` | Add a skill from a local path |
-| `/skill remove <name>` | Remove a skill by name |
-| `/skill list` | List skills loaded in this session |
-
-Dynamic skills take effect on the next message. This is useful for:
-- Testing skills during development
-- Temporarily adding capabilities to a model
-- Experimenting with skill combinations
-
-## Skill Reference Formats
-
-Skills use a 5-part name structure: `host/namespace/kind/model:tag`
-
-| Format | Example | Description |
-|--------|---------|-------------|
-| Local path | `./skills/calc` | Bundled with agent at create time |
-| Library skill | `skill/calculator:1.0.0` | From the official skill library (library/skill/calculator) |
-| User skill | `alice/skill/calc:1.0.0` | From a user's namespace |
-| Full path | `registry.ollama.ai/alice/skill/calc:1.0.0` | Fully qualified with host |
-
-The `kind` field distinguishes skills from models:
-- `skill` - Skill packages
-- `agent` - Agent packages (future)
-- (empty) - Regular models
-
-## SKILL.md Structure
-
-### Required Frontmatter
-
-```yaml
----
-name: skill-name        # Must match directory name
-description: Brief description of the skill
----
-```
-
-### Recommended Sections
-
-1. **Purpose**: What the skill does and when to use it
-2. **When to use**: Trigger conditions for the agent
-3. **Instructions**: Step-by-step usage guide
-4. **Examples**: Input/output examples
-5. **Scripts**: Documentation for any bundled scripts
-
-### Example: Calculator Skill
-
-```markdown
----
-name: calculator
-description: Performs mathematical calculations using Python
----
-
-# Calculator Skill
-
-## Purpose
-This skill performs mathematical calculations using a bundled Python script.
-
-## When to use
-- User asks to calculate something
-- User wants to do math operations
-- Any arithmetic is needed
-
-## Instructions
-1. When calculation is needed, use the `run_skill_script` tool
-2. Call: `python3 scripts/calculate.py "<expression>"`
-3. Return the result to the user
-
-## Examples
-
-**Input**: "What is 25 * 4?"
-**Action**: `run_skill_script` with command `python3 scripts/calculate.py '25 * 4'`
-**Output**: "25 * 4 = 100"
-```
-
-## Storage Layout
-
-```
-~/.ollama/models/
-├── blobs/
-│   └── sha256-<digest>           # Skill tar.gz blob
-├── manifests/
-│   └── registry.ollama.ai/
-│       └── skill/                # Library skills
-│           └── calculator/
-│               └── 1.0.0
-│       └── skill-username/       # User skills
-│           └── my-skill/
-│               └── latest
-└── skills/
-    └── sha256-<digest>/          # Extracted skill cache
-        ├── SKILL.md
-        └── scripts/
-```
-
----
-
-# Security Considerations
-
-## Current State (Development)
-
-The current implementation has several security considerations that need to be addressed before production use.
-
-### 1. Script Execution
-
-**Risk**: Skills can bundle arbitrary scripts that execute on the host system.
-
-**Current behavior**:
-- Scripts run with the same permissions as the Ollama process
-- No sandboxing or isolation
-- Full filesystem access
-
-**Mitigations needed**:
-- [ ] Sandbox script execution (containers, seccomp, etc.)
-- [ ] Resource limits (CPU, memory, time)
-- [ ] Filesystem isolation (read-only mounts, restricted paths)
-- [ ] Network policy controls
-- [ ] Capability dropping
-
-### 2. Skill Provenance
-
-**Risk**: Malicious skills could be pushed to the registry.
-
-**Current behavior**:
-- No code signing or verification
-- No malware scanning
-- Trust based on namespace ownership
-
-**Mitigations needed**:
-- [ ] Skill signing with author keys
-- [ ] Registry-side malware scanning
-- [ ] Content policy enforcement
-- [ ] Reputation system for skill authors
-
-### 3. Namespace Squatting
-
-**Risk**: Malicious actors could register skill names that impersonate official tools.
-
-**Current behavior**:
-- First-come-first-served namespace registration
-- No verification of skill names
-
-**Mitigations needed**:
-- [ ] Reserved namespace list (official tools, common names)
-- [ ] Trademark/name verification for popular skills
-- [ ] Clear namespacing conventions
-
-### 4. Supply Chain Attacks
-
-**Risk**: Compromised skills could inject malicious code into agents.
-
-**Current behavior**:
-- Skills pulled without integrity verification beyond digest
-- No dependency tracking
-
-**Mitigations needed**:
-- [ ] SBOM (Software Bill of Materials) for skills
-- [ ] Dependency vulnerability scanning
-- [ ] Pinned versions in Agentfiles
-- [ ] Audit logging of skill usage
-
-### 5. Data Exfiltration
-
-**Risk**: Skills could exfiltrate sensitive data from conversations or the host.
-
-**Current behavior**:
-- Skills have access to conversation context
-- Scripts can make network requests
-
-**Mitigations needed**:
-- [ ] Network egress controls
-- [ ] Sensitive data detection/masking
-- [ ] Audit logging of script network activity
-- [ ] User consent for data access
-
-### 6. Privilege Escalation
-
-**Risk**: Skills could escalate privileges through script execution.
-
-**Current behavior**:
-- Scripts inherit Ollama process privileges
-- No capability restrictions
-
-**Mitigations needed**:
-- [ ] Run scripts as unprivileged user
-- [ ] Drop all capabilities
-- [ ] Mandatory access controls (SELinux/AppArmor)
-
-## Recommended Security Model
-
-### Skill Trust Levels
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│ Level 0: Untrusted (default)                                │
-│ - No script execution                                       │
-│ - Instructions only                                         │
-│ - Safe for any skill                                        │
-├─────────────────────────────────────────────────────────────┤
-│ Level 1: Sandboxed                                          │
-│ - Scripts run in isolated container                         │
-│ - No network access                                         │
-│ - Read-only filesystem                                      │
-│ - Resource limits enforced                                  │
-├─────────────────────────────────────────────────────────────┤
-│ Level 2: Trusted                                            │
-│ - Scripts run with network access                           │
-│ - Can write to designated directories                       │
-│ - Requires explicit user approval                           │
-├─────────────────────────────────────────────────────────────┤
-│ Level 3: Privileged (admin only)                            │
-│ - Full host access                                          │
-│ - System administration skills                              │
-│ - Requires admin approval                                   │
-└─────────────────────────────────────────────────────────────┘
-```
-
-### Skill Manifest Security Fields (Future)
-
-```yaml
----
-name: my-skill
-description: A skill description
-security:
-  trust_level: sandboxed
-  permissions:
-    - network:read          # Can make HTTP GET requests
-    - filesystem:read:/data # Can read from /data
-  resource_limits:
-    max_memory: 256MB
-    max_cpu_time: 30s
-    max_disk: 100MB
-  signature: sha256:abc...  # Author signature
----
-```
-
----
-
-# Future Considerations
-
-## Feature Roadmap
-
-### Phase 1: Foundation (Current)
-- [x] Skill bundling with agents
-- [x] Local skill development
-- [x] Basic CLI commands (push, pull, list, rm, show)
-- [x] Registry blob storage
-- [ ] Registry namespace configuration
-
-### Phase 2: Security
-- [ ] Script sandboxing
-- [ ] Permission model
-- [ ] Skill signing
-- [ ] Audit logging
-
-### Phase 3: Discovery
-- [ ] Skill search on ollama.com
-- [ ] Skill ratings and reviews
-- [ ] Usage analytics
-- [ ] Featured/trending skills
-
-### Phase 4: Advanced Features
-- [ ] Skill dependencies
-- [ ] Skill versioning constraints
-- [ ] Skill composition (skills using skills)
-- [ ] Skill testing framework
-
-## Open Questions
-
-### 1. Skill Execution Model
-
-**Question**: How should skills execute scripts?
-
-Options:
-- **A) In-process**: Fast but unsafe
-- **B) Subprocess**: Current approach, moderate isolation
-- **C) Container**: Good isolation, requires container runtime
-- **D) WASM**: Portable and safe, limited capabilities
-- **E) Remote execution**: Offload to secure service
-
-### 2. Skill Versioning
-
-**Question**: How strict should version pinning be?
-
-Options:
-- **A) Always latest**: Simple but risky
-- **B) Semantic versioning**: `^1.0.0` allows minor updates
-- **C) Exact pinning**: `=1.0.0` requires explicit updates
-- **D) Digest pinning**: `@sha256:abc` immutable reference
-
-### 3. Skill Permissions
-
-**Question**: How should users grant permissions to skills?
-
-Options:
-- **A) All or nothing**: Accept all permissions or don't use
-- **B) Granular consent**: Approve each permission individually
-- **C) Trust levels**: Pre-defined permission bundles
-- **D) Runtime prompts**: Ask when permission is first used
-
-### 4. Skill Discovery
-
-**Question**: How should users find skills?
-
-Options:
-- **A) Central registry only**: ollama.com/skills
-- **B) Federated registries**: Multiple skill sources
-- **C) Git repositories**: Pull from GitHub, etc.
-- **D) All of the above**: Multiple discovery mechanisms
-
-### 5. Skill Monetization
-
-**Question**: Should skill authors be able to monetize?
-
-Options:
-- **A) Free only**: All skills are free and open
-- **B) Paid skills**: Authors can charge for skills
-- **C) Freemium**: Free tier with paid features
-- **D) Donations**: Voluntary support for authors
-
-### 6. Skill Updates
-
-**Question**: How should skill updates be handled?
-
-Options:
-- **A) Manual**: User explicitly updates
-- **B) Auto-update**: Always use latest
-- **C) Notify**: Alert user to available updates
-- **D) Policy-based**: Organization controls update policy
-
-## API Considerations
-
-### Skill Metadata API
-
-```
-GET /api/skills
-GET /api/skills/:namespace/:name
-GET /api/skills/:namespace/:name/versions
-GET /api/skills/:namespace/:name/readme
-```
-
-### Skill Execution API
-
-```
-POST /api/skills/:namespace/:name/execute
-{
-  "command": "python3 scripts/run.py",
-  "args": ["--input", "data"],
-  "timeout": 30
-}
-```
-
-### Skill Permissions API
-
-```
-GET /api/skills/:namespace/:name/permissions
-POST /api/skills/:namespace/:name/permissions/grant
-DELETE /api/skills/:namespace/:name/permissions/revoke
-```
-
-## Testing Considerations
-
-### Skill Testing Framework
-
-```bash
-# Run skill tests
-ollama skill test ./my-skill
-
-# Test with specific model
-ollama skill test ./my-skill --model llama3.2:3b
-
-# Generate test report
-ollama skill test ./my-skill --report
-```
-
-### Test File Format
-
-```yaml
-# my-skill/tests/test.yaml
-tests:
-  - name: "basic calculation"
-    input: "What is 2 + 2?"
-    expect:
-      contains: "4"
-      tool_called: "run_skill_script"
-
-  - name: "complex expression"
-    input: "Calculate 15% of 200"
-    expect:
-      contains: "30"
-```
-
-## Compatibility Considerations
-
-### Minimum Ollama Version
-
-Skills should declare minimum Ollama version:
-
-```yaml
----
-name: my-skill
-requires:
-  ollama: ">=0.4.0"
----
-```
-
-### Model Compatibility
-
-Skills may require specific model capabilities:
-
-```yaml
----
-name: vision-skill
-requires:
-  capabilities:
-    - vision
-    - tools
----
-```
-
-## Migration Path
-
-### From Local to Registry
-
-```bash
-# Develop locally
-SKILL ./my-skill
-
-# Push when ready
-ollama skill push myname/my-skill:1.0.0 ./my-skill
-
-# Update Agentfile
-SKILL skill/myname/my-skill:1.0.0
-```
-
-### Version Upgrades
-
-```bash
-# Check for updates
-ollama skill outdated
-
-# Update specific skill
-ollama skill update calculator:1.0.0
-
-# Update all skills
-ollama skill update --all
-```

envconfig/config.go

@@ -148,16 +148,6 @@ func Remotes() []string {
 	return r
 }
 
-// Skills returns the list of skill directories. Skills directories can be configured via the OLLAMA_SKILLS environment variable.
-// Returns empty slice if not configured.
-func Skills() []string {
-	raw := strings.TrimSpace(Var("OLLAMA_SKILLS"))
-	if raw == "" {
-		return []string{}
-	}
-	return strings.Split(raw, ",")
-}
-
 func BoolWithDefault(k string) func(defaultValue bool) bool {
 	return func(defaultValue bool) bool {
 		if s := Var(k); s != "" {
@@ -216,6 +206,8 @@ var (
 	UseAuth = Bool("OLLAMA_AUTH")
 	// Enable Vulkan backend
 	EnableVulkan = Bool("OLLAMA_VULKAN")
+	// Usage enables usage statistics reporting
+	Usage = Bool("OLLAMA_USAGE")
 )
 
 func String(s string) func() string {
@@ -327,9 +319,6 @@ func AsMap() map[string]EnvVar {
 		ret["OLLAMA_VULKAN"] = EnvVar{"OLLAMA_VULKAN", EnableVulkan(), "Enable experimental Vulkan support"}
 	}
 
-	// Skills configuration would go here when added
-	ret["OLLAMA_SKILLS"] = EnvVar{"OLLAMA_SKILLS", Skills(), "Comma-separated list of skill directories"}
-
 	return ret
 }
 

go.mod

@@ -87,5 +87,5 @@ require (
 	golang.org/x/term v0.36.0
 	golang.org/x/text v0.30.0
 	google.golang.org/protobuf v1.34.1
-	gopkg.in/yaml.v3 v3.0.1
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

parser/parser.go

@@ -4,7 +4,6 @@ import (
 	"bufio"
 	"bytes"
 	"crypto/sha256"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@@ -59,8 +58,6 @@ func (f Modelfile) CreateRequest(relativeDir string) (*api.CreateRequest, error)
 
 	var messages []api.Message
 	var licenses []string
-	var skills []api.SkillRef
-	var mcps []api.MCPRef
 	params := make(map[string]any)
 
 	for _, c := range f.Commands {
@@ -121,32 +118,6 @@ func (f Modelfile) CreateRequest(relativeDir string) (*api.CreateRequest, error)
 		case "message":
 			role, msg, _ := strings.Cut(c.Args, ": ")
 			messages = append(messages, api.Message{Role: role, Content: msg})
-		case "skill":
-			skillName := c.Args
-			// Expand local paths relative to the Agentfile directory
-			if isLocalPath(skillName) {
-				expanded, err := expandPath(skillName, relativeDir)
-				if err != nil {
-					return nil, fmt.Errorf("expanding skill path %q: %w", skillName, err)
-				}
-				skillName = expanded
-			}
-			skills = append(skills, api.SkillRef{Name: skillName})
-		case "mcp":
-			mcpRef, err := parseMCPArg(c.Args, relativeDir)
-			if err != nil {
-				return nil, fmt.Errorf("invalid MCP: %w", err)
-			}
-			mcps = append(mcps, mcpRef)
-		case "agent_type":
-			// Handle "AGENT TYPE conversational" -> strip "TYPE " prefix
-			args := c.Args
-			if strings.HasPrefix(strings.ToLower(args), "type ") {
-				args = strings.TrimSpace(args[5:])
-			}
-			req.AgentType = args
-		case "entrypoint":
-			req.Entrypoint = c.Args
 		default:
 			if slices.Contains(deprecatedParameters, c.Name) {
 				fmt.Printf("warning: parameter %s is deprecated\n", c.Name)
@@ -179,12 +150,6 @@ func (f Modelfile) CreateRequest(relativeDir string) (*api.CreateRequest, error)
 	if len(licenses) > 0 {
 		req.License = licenses
 	}
-	if len(skills) > 0 {
-		req.Skills = skills
-	}
-	if len(mcps) > 0 {
-		req.MCPs = mcps
-	}
 
 	return req, nil
 }
@@ -368,7 +333,7 @@ func (c Command) String() string {
 	switch c.Name {
 	case "model":
 		fmt.Fprintf(&sb, "FROM %s", c.Args)
-	case "license", "template", "system", "adapter", "renderer", "parser", "requires", "skill", "agent_type", "entrypoint":
+	case "license", "template", "system", "adapter", "renderer", "parser", "requires":
 		fmt.Fprintf(&sb, "%s %s", strings.ToUpper(c.Name), quote(c.Args))
 	case "message":
 		role, message, _ := strings.Cut(c.Args, ": ")
@@ -394,7 +359,7 @@ const (
 var (
 	errMissingFrom        = errors.New("no FROM line")
 	errInvalidMessageRole = errors.New("message role must be one of \"system\", \"user\", or \"assistant\"")
-	errInvalidCommand     = errors.New("command must be one of \"from\", \"license\", \"template\", \"system\", \"adapter\", \"renderer\", \"parser\", \"parameter\", \"message\", \"requires\", \"skill\", \"agent_type\", \"mcp\", or \"entrypoint\"")
+	errInvalidCommand     = errors.New("command must be one of \"from\", \"license\", \"template\", \"system\", \"adapter\", \"renderer\", \"parser\", \"parameter\", \"message\", or \"requires\"")
 )
 
 type ParserError struct {
@@ -458,9 +423,6 @@ func ParseFile(r io.Reader) (*Modelfile, error) {
 				switch s := strings.ToLower(b.String()); s {
 				case "from":
 					cmd.Name = "model"
-				case "agent":
-					// "AGENT TYPE" -> "agent_type", consume next word
-					cmd.Name = "agent_type"
 				case "parameter":
 					// transition to stateParameter which sets command name
 					next = stateParameter
@@ -538,10 +500,6 @@ func ParseFile(r io.Reader) (*Modelfile, error) {
 		if cmd.Name == "model" {
 			return &f, nil
 		}
-		// Allow entrypoint-only agents without FROM
-		if cmd.Name == "entrypoint" {
-			return &f, nil
-		}
 	}
 
 	return nil, errMissingFrom
@@ -560,7 +518,7 @@ func parseRuneForState(r rune, cs state) (state, rune, error) {
 		}
 	case stateName:
 		switch {
-		case isAlpha(r), r == '_':
+		case isAlpha(r):
 			return stateName, r, nil
 		case isSpace(r):
 			return stateValue, 0, nil
@@ -661,7 +619,7 @@ func isValidMessageRole(role string) bool {
 
 func isValidCommand(cmd string) bool {
 	switch strings.ToLower(cmd) {
-	case "from", "license", "template", "system", "adapter", "renderer", "parser", "parameter", "message", "requires", "skill", "agent_type", "agent", "mcp", "entrypoint":
+	case "from", "license", "template", "system", "adapter", "renderer", "parser", "parameter", "message", "requires":
 		return true
 	default:
 		return false
@@ -708,79 +666,3 @@ func expandPathImpl(path, relativeDir string, currentUserFunc func() (*user.User
 func expandPath(path, relativeDir string) (string, error) {
 	return expandPathImpl(path, relativeDir, user.Current, user.Lookup)
 }
-
-// parseMCPArg parses MCP command arguments.
-// Supports two formats:
-//
-//	JSON: {"name": "web-search", "command": "uv", "args": ["run", "./script.py"]}
-//	Simple: web-search uv run ./script.py (name, command, args...)
-func parseMCPArg(args string, relativeDir string) (api.MCPRef, error) {
-	args = strings.TrimSpace(args)
-	if args == "" {
-		return api.MCPRef{}, errors.New("MCP requires arguments")
-	}
-
-	// Try JSON format first
-	if strings.HasPrefix(args, "{") {
-		var ref api.MCPRef
-		if err := json.Unmarshal([]byte(args), &ref); err != nil {
-			return api.MCPRef{}, fmt.Errorf("invalid JSON: %w", err)
-		}
-		if ref.Name == "" {
-			return api.MCPRef{}, errors.New("MCP name is required")
-		}
-		if ref.Command == "" {
-			return api.MCPRef{}, errors.New("MCP command is required")
-		}
-		if ref.Type == "" {
-			ref.Type = "stdio"
-		}
-		// Expand relative paths in args
-		for i, arg := range ref.Args {
-			if isLocalPath(arg) {
-				expanded, err := expandPath(arg, relativeDir)
-				if err != nil {
-					return api.MCPRef{}, fmt.Errorf("expanding path %q: %w", arg, err)
-				}
-				ref.Args[i] = expanded
-			}
-		}
-		return ref, nil
-	}
-
-	// Simple format: name command args...
-	parts := strings.Fields(args)
-	if len(parts) < 2 {
-		return api.MCPRef{}, errors.New("MCP requires at least name and command")
-	}
-
-	ref := api.MCPRef{
-		Name:    parts[0],
-		Command: parts[1],
-		Type:    "stdio",
-	}
-	if len(parts) > 2 {
-		ref.Args = parts[2:]
-	}
-
-	// Expand relative paths in args
-	for i, arg := range ref.Args {
-		if isLocalPath(arg) {
-			expanded, err := expandPath(arg, relativeDir)
-			if err != nil {
-				return api.MCPRef{}, fmt.Errorf("expanding path %q: %w", arg, err)
-			}
-			ref.Args[i] = expanded
-		}
-	}
-
-	return ref, nil
-}
-
-// isLocalPath checks if a string looks like a local filesystem path.
-func isLocalPath(s string) bool {
-	return strings.HasPrefix(s, "/") ||
-		strings.HasPrefix(s, "./") ||
-		strings.HasPrefix(s, "../") ||
-		strings.HasPrefix(s, "~")
-}

readline/errors.go

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

readline/readline.go

@@ -206,6 +206,9 @@ func (i *Instance) Readline() (string, error) {
 			buf.DeleteBefore()
 		case CharCtrlL:
 			buf.ClearScreen()
+		case CharCtrlO:
+			// Ctrl+O - expand tool output
+			return "", ErrExpandOutput
 		case CharCtrlW:
 			buf.DeleteWord()
 		case CharCtrlZ:

readline/types.go

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

server/create.go

@@ -62,10 +62,6 @@ func (s *Server) CreateHandler(c *gin.Context) {
 	config.Renderer = r.Renderer
 	config.Parser = r.Parser
 	config.Requires = r.Requires
-	config.Skills = r.Skills
-	config.MCPs = r.MCPs
-	config.AgentType = r.AgentType
-	config.Entrypoint = r.Entrypoint
 
 	for v := range r.Files {
 		if !fs.ValidPath(v) {
@@ -125,10 +121,7 @@ func (s *Server) CreateHandler(c *gin.Context) {
 					ch <- gin.H{"error": err.Error()}
 				}
 
-				// Inherit config from base model (Renderer, Parser, Requires, Capabilities, etc.)
-				// This is especially important for cloud models which don't have GGUF files
-				// to detect capabilities from.
-				if err == nil && !remote {
+				if err == nil && !remote && (config.Renderer == "" || config.Parser == "" || config.Requires == "") {
 					manifest, mErr := ParseNamedManifest(fromName)
 					if mErr == nil && manifest.Config.Digest != "" {
 						configPath, pErr := GetBlobsPath(manifest.Config.Digest)
@@ -145,29 +138,6 @@ func (s *Server) CreateHandler(c *gin.Context) {
 									if config.Requires == "" {
 										config.Requires = baseConfig.Requires
 									}
-									// Inherit capabilities for cloud/remote models
-									// (local models detect capabilities from GGUF file)
-									if len(config.Capabilities) == 0 && len(baseConfig.Capabilities) > 0 {
-										config.Capabilities = baseConfig.Capabilities
-									}
-									// Inherit remote host/model if base is a cloud model
-									if config.RemoteHost == "" && baseConfig.RemoteHost != "" {
-										config.RemoteHost = baseConfig.RemoteHost
-									}
-									if config.RemoteModel == "" && baseConfig.RemoteModel != "" {
-										config.RemoteModel = baseConfig.RemoteModel
-									}
-									// Inherit model family for proper rendering
-									if config.ModelFamily == "" && baseConfig.ModelFamily != "" {
-										config.ModelFamily = baseConfig.ModelFamily
-									}
-									if len(config.ModelFamilies) == 0 && len(baseConfig.ModelFamilies) > 0 {
-										config.ModelFamilies = baseConfig.ModelFamilies
-									}
-									// Inherit context length for cloud models
-									if config.ContextLen == 0 && baseConfig.ContextLen > 0 {
-										config.ContextLen = baseConfig.ContextLen
-									}
 								}
 								cfgFile.Close()
 							}
@@ -187,9 +157,6 @@ func (s *Server) CreateHandler(c *gin.Context) {
 				ch <- gin.H{"error": err.Error()}
 				return
 			}
-		} else if r.Entrypoint != "" {
-			// Entrypoint-only agent: no base model needed
-			slog.Debug("create entrypoint-only agent", "entrypoint", r.Entrypoint)
 		} else {
 			ch <- gin.H{"error": errNeitherFromOrFiles.Error(), "status": http.StatusBadRequest}
 			return
@@ -576,18 +543,6 @@ func createModel(r api.CreateRequest, name model.Name, baseLayers []*layerGGML,
 		return err
 	}
 
-	// Handle skill layers for agents
-	layers, config.Skills, err = setSkillLayers(layers, config.Skills, fn)
-	if err != nil {
-		return err
-	}
-
-	// Handle MCP layers for agents
-	layers, config.MCPs, err = setMCPLayers(layers, config.MCPs, fn)
-	if err != nil {
-		return err
-	}
-
 	configLayer, err := createConfigLayer(layers, *config)
 	if err != nil {
 		return err
@@ -838,135 +793,6 @@ func setMessages(layers []Layer, m []api.Message) ([]Layer, error) {
 	return layers, nil
 }
 
-// setSkillLayers creates skill layers for local skill paths and updates the skill refs.
-// Local paths are converted to bundled skill layers with digests.
-// Registry references are kept as-is for later resolution during pull.
-func setSkillLayers(layers []Layer, skills []model.SkillRef, fn func(resp api.ProgressResponse)) ([]Layer, []model.SkillRef, error) {
-	if len(skills) == 0 {
-		return layers, skills, nil
-	}
-
-	// Remove any existing skill layers
-	layers = removeLayer(layers, MediaTypeSkill)
-
-	var updatedSkills []model.SkillRef
-
-	for _, skill := range skills {
-		// Check if this is a local path
-		if IsLocalSkillPath(skill.Name) {
-			// Expand home directory if needed
-			skillPath := skill.Name
-			if strings.HasPrefix(skillPath, "~") {
-				home, err := os.UserHomeDir()
-				if err != nil {
-					return nil, nil, fmt.Errorf("expanding home directory: %w", err)
-				}
-				skillPath = filepath.Join(home, skillPath[1:])
-			}
-
-			// Make absolute
-			absPath, err := filepath.Abs(skillPath)
-			if err != nil {
-				return nil, nil, fmt.Errorf("resolving skill path %q: %w", skill.Name, err)
-			}
-
-			// Check if this is a direct skill directory or a parent containing skills
-			skillMdPath := filepath.Join(absPath, "SKILL.md")
-			if _, err := os.Stat(skillMdPath); err == nil {
-				// Direct skill directory
-				fn(api.ProgressResponse{Status: fmt.Sprintf("packaging skill: %s", filepath.Base(absPath))})
-
-				layer, err := CreateSkillLayer(absPath)
-				if err != nil {
-					return nil, nil, fmt.Errorf("creating skill layer for %q: %w", skill.Name, err)
-				}
-
-				layers = append(layers, layer)
-				updatedSkills = append(updatedSkills, model.SkillRef{
-					Name:   filepath.Base(absPath),
-					Digest: layer.Digest,
-				})
-			} else {
-				// Parent directory - walk to find skill subdirectories
-				err := filepath.WalkDir(absPath, func(path string, entry fs.DirEntry, walkErr error) error {
-					if walkErr != nil {
-						return walkErr
-					}
-					if entry.IsDir() {
-						return nil
-					}
-					if entry.Name() != "SKILL.md" {
-						return nil
-					}
-
-					skillDir := filepath.Dir(path)
-					skillName := filepath.Base(skillDir)
-					fn(api.ProgressResponse{Status: fmt.Sprintf("packaging skill: %s", skillName)})
-
-					layer, err := CreateSkillLayer(skillDir)
-					if err != nil {
-						return fmt.Errorf("creating skill layer for %q: %w", skillDir, err)
-					}
-
-					layers = append(layers, layer)
-					updatedSkills = append(updatedSkills, model.SkillRef{
-						Name:   skillName,
-						Digest: layer.Digest,
-					})
-					return nil
-				})
-				if err != nil {
-					return nil, nil, fmt.Errorf("walking skill directory %q: %w", skill.Name, err)
-				}
-			}
-		} else if skill.Digest != "" {
-			// Already has a digest (from a pulled agent), keep as-is
-			updatedSkills = append(updatedSkills, skill)
-		} else {
-			// Registry reference - keep as-is for later resolution
-			updatedSkills = append(updatedSkills, skill)
-		}
-	}
-
-	return layers, updatedSkills, nil
-}
-
-// setMCPLayers handles MCP server references.
-// Currently, MCPs are stored as config data (command/args).
-// Future: support bundling MCP server directories as layers.
-func setMCPLayers(layers []Layer, mcps []model.MCPRef, fn func(resp api.ProgressResponse)) ([]Layer, []model.MCPRef, error) {
-	if len(mcps) == 0 {
-		return layers, mcps, nil
-	}
-
-	// Remove any existing MCP layers
-	layers = removeLayer(layers, MediaTypeMCP)
-
-	var updatedMCPs []model.MCPRef
-
-	for _, mcp := range mcps {
-		// Validate MCP has required fields
-		if mcp.Name == "" {
-			return nil, nil, fmt.Errorf("MCP server requires a name")
-		}
-		if mcp.Command == "" {
-			return nil, nil, fmt.Errorf("MCP server %q requires a command", mcp.Name)
-		}
-
-		// Set default type if not specified
-		if mcp.Type == "" {
-			mcp.Type = "stdio"
-		}
-
-		// For now, just keep MCPs as config data
-		// Future: detect local paths in args and bundle them
-		updatedMCPs = append(updatedMCPs, mcp)
-		fn(api.ProgressResponse{Status: fmt.Sprintf("configuring MCP: %s", mcp.Name)})
-	}
-
-	return layers, updatedMCPs, nil
-}
-
 func createConfigLayer(layers []Layer, config model.ConfigV2) (*Layer, error) {
 	digests := make([]string, len(layers))
 	for i, layer := range layers {

server/images.go

@@ -232,13 +232,6 @@ func (m *Model) String() string {
 		})
 	}
 
-	if m.Config.Entrypoint != "" {
-		modelfile.Commands = append(modelfile.Commands, parser.Command{
-			Name: "entrypoint",
-			Args: m.Config.Entrypoint,
-		})
-	}
-
 	for k, v := range m.Options {
 		switch v := v.(type) {
 		case []any:
@@ -664,16 +657,6 @@ func PullModel(ctx context.Context, name string, regOpts *registryOptions, fn fu
 		}
 	}
 
-	// Extract skill layers to the skills cache
-	for _, layer := range manifest.Layers {
-		if layer.MediaType == MediaTypeSkill {
-			fn(api.ProgressResponse{Status: fmt.Sprintf("extracting skill %s", layer.Digest)})
-			if _, err := ExtractSkillBlob(layer.Digest); err != nil {
-				return fmt.Errorf("extracting skill layer %s: %w", layer.Digest, err)
-			}
-		}
-	}
-
 	fn(api.ProgressResponse{Status: "writing manifest"})
 
 	manifestJSON, err := json.Marshal(manifest)

server/manifest.go

@@ -129,30 +129,11 @@ func Manifests(continueOnError bool) (map[model.Name]*Manifest, error) {
 		return nil, err
 	}
 
-	// Find both 4-part (models) and 5-part (skills/agents) manifest paths
-	matches4, err := filepath.Glob(filepath.Join(manifests, "*", "*", "*", "*"))
+	// TODO(mxyng): use something less brittle
+	matches, err := filepath.Glob(filepath.Join(manifests, "*", "*", "*", "*"))
 	if err != nil {
 		return nil, err
 	}
-	matches5, err := filepath.Glob(filepath.Join(manifests, "*", "*", "*", "*", "*"))
-	if err != nil {
-		return nil, err
-	}
-
-	// Combine matches, filtering to only include files
-	var matches []string
-	for _, match := range matches4 {
-		fi, err := os.Stat(match)
-		if err == nil && !fi.IsDir() {
-			matches = append(matches, match)
-		}
-	}
-	for _, match := range matches5 {
-		fi, err := os.Stat(match)
-		if err == nil && !fi.IsDir() {
-			matches = append(matches, match)
-		}
-	}
 
 	ms := make(map[model.Name]*Manifest)
 	for _, match := range matches {

server/mcp.go

@@ -1,315 +0,0 @@
-package server
-
-import (
-	"archive/tar"
-	"compress/gzip"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/ollama/ollama/envconfig"
-	"github.com/ollama/ollama/types/model"
-)
-
-// MediaTypeMCP is the media type for MCP server layers in manifests.
-const MediaTypeMCP = "application/vnd.ollama.image.mcp"
-
-// GetMCPsPath returns the path to the extracted MCPs cache directory.
-// If digest is empty, returns the mcps directory itself.
-// If digest is provided, returns the path to the extracted MCP for that digest.
-func GetMCPsPath(digest string) (string, error) {
-	// only accept actual sha256 digests
-	pattern := "^sha256[:-][0-9a-fA-F]{64}$"
-	re := regexp.MustCompile(pattern)
-
-	if digest != "" && !re.MatchString(digest) {
-		return "", ErrInvalidDigestFormat
-	}
-
-	digest = strings.ReplaceAll(digest, ":", "-")
-	path := filepath.Join(envconfig.Models(), "mcps", digest)
-	dirPath := filepath.Dir(path)
-	if digest == "" {
-		dirPath = path
-	}
-
-	if err := os.MkdirAll(dirPath, 0o755); err != nil {
-		return "", fmt.Errorf("%w: ensure path elements are traversable", err)
-	}
-
-	return path, nil
-}
-
-// ExtractMCPBlob extracts an MCP tar.gz blob to the mcps cache.
-// The blob is expected to be at the blobs path for the given digest.
-// Returns the path to the extracted MCP directory.
-func ExtractMCPBlob(digest string) (string, error) {
-	// Get the blob path
-	blobPath, err := GetBlobsPath(digest)
-	if err != nil {
-		return "", fmt.Errorf("getting blob path: %w", err)
-	}
-
-	// Get the extraction path
-	mcpPath, err := GetMCPsPath(digest)
-	if err != nil {
-		return "", fmt.Errorf("getting mcp path: %w", err)
-	}
-
-	// Check if already extracted (look for any file)
-	entries, err := os.ReadDir(mcpPath)
-	if err == nil && len(entries) > 0 {
-		return mcpPath, nil
-	}
-
-	// Open the blob
-	f, err := os.Open(blobPath)
-	if err != nil {
-		return "", fmt.Errorf("opening blob: %w", err)
-	}
-	defer f.Close()
-
-	// Create gzip reader
-	gzr, err := gzip.NewReader(f)
-	if err != nil {
-		return "", fmt.Errorf("creating gzip reader: %w", err)
-	}
-	defer gzr.Close()
-
-	// Create tar reader
-	tr := tar.NewReader(gzr)
-
-	// Create the mcp directory
-	if err := os.MkdirAll(mcpPath, 0o755); err != nil {
-		return "", fmt.Errorf("creating mcp directory: %w", err)
-	}
-
-	// Extract files
-	for {
-		header, err := tr.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return "", fmt.Errorf("reading tar: %w", err)
-		}
-
-		// Clean the name and ensure it doesn't escape the target directory
-		name := filepath.Clean(header.Name)
-		if strings.HasPrefix(name, "..") {
-			return "", fmt.Errorf("invalid path in archive: %s", header.Name)
-		}
-
-		target := filepath.Join(mcpPath, name)
-
-		// Verify the target is within mcpPath
-		if !strings.HasPrefix(target, filepath.Clean(mcpPath)+string(os.PathSeparator)) && target != filepath.Clean(mcpPath) {
-			return "", fmt.Errorf("path escapes mcp directory: %s", header.Name)
-		}
-
-		switch header.Typeflag {
-		case tar.TypeDir:
-			if err := os.MkdirAll(target, 0o755); err != nil {
-				return "", fmt.Errorf("creating directory: %w", err)
-			}
-		case tar.TypeReg:
-			// Ensure parent directory exists
-			if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
-				return "", fmt.Errorf("creating parent directory: %w", err)
-			}
-
-			outFile, err := os.OpenFile(target, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.FileMode(header.Mode))
-			if err != nil {
-				return "", fmt.Errorf("creating file: %w", err)
-			}
-
-			if _, err := io.Copy(outFile, tr); err != nil {
-				outFile.Close()
-				return "", fmt.Errorf("writing file: %w", err)
-			}
-			outFile.Close()
-		}
-	}
-
-	return mcpPath, nil
-}
-
-// CreateMCPLayer creates an MCP layer from a local directory.
-// The directory can optionally contain an mcp.json or package.json file.
-// Returns the created layer.
-func CreateMCPLayer(mcpDir string) (Layer, error) {
-	// Verify directory exists
-	info, err := os.Stat(mcpDir)
-	if err != nil {
-		return Layer{}, fmt.Errorf("mcp directory not found: %w", err)
-	}
-	if !info.IsDir() {
-		return Layer{}, fmt.Errorf("mcp path is not a directory: %s", mcpDir)
-	}
-
-	// Create a temporary file for the tar.gz
-	blobsPath, err := GetBlobsPath("")
-	if err != nil {
-		return Layer{}, fmt.Errorf("getting blobs path: %w", err)
-	}
-
-	tmpFile, err := os.CreateTemp(blobsPath, "mcp-*.tar.gz")
-	if err != nil {
-		return Layer{}, fmt.Errorf("creating temp file: %w", err)
-	}
-	tmpPath := tmpFile.Name()
-	defer func() {
-		tmpFile.Close()
-		os.Remove(tmpPath)
-	}()
-
-	// Create gzip writer
-	gzw := gzip.NewWriter(tmpFile)
-	defer gzw.Close()
-
-	// Create tar writer
-	tw := tar.NewWriter(gzw)
-	defer tw.Close()
-
-	// Walk the mcp directory and add files to tar
-	err = filepath.Walk(mcpDir, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-
-		// Get relative path
-		relPath, err := filepath.Rel(mcpDir, path)
-		if err != nil {
-			return err
-		}
-
-		// Skip the root directory itself
-		if relPath == "." {
-			return nil
-		}
-
-		// Create tar header
-		header, err := tar.FileInfoHeader(info, "")
-		if err != nil {
-			return err
-		}
-		header.Name = relPath
-
-		if err := tw.WriteHeader(header); err != nil {
-			return err
-		}
-
-		// Write file contents if it's a regular file
-		if !info.IsDir() {
-			f, err := os.Open(path)
-			if err != nil {
-				return err
-			}
-			defer f.Close()
-
-			if _, err := io.Copy(tw, f); err != nil {
-				return err
-			}
-		}
-
-		return nil
-	})
-	if err != nil {
-		return Layer{}, fmt.Errorf("creating tar archive: %w", err)
-	}
-
-	// Close writers to flush
-	if err := tw.Close(); err != nil {
-		return Layer{}, fmt.Errorf("closing tar writer: %w", err)
-	}
-	if err := gzw.Close(); err != nil {
-		return Layer{}, fmt.Errorf("closing gzip writer: %w", err)
-	}
-	if err := tmpFile.Close(); err != nil {
-		return Layer{}, fmt.Errorf("closing temp file: %w", err)
-	}
-
-	// Open the temp file for reading
-	tmpFile, err = os.Open(tmpPath)
-	if err != nil {
-		return Layer{}, fmt.Errorf("reopening temp file: %w", err)
-	}
-	defer tmpFile.Close()
-
-	// Create the layer (this will compute the digest and move to blobs)
-	layer, err := NewLayer(tmpFile, MediaTypeMCP)
-	if err != nil {
-		return Layer{}, fmt.Errorf("creating layer: %w", err)
-	}
-
-	// Extract the mcp to the cache so it's ready to use
-	if _, err := ExtractMCPBlob(layer.Digest); err != nil {
-		return Layer{}, fmt.Errorf("extracting mcp: %w", err)
-	}
-
-	return layer, nil
-}
-
-// IsLocalMCPPath checks if an MCP reference looks like a local path.
-// Local paths are explicitly prefixed with /, ./, ../, or ~.
-func IsLocalMCPPath(name string) bool {
-	return strings.HasPrefix(name, "/") ||
-		strings.HasPrefix(name, "./") ||
-		strings.HasPrefix(name, "../") ||
-		strings.HasPrefix(name, "~")
-}
-
-// MCPNamespace is the namespace used for standalone MCPs in the registry.
-const MCPNamespace = "mcp"
-
-// IsMCPReference checks if a name refers to an MCP (has mcp/ prefix).
-func IsMCPReference(name string) bool {
-	name = strings.ReplaceAll(name, string(os.PathSeparator), "/")
-	parts := strings.Split(name, "/")
-
-	// mcp/name or mcp/name:tag
-	if len(parts) >= 1 && parts[0] == MCPNamespace {
-		return true
-	}
-	// namespace/mcp/name (e.g., myuser/mcp/websearch)
-	if len(parts) >= 2 && parts[1] == MCPNamespace {
-		return true
-	}
-	return false
-}
-
-// ParseMCPName parses an MCP reference string into a model.Name.
-// The Kind field is set to "mcp".
-func ParseMCPName(name string) model.Name {
-	n := model.ParseName(name)
-
-	// If Kind wasn't set (old format without mcp/), set it
-	if n.Kind == "" {
-		n.Kind = MCPNamespace
-	}
-
-	return n
-}
-
-// GetMCPManifestPath returns the path to the MCP manifest file.
-func GetMCPManifestPath(n model.Name) (string, error) {
-	if n.Model == "" {
-		return "", fmt.Errorf("mcp name is required")
-	}
-
-	// Ensure Kind is set
-	if n.Kind == "" {
-		n.Kind = MCPNamespace
-	}
-
-	path := filepath.Join(
-		envconfig.Models(),
-		"manifests",
-		n.Filepath(),
-	)
-
-	return path, nil
-}

server/modelpath.go

@@ -18,7 +18,6 @@ type ModelPath struct {
 	ProtocolScheme string
 	Registry       string
 	Namespace      string
-	Kind           string // Optional: "skill", "agent", or empty for models
 	Repository     string
 	Tag            string
 }
@@ -43,7 +42,6 @@ func ParseModelPath(name string) ModelPath {
 		ProtocolScheme: DefaultProtocolScheme,
 		Registry:       DefaultRegistry,
 		Namespace:      DefaultNamespace,
-		Kind:           "",
 		Repository:     "",
 		Tag:            DefaultTag,
 	}
@@ -57,41 +55,13 @@ func ParseModelPath(name string) ModelPath {
 	name = strings.ReplaceAll(name, string(os.PathSeparator), "/")
 	parts := strings.Split(name, "/")
 	switch len(parts) {
-	case 4:
-		// host/namespace/kind/model or host/namespace/model:tag with kind
+	case 3:
 		mp.Registry = parts[0]
 		mp.Namespace = parts[1]
-		if model.ValidKinds[parts[2]] {
-			mp.Kind = parts[2]
-			mp.Repository = parts[3]
-		} else {
-			// Not a valid kind, treat as old format with extra part
-			mp.Repository = parts[3]
-		}
-	case 3:
-		// Could be: host/namespace/model OR namespace/kind/model
-		if model.ValidKinds[parts[1]] {
-			// namespace/kind/model
-			mp.Namespace = parts[0]
-			mp.Kind = parts[1]
-			mp.Repository = parts[2]
-		} else {
-			// host/namespace/model
-			mp.Registry = parts[0]
-			mp.Namespace = parts[1]
-			mp.Repository = parts[2]
-		}
+		mp.Repository = parts[2]
 	case 2:
-		// Could be: namespace/model OR kind/model
-		if model.ValidKinds[parts[0]] {
-			// kind/model (library skill)
-			mp.Kind = parts[0]
-			mp.Repository = parts[1]
-		} else {
-			// namespace/model
-			mp.Namespace = parts[0]
-			mp.Repository = parts[1]
-		}
+		mp.Namespace = parts[0]
+		mp.Repository = parts[1]
 	case 1:
 		mp.Repository = parts[0]
 	}
@@ -105,35 +75,20 @@ func ParseModelPath(name string) ModelPath {
 }
 
 func (mp ModelPath) GetNamespaceRepository() string {
-	if mp.Kind != "" {
-		return fmt.Sprintf("%s/%s/%s", mp.Namespace, mp.Kind, mp.Repository)
-	}
 	return fmt.Sprintf("%s/%s", mp.Namespace, mp.Repository)
 }
 
 func (mp ModelPath) GetFullTagname() string {
-	if mp.Kind != "" {
-		return fmt.Sprintf("%s/%s/%s/%s:%s", mp.Registry, mp.Namespace, mp.Kind, mp.Repository, mp.Tag)
-	}
 	return fmt.Sprintf("%s/%s/%s:%s", mp.Registry, mp.Namespace, mp.Repository, mp.Tag)
 }
 
 func (mp ModelPath) GetShortTagname() string {
 	if mp.Registry == DefaultRegistry {
 		if mp.Namespace == DefaultNamespace {
-			if mp.Kind != "" {
-				return fmt.Sprintf("%s/%s:%s", mp.Kind, mp.Repository, mp.Tag)
-			}
 			return fmt.Sprintf("%s:%s", mp.Repository, mp.Tag)
 		}
-		if mp.Kind != "" {
-			return fmt.Sprintf("%s/%s/%s:%s", mp.Namespace, mp.Kind, mp.Repository, mp.Tag)
-		}
 		return fmt.Sprintf("%s/%s:%s", mp.Namespace, mp.Repository, mp.Tag)
 	}
-	if mp.Kind != "" {
-		return fmt.Sprintf("%s/%s/%s/%s:%s", mp.Registry, mp.Namespace, mp.Kind, mp.Repository, mp.Tag)
-	}
 	return fmt.Sprintf("%s/%s/%s:%s", mp.Registry, mp.Namespace, mp.Repository, mp.Tag)
 }
 
@@ -142,7 +97,6 @@ func (mp ModelPath) GetManifestPath() (string, error) {
 	name := model.Name{
 		Host:      mp.Registry,
 		Namespace: mp.Namespace,
-		Kind:      mp.Kind,
 		Model:     mp.Repository,
 		Tag:       mp.Tag,
 	}

server/routes.go

@@ -20,6 +20,7 @@ import (
 	"net/url"
 	"os"
 	"os/signal"
+	"runtime"
 	"slices"
 	"strings"
 	"sync/atomic"
@@ -44,6 +45,7 @@ import (
 	"github.com/ollama/ollama/model/renderers"
 	"github.com/ollama/ollama/server/internal/client/ollama"
 	"github.com/ollama/ollama/server/internal/registry"
+	"github.com/ollama/ollama/server/usage"
 	"github.com/ollama/ollama/template"
 	"github.com/ollama/ollama/thinking"
 	"github.com/ollama/ollama/tools"
@@ -82,6 +84,7 @@ type Server struct {
 	addr    net.Addr
 	sched   *Scheduler
 	lowVRAM bool
+	stats *usage.Stats
 }
 
 func init() {
@@ -104,6 +107,30 @@ var (
 	errBadTemplate = errors.New("template error")
 )
 
+// usage records a request to usage stats if enabled.
+func (s *Server) usage(c *gin.Context, endpoint, model, architecture string, promptTokens, completionTokens int, usedTools bool) {
+	if s.stats == nil {
+		return
+	}
+	s.stats.Record(&usage.Request{
+		Endpoint:         endpoint,
+		Model:            model,
+		Architecture:     architecture,
+		APIType:          usage.ClassifyAPIType(c.Request.URL.Path),
+		PromptTokens:     promptTokens,
+		CompletionTokens: completionTokens,
+		UsedTools:        usedTools,
+	})
+}
+
+// usageError records a failed request to usage stats if enabled.
+func (s *Server) usageError() {
+	if s.stats == nil {
+		return
+	}
+	s.stats.RecordError()
+}
+
 func modelOptions(model *Model, requestOpts map[string]any) (api.Options, error) {
 	opts := api.DefaultOptions()
 	if err := opts.FromMap(model.Options); err != nil {
@@ -374,7 +401,7 @@ func (s *Server) GenerateHandler(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("%q does not support generate", req.Model)})
 		return
 	} else if err != nil {
-		handleScheduleError(c, req.Model, err)
+		s.handleScheduleError(c, req.Model, err)
 		return
 	}
 
@@ -561,6 +588,7 @@ func (s *Server) GenerateHandler(c *gin.Context) {
 				res.DoneReason = cr.DoneReason.String()
 				res.TotalDuration = time.Since(checkpointStart)
 				res.LoadDuration = checkpointLoaded.Sub(checkpointStart)
+				s.usage(c, "generate", m.ShortName, m.Config.ModelFamily, cr.PromptEvalCount, cr.EvalCount, false)
 
 				if !req.Raw {
 					tokens, err := r.Tokenize(c.Request.Context(), prompt+sb.String())
@@ -680,7 +708,7 @@ func (s *Server) EmbedHandler(c *gin.Context) {
 
 	r, m, opts, err := s.scheduleRunner(c.Request.Context(), name.String(), []model.Capability{}, req.Options, req.KeepAlive)
 	if err != nil {
-		handleScheduleError(c, req.Model, err)
+		s.handleScheduleError(c, req.Model, err)
 		return
 	}
 
@@ -790,6 +818,7 @@ func (s *Server) EmbedHandler(c *gin.Context) {
 		LoadDuration:    checkpointLoaded.Sub(checkpointStart),
 		PromptEvalCount: int(totalTokens),
 	}
+	s.usage(c, "embed", m.ShortName, m.Config.ModelFamily, int(totalTokens), 0, false)
 	c.JSON(http.StatusOK, resp)
 }
 
@@ -827,7 +856,7 @@ func (s *Server) EmbeddingsHandler(c *gin.Context) {
 
 	r, _, _, err := s.scheduleRunner(c.Request.Context(), name.String(), []model.Capability{}, req.Options, req.KeepAlive)
 	if err != nil {
-		handleScheduleError(c, req.Model, err)
+		s.handleScheduleError(c, req.Model, err)
 		return
 	}
 
@@ -978,9 +1007,6 @@ func getExistingName(n model.Name) (model.Name, error) {
 		if set.Namespace == "" && strings.EqualFold(e.Namespace, n.Namespace) {
 			n.Namespace = e.Namespace
 		}
-		if set.Kind == "" && strings.EqualFold(e.Kind, n.Kind) {
-			n.Kind = e.Kind
-		}
 		if set.Model == "" && strings.EqualFold(e.Model, n.Model) {
 			n.Model = e.Model
 		}
@@ -1119,10 +1145,6 @@ func GetModelInfo(req api.ShowRequest) (*api.ShowResponse, error) {
 		Capabilities: m.Capabilities(),
 		ModifiedAt:   manifest.fi.ModTime(),
 		Requires:     m.Config.Requires,
-		Skills:       m.Config.Skills,
-		MCPs:         m.Config.MCPs,
-		AgentType:    m.Config.AgentType,
-		Entrypoint:   m.Config.Entrypoint,
 	}
 
 	if m.Config.RemoteHost != "" {
@@ -1177,16 +1199,11 @@ func GetModelInfo(req api.ShowRequest) (*api.ShowResponse, error) {
 	fmt.Fprint(&sb, m.String())
 	resp.Modelfile = sb.String()
 
-	// skip loading tensor information if this is a remote model or a skill
+	// skip loading tensor information if this is a remote model
 	if m.Config.RemoteHost != "" && m.Config.RemoteModel != "" {
 		return resp, nil
 	}
 
-	// Skills don't have model weights, skip tensor loading
-	if m.ModelPath == "" {
-		return resp, nil
-	}
-
 	kvData, tensors, err := getModelData(m.ModelPath, req.Verbose)
 	if err != nil {
 		return nil, err
@@ -1543,6 +1560,7 @@ func (s *Server) GenerateRoutes(rc *ollama.Registry) (http.Handler, error) {
 
 	// Inference
 	r.GET("/api/ps", s.PsHandler)
+	r.GET("/api/usage", s.UsageHandler)
 	r.POST("/api/generate", s.GenerateHandler)
 	r.POST("/api/chat", s.ChatHandler)
 	r.POST("/api/embed", s.EmbedHandler)
@@ -1605,6 +1623,13 @@ func Serve(ln net.Listener) error {
 
 	s := &Server{addr: ln.Addr()}
 
+	// Initialize usage stats if enabled
+	if envconfig.Usage() {
+		s.stats = usage.New()
+		s.stats.Start()
+		slog.Info("usage stats enabled")
+	}
+
 	var rc *ollama.Registry
 	if useClient2 {
 		var err error
@@ -1644,6 +1669,9 @@ func Serve(ln net.Listener) error {
 	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
 	go func() {
 		<-signals
+		if s.stats != nil {
+			s.stats.Stop()
+		}
 		srvr.Close()
 		schedDone()
 		sched.unloadAllRunners()
@@ -1661,6 +1689,24 @@ func Serve(ln net.Listener) error {
 	gpus := discover.GPUDevices(ctx, nil)
 	discover.LogDetails(gpus)
 
+	// Set GPU info for usage reporting
+	if s.stats != nil {
+		usage.GPUInfoFunc = func() []usage.GPU {
+			var result []usage.GPU
+			for _, gpu := range gpus {
+				result = append(result, usage.GPU{
+					Name:         gpu.Name,
+					VRAMBytes:    gpu.TotalMemory,
+					ComputeMajor: gpu.ComputeMajor,
+					ComputeMinor: gpu.ComputeMinor,
+					DriverMajor:  gpu.DriverMajor,
+					DriverMinor:  gpu.DriverMinor,
+				})
+			}
+			return result
+		}
+	}
+
 	var totalVRAM uint64
 	for _, gpu := range gpus {
 		totalVRAM += gpu.TotalMemory - envconfig.GpuOverhead()
@@ -1864,6 +1910,63 @@ func (s *Server) PsHandler(c *gin.Context) {
 	c.JSON(http.StatusOK, api.ProcessResponse{Models: models})
 }
 
+func (s *Server) UsageHandler(c *gin.Context) {
+	// Get total VRAM used by Ollama
+	s.sched.loadedMu.Lock()
+	var totalOllamaVRAM uint64
+	for _, runner := range s.sched.loaded {
+		totalOllamaVRAM += runner.vramSize
+	}
+	s.sched.loadedMu.Unlock()
+
+	var resp api.UsageResponse
+
+	// Get GPU/device info
+	gpus := discover.GPUDevices(c.Request.Context(), nil)
+
+	// On Apple Silicon, use system memory instead of Metal's recommendedMaxWorkingSetSize
+	// because unified memory means GPU and CPU share the same physical RAM pool
+	var sysTotal, sysFree uint64
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		sysInfo := discover.GetSystemInfo()
+		sysTotal = sysInfo.TotalMemory
+		sysFree = sysInfo.FreeMemory
+	}
+
+	for _, gpu := range gpus {
+		total := gpu.TotalMemory
+		free := gpu.FreeMemory
+
+		// On Apple Silicon, override with system memory values
+		if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && sysTotal > 0 {
+			total = sysTotal
+			free = sysFree
+		}
+
+		used := total - free
+		ollamaUsed := min(totalOllamaVRAM, used)
+		otherUsed := used - ollamaUsed
+
+		// Use Description for Name (actual device name like "Apple M2 Max")
+		// Fall back to backend name if Description is empty
+		name := gpu.Description
+		if name == "" {
+			name = gpu.Name
+		}
+
+		resp.GPUs = append(resp.GPUs, api.GPUUsage{
+			Name:    name,
+			Backend: gpu.Library,
+			Total:   total,
+			Free:    free,
+			Used:    ollamaUsed,
+			Other:   otherUsed,
+		})
+	}
+
+	c.JSON(http.StatusOK, resp)
+}
+
 func toolCallId() string {
 	const letterBytes = "abcdefghijklmnopqrstuvwxyz0123456789"
 	b := make([]byte, 8)
@@ -2044,7 +2147,7 @@ func (s *Server) ChatHandler(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("%q does not support chat", req.Model)})
 		return
 	} else if err != nil {
-		handleScheduleError(c, req.Model, err)
+		s.handleScheduleError(c, req.Model, err)
 		return
 	}
 
@@ -2192,6 +2295,7 @@ func (s *Server) ChatHandler(c *gin.Context) {
 					res.DoneReason = r.DoneReason.String()
 					res.TotalDuration = time.Since(checkpointStart)
 					res.LoadDuration = checkpointLoaded.Sub(checkpointStart)
+					s.usage(c, "chat", m.ShortName, m.Config.ModelFamily, r.PromptEvalCount, r.EvalCount, len(req.Tools) > 0)
 				}
 
 				if builtinParser != nil {
@@ -2367,6 +2471,7 @@ func (s *Server) ChatHandler(c *gin.Context) {
 			resp.Message.ToolCalls = toolCalls
 		}
 
+		s.usage(c, "chat", m.ShortName, m.Config.ModelFamily, resp.PromptEvalCount, resp.EvalCount, len(toolCalls) > 0)
 		c.JSON(http.StatusOK, resp)
 		return
 	}
@@ -2374,7 +2479,8 @@ func (s *Server) ChatHandler(c *gin.Context) {
 	streamResponse(c, ch)
 }
 
-func handleScheduleError(c *gin.Context, name string, err error) {
+func (s *Server) handleScheduleError(c *gin.Context, name string, err error) {
+	s.usageError()
 	switch {
 	case errors.Is(err, errCapabilities), errors.Is(err, errRequired):
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})

server/routes_usage_test.go

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

server/skill.go

@@ -1,326 +0,0 @@
-package server
-
-import (
-	"archive/tar"
-	"compress/gzip"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/ollama/ollama/envconfig"
-	"github.com/ollama/ollama/types/model"
-)
-
-// MediaTypeSkill is the media type for skill layers in manifests.
-const MediaTypeSkill = "application/vnd.ollama.image.skill"
-
-// GetSkillsPath returns the path to the extracted skills cache directory.
-// If digest is empty, returns the skills directory itself.
-// If digest is provided, returns the path to the extracted skill for that digest.
-func GetSkillsPath(digest string) (string, error) {
-	// only accept actual sha256 digests
-	pattern := "^sha256[:-][0-9a-fA-F]{64}$"
-	re := regexp.MustCompile(pattern)
-
-	if digest != "" && !re.MatchString(digest) {
-		return "", ErrInvalidDigestFormat
-	}
-
-	digest = strings.ReplaceAll(digest, ":", "-")
-	path := filepath.Join(envconfig.Models(), "skills", digest)
-	dirPath := filepath.Dir(path)
-	if digest == "" {
-		dirPath = path
-	}
-
-	if err := os.MkdirAll(dirPath, 0o755); err != nil {
-		return "", fmt.Errorf("%w: ensure path elements are traversable", err)
-	}
-
-	return path, nil
-}
-
-// ExtractSkillBlob extracts a skill tar.gz blob to the skills cache.
-// The blob is expected to be at the blobs path for the given digest.
-// Returns the path to the extracted skill directory.
-func ExtractSkillBlob(digest string) (string, error) {
-	// Get the blob path
-	blobPath, err := GetBlobsPath(digest)
-	if err != nil {
-		return "", fmt.Errorf("getting blob path: %w", err)
-	}
-
-	// Get the extraction path
-	skillPath, err := GetSkillsPath(digest)
-	if err != nil {
-		return "", fmt.Errorf("getting skill path: %w", err)
-	}
-
-	// Check if already extracted
-	if _, err := os.Stat(filepath.Join(skillPath, "SKILL.md")); err == nil {
-		return skillPath, nil
-	}
-
-	// Open the blob
-	f, err := os.Open(blobPath)
-	if err != nil {
-		return "", fmt.Errorf("opening blob: %w", err)
-	}
-	defer f.Close()
-
-	// Create gzip reader
-	gzr, err := gzip.NewReader(f)
-	if err != nil {
-		return "", fmt.Errorf("creating gzip reader: %w", err)
-	}
-	defer gzr.Close()
-
-	// Create tar reader
-	tr := tar.NewReader(gzr)
-
-	// Create the skill directory
-	if err := os.MkdirAll(skillPath, 0o755); err != nil {
-		return "", fmt.Errorf("creating skill directory: %w", err)
-	}
-
-	// Extract files
-	for {
-		header, err := tr.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return "", fmt.Errorf("reading tar: %w", err)
-		}
-
-		// Clean the name and ensure it doesn't escape the target directory
-		name := filepath.Clean(header.Name)
-		if strings.HasPrefix(name, "..") {
-			return "", fmt.Errorf("invalid path in archive: %s", header.Name)
-		}
-
-		target := filepath.Join(skillPath, name)
-
-		// Verify the target is within skillPath
-		if !strings.HasPrefix(target, filepath.Clean(skillPath)+string(os.PathSeparator)) && target != filepath.Clean(skillPath) {
-			return "", fmt.Errorf("path escapes skill directory: %s", header.Name)
-		}
-
-		switch header.Typeflag {
-		case tar.TypeDir:
-			if err := os.MkdirAll(target, 0o755); err != nil {
-				return "", fmt.Errorf("creating directory: %w", err)
-			}
-		case tar.TypeReg:
-			// Ensure parent directory exists
-			if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
-				return "", fmt.Errorf("creating parent directory: %w", err)
-			}
-
-			outFile, err := os.OpenFile(target, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.FileMode(header.Mode))
-			if err != nil {
-				return "", fmt.Errorf("creating file: %w", err)
-			}
-
-			if _, err := io.Copy(outFile, tr); err != nil {
-				outFile.Close()
-				return "", fmt.Errorf("writing file: %w", err)
-			}
-			outFile.Close()
-		}
-	}
-
-	return skillPath, nil
-}
-
-// CreateSkillLayer creates a skill layer from a local directory.
-// The directory must contain a SKILL.md file.
-// Returns the created layer.
-func CreateSkillLayer(skillDir string) (Layer, error) {
-	// Verify SKILL.md exists
-	skillMdPath := filepath.Join(skillDir, "SKILL.md")
-	if _, err := os.Stat(skillMdPath); err != nil {
-		return Layer{}, fmt.Errorf("skill directory must contain SKILL.md: %w", err)
-	}
-
-	// Create a temporary file for the tar.gz
-	blobsPath, err := GetBlobsPath("")
-	if err != nil {
-		return Layer{}, fmt.Errorf("getting blobs path: %w", err)
-	}
-
-	tmpFile, err := os.CreateTemp(blobsPath, "skill-*.tar.gz")
-	if err != nil {
-		return Layer{}, fmt.Errorf("creating temp file: %w", err)
-	}
-	tmpPath := tmpFile.Name()
-	defer func() {
-		tmpFile.Close()
-		os.Remove(tmpPath)
-	}()
-
-	// Create gzip writer
-	gzw := gzip.NewWriter(tmpFile)
-	defer gzw.Close()
-
-	// Create tar writer
-	tw := tar.NewWriter(gzw)
-	defer tw.Close()
-
-	// Walk the skill directory and add files to tar
-	err = filepath.Walk(skillDir, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-
-		// Get relative path
-		relPath, err := filepath.Rel(skillDir, path)
-		if err != nil {
-			return err
-		}
-
-		// Skip the root directory itself
-		if relPath == "." {
-			return nil
-		}
-
-		// Create tar header
-		header, err := tar.FileInfoHeader(info, "")
-		if err != nil {
-			return err
-		}
-		header.Name = relPath
-
-		if err := tw.WriteHeader(header); err != nil {
-			return err
-		}
-
-		// Write file contents if it's a regular file
-		if !info.IsDir() {
-			f, err := os.Open(path)
-			if err != nil {
-				return err
-			}
-			defer f.Close()
-
-			if _, err := io.Copy(tw, f); err != nil {
-				return err
-			}
-		}
-
-		return nil
-	})
-	if err != nil {
-		return Layer{}, fmt.Errorf("creating tar archive: %w", err)
-	}
-
-	// Close writers to flush
-	if err := tw.Close(); err != nil {
-		return Layer{}, fmt.Errorf("closing tar writer: %w", err)
-	}
-	if err := gzw.Close(); err != nil {
-		return Layer{}, fmt.Errorf("closing gzip writer: %w", err)
-	}
-	if err := tmpFile.Close(); err != nil {
-		return Layer{}, fmt.Errorf("closing temp file: %w", err)
-	}
-
-	// Open the temp file for reading
-	tmpFile, err = os.Open(tmpPath)
-	if err != nil {
-		return Layer{}, fmt.Errorf("reopening temp file: %w", err)
-	}
-	defer tmpFile.Close()
-
-	// Create the layer (this will compute the digest and move to blobs)
-	layer, err := NewLayer(tmpFile, MediaTypeSkill)
-	if err != nil {
-		return Layer{}, fmt.Errorf("creating layer: %w", err)
-	}
-
-	// Extract the skill to the cache so it's ready to use
-	if _, err := ExtractSkillBlob(layer.Digest); err != nil {
-		return Layer{}, fmt.Errorf("extracting skill: %w", err)
-	}
-
-	return layer, nil
-}
-
-// IsLocalSkillPath checks if a skill reference looks like a local path.
-// Local paths are explicitly prefixed with /, ./, ../, or ~.
-// Registry references like "skill/calculator:1.0.0" should NOT be treated as local paths.
-func IsLocalSkillPath(name string) bool {
-	// Local paths are explicitly indicated by path prefixes
-	return strings.HasPrefix(name, "/") ||
-		strings.HasPrefix(name, "./") ||
-		strings.HasPrefix(name, "../") ||
-		strings.HasPrefix(name, "~")
-}
-
-// SkillNamespace is the namespace used for standalone skills in the registry.
-const SkillNamespace = "skill"
-
-// IsSkillReference checks if a name refers to a skill (has skill/ prefix).
-func IsSkillReference(name string) bool {
-	// Check for skill/ prefix (handles both "skill/foo" and "registry/skill/foo")
-	name = strings.ReplaceAll(name, string(os.PathSeparator), "/")
-	parts := strings.Split(name, "/")
-
-	// skill/name or skill/name:tag
-	if len(parts) >= 1 && parts[0] == SkillNamespace {
-		return true
-	}
-	// namespace/skill/name (e.g., myuser/skill/calc) - not a skill ref
-	// registry/skill/name (e.g., registry.ollama.ai/skill/calc)
-	if len(parts) >= 2 && parts[1] == SkillNamespace {
-		return true
-	}
-	return false
-}
-
-// ParseSkillName parses a skill reference string into a model.Name.
-// The Kind field is set to "skill".
-// Examples:
-//   - "calculator" -> library/skill/calculator:latest
-//   - "myname/calculator" -> myname/skill/calculator:latest
-//   - "myname/skill/calculator:1.0.0" -> myname/skill/calculator:1.0.0
-func ParseSkillName(name string) model.Name {
-	// Use the standard parser which now handles Kind
-	n := model.ParseName(name)
-
-	// If Kind wasn't set (old format without skill/), set it
-	if n.Kind == "" {
-		n.Kind = SkillNamespace
-	}
-
-	return n
-}
-
-// SkillDisplayName returns a user-friendly display name for a skill.
-func SkillDisplayName(n model.Name) string {
-	return n.DisplayShortest()
-}
-
-// GetSkillManifestPath returns the path to the skill manifest file.
-// Uses the 5-part structure: host/namespace/kind/model/tag
-func GetSkillManifestPath(n model.Name) (string, error) {
-	if n.Model == "" {
-		return "", fmt.Errorf("skill name is required")
-	}
-
-	// Ensure Kind is set
-	if n.Kind == "" {
-		n.Kind = SkillNamespace
-	}
-
-	path := filepath.Join(
-		envconfig.Models(),
-		"manifests",
-		n.Filepath(),
-	)
-
-	return path, nil
-}

server/usage/reporter.go

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

server/usage/source.go

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

server/usage/usage.go

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

server/usage/usage_test.go

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

template/template.go

@@ -381,6 +381,28 @@ func (t templateTools) String() string {
 	return string(bts)
 }
 
+// templateArgs is a map type with JSON string output for templates.
+type templateArgs map[string]any
+
+func (t templateArgs) String() string {
+	if t == nil {
+		return "{}"
+	}
+	bts, _ := json.Marshal(t)
+	return string(bts)
+}
+
+// templateProperties is a map type with JSON string output for templates.
+type templateProperties map[string]api.ToolProperty
+
+func (t templateProperties) String() string {
+	if t == nil {
+		return "{}"
+	}
+	bts, _ := json.Marshal(t)
+	return string(bts)
+}
+
 // templateTool is a template-compatible representation of api.Tool
 // with Properties as a regular map for template ranging.
 type templateTool struct {
@@ -396,11 +418,11 @@ type templateToolFunction struct {
 }
 
 type templateToolFunctionParameters struct {
-	Type       string                      `json:"type"`
-	Defs       any                         `json:"$defs,omitempty"`
-	Items      any                         `json:"items,omitempty"`
-	Required   []string                    `json:"required,omitempty"`
-	Properties map[string]api.ToolProperty `json:"properties"`
+	Type       string             `json:"type"`
+	Defs       any                `json:"$defs,omitempty"`
+	Items      any                `json:"items,omitempty"`
+	Required   []string           `json:"required,omitempty"`
+	Properties templateProperties `json:"properties"`
 }
 
 // templateToolCall is a template-compatible representation of api.ToolCall
@@ -413,7 +435,7 @@ type templateToolCall struct {
 type templateToolCallFunction struct {
 	Index     int
 	Name      string
-	Arguments map[string]any
+	Arguments templateArgs
 }
 
 // templateMessage is a template-compatible representation of api.Message
@@ -446,7 +468,7 @@ func convertToolsForTemplate(tools api.Tools) templateTools {
 					Defs:       tool.Function.Parameters.Defs,
 					Items:      tool.Function.Parameters.Items,
 					Required:   tool.Function.Parameters.Required,
-					Properties: tool.Function.Parameters.Properties.ToMap(),
+					Properties: templateProperties(tool.Function.Parameters.Properties.ToMap()),
 				},
 			},
 		}
@@ -468,7 +490,7 @@ func convertMessagesForTemplate(messages []*api.Message) []*templateMessage {
 				Function: templateToolCallFunction{
 					Index:     tc.Function.Index,
 					Name:      tc.Function.Name,
-					Arguments: tc.Function.Arguments.ToMap(),
+					Arguments: templateArgs(tc.Function.Arguments.ToMap()),
 				},
 			})
 		}

template/template_test.go

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

types/model/config.go

@@ -1,29 +1,5 @@
 package model
 
-// SkillRef represents a reference to a skill, either by local path or by registry digest.
-type SkillRef struct {
-	// Name is the local path (for development) or registry name (e.g., "skill/calculator:1.0.0")
-	Name string `json:"name,omitempty"`
-	// Digest is the content-addressable digest of the skill blob (e.g., "sha256:abc123...")
-	Digest string `json:"digest,omitempty"`
-}
-
-// MCPRef represents a reference to an MCP (Model Context Protocol) server.
-type MCPRef struct {
-	// Name is the identifier for the MCP server (used for tool namespacing)
-	Name string `json:"name,omitempty"`
-	// Digest is the content-addressable digest of the bundled MCP server blob
-	Digest string `json:"digest,omitempty"`
-	// Command is the executable to run (e.g., "uv", "node", "python3")
-	Command string `json:"command,omitempty"`
-	// Args are the arguments to pass to the command
-	Args []string `json:"args,omitempty"`
-	// Env is optional environment variables for the MCP server
-	Env map[string]string `json:"env,omitempty"`
-	// Type is the transport type (currently only "stdio" is supported)
-	Type string `json:"type,omitempty"`
-}
-
 // ConfigV2 represents the configuration metadata for a model.
 type ConfigV2 struct {
 	ModelFormat   string   `json:"model_format"`
@@ -44,12 +20,6 @@ type ConfigV2 struct {
 	EmbedLen     int      `json:"embedding_length,omitempty"`
 	BaseName     string   `json:"base_name,omitempty"`
 
-	// agent-specific fields
-	Skills     []SkillRef `json:"skills,omitempty"`
-	MCPs       []MCPRef   `json:"mcps,omitempty"`
-	AgentType  string     `json:"agent_type,omitempty"`
-	Entrypoint string     `json:"entrypoint,omitempty"`
-
 	// required by spec
 	Architecture string `json:"architecture"`
 	OS           string `json:"os"`

types/model/name.go

@@ -59,7 +59,6 @@ type partKind int
 const (
 	kindHost partKind = iota
 	kindNamespace
-	kindKind
 	kindModel
 	kindTag
 	kindDigest
@@ -71,8 +70,6 @@ func (k partKind) String() string {
 		return "host"
 	case kindNamespace:
 		return "namespace"
-	case kindKind:
-		return "kind"
 	case kindModel:
 		return "model"
 	case kindTag:
@@ -92,7 +89,6 @@ func (k partKind) String() string {
 type Name struct {
 	Host      string
 	Namespace string
-	Kind      string // Optional: "skill", "agent", or empty for models
 	Model     string
 	Tag       string
 }
@@ -101,27 +97,34 @@ type Name struct {
 // format of a valid name string is:
 //
 //	  s:
-//		  { host } "/" { namespace } "/" { kind } "/" { model } ":" { tag }
+//		  { host } "/" { namespace } "/" { model } ":" { tag } "@" { digest }
 //		  { host } "/" { namespace } "/" { model } ":" { tag }
-//		  { namespace } "/" { kind } "/" { model } ":" { tag }
+//		  { host } "/" { namespace } "/" { model } "@" { digest }
+//		  { host } "/" { namespace } "/" { model }
+//		  { namespace } "/" { model } ":" { tag } "@" { digest }
 //		  { namespace } "/" { model } ":" { tag }
+//		  { namespace } "/" { model } "@" { digest }
+//		  { namespace } "/" { model }
+//		  { model } ":" { tag } "@" { digest }
 //		  { model } ":" { tag }
+//		  { model } "@" { digest }
 //		  { model }
+//		  "@" { digest }
 //	  host:
 //	      pattern: { alphanum | "_" } { alphanum | "-" | "_" | "." | ":" }*
 //	      length:  [1, 350]
 //	  namespace:
 //	      pattern: { alphanum | "_" } { alphanum | "-" | "_" }*
 //	      length:  [1, 80]
-//	  kind:
-//	      pattern: "skill" | "agent" | "" (empty for models)
-//	      length:  [0, 80]
 //	  model:
 //	      pattern: { alphanum | "_" } { alphanum | "-" | "_" | "." }*
 //	      length:  [1, 80]
 //	  tag:
 //	      pattern: { alphanum | "_" } { alphanum | "-" | "_" | "." }*
 //	      length:  [1, 80]
+//	  digest:
+//	      pattern: { alphanum | "_" } { alphanum | "-" | ":" }*
+//	      length:  [1, 80]
 //
 // Most users should use [ParseName] instead, unless need to support
 // different defaults than DefaultName.
@@ -133,13 +136,6 @@ func ParseName(s string) Name {
 	return Merge(ParseNameBare(s), DefaultName())
 }
 
-// ValidKinds are the allowed values for the Kind field
-var ValidKinds = map[string]bool{
-	"skill": true,
-	"agent": true,
-	"mcp":   true,
-}
-
 // ParseNameBare parses s as a name string and returns a Name. No merge with
 // [DefaultName] is performed.
 func ParseNameBare(s string) Name {
@@ -157,30 +153,6 @@ func ParseNameBare(s string) Name {
 		return n
 	}
 
-	s, n.Kind, promised = cutPromised(s, "/")
-	if !promised {
-		// Only 2 parts: namespace/model - what we parsed as Kind is actually Namespace
-		n.Namespace = n.Kind
-		n.Kind = ""
-		return n
-	}
-
-	// Check if what we parsed as Kind is actually a valid kind value
-	if !ValidKinds[n.Kind] {
-		// Not a valid kind - this is the old 3-part format: host/namespace/model
-		// Shift: Kind -> Namespace, s -> Host
-		n.Namespace = n.Kind
-		n.Kind = ""
-
-		scheme, host, ok := strings.Cut(s, "://")
-		if !ok {
-			host = scheme
-		}
-		n.Host = host
-		return n
-	}
-
-	// Valid kind found - continue parsing for namespace and optional host
 	s, n.Namespace, promised = cutPromised(s, "/")
 	if !promised {
 		n.Namespace = s
@@ -196,32 +168,20 @@ func ParseNameBare(s string) Name {
 	return n
 }
 
-// ParseNameFromFilepath parses a 4 or 5-part filepath as a Name. The parts are
+// ParseNameFromFilepath parses a 4-part filepath as a Name. The parts are
 // expected to be in the form:
 //
 // { host } "/" { namespace } "/" { model } "/" { tag }
-// { host } "/" { namespace } "/" { kind } "/" { model } "/" { tag }
 func ParseNameFromFilepath(s string) (n Name) {
 	parts := strings.Split(s, string(filepath.Separator))
-
-	switch len(parts) {
-	case 4:
-		// Old format: host/namespace/model/tag
-		n.Host = parts[0]
-		n.Namespace = parts[1]
-		n.Model = parts[2]
-		n.Tag = parts[3]
-	case 5:
-		// New format: host/namespace/kind/model/tag
-		n.Host = parts[0]
-		n.Namespace = parts[1]
-		n.Kind = parts[2]
-		n.Model = parts[3]
-		n.Tag = parts[4]
-	default:
+	if len(parts) != 4 {
 		return Name{}
 	}
 
+	n.Host = parts[0]
+	n.Namespace = parts[1]
+	n.Model = parts[2]
+	n.Tag = parts[3]
 	if !n.IsFullyQualified() {
 		return Name{}
 	}
@@ -229,12 +189,11 @@ func ParseNameFromFilepath(s string) (n Name) {
 	return n
 }
 
-// Merge merges the host, namespace, kind, and tag parts of the two names,
+// Merge merges the host, namespace, and tag parts of the two names,
 // preferring the non-empty parts of a.
 func Merge(a, b Name) Name {
 	a.Host = cmp.Or(a.Host, b.Host)
 	a.Namespace = cmp.Or(a.Namespace, b.Namespace)
-	a.Kind = cmp.Or(a.Kind, b.Kind)
 	a.Tag = cmp.Or(a.Tag, b.Tag)
 	return a
 }
@@ -252,10 +211,6 @@ func (n Name) String() string {
 		b.WriteString(n.Namespace)
 		b.WriteByte('/')
 	}
-	if n.Kind != "" {
-		b.WriteString(n.Kind)
-		b.WriteByte('/')
-	}
 	b.WriteString(n.Model)
 	if n.Tag != "" {
 		b.WriteByte(':')
@@ -278,12 +233,6 @@ func (n Name) DisplayShortest() string {
 		sb.WriteByte('/')
 	}
 
-	// include kind if present
-	if n.Kind != "" {
-		sb.WriteString(n.Kind)
-		sb.WriteByte('/')
-	}
-
 	// always include model and tag
 	sb.WriteString(n.Model)
 	sb.WriteString(":")
@@ -307,23 +256,18 @@ func (n Name) IsValid() bool {
 }
 
 // IsFullyQualified returns true if all parts of the name are present and
-// valid without the digest. Kind is optional and only validated if non-empty.
+// valid without the digest.
 func (n Name) IsFullyQualified() bool {
-	if !isValidPart(kindHost, n.Host) {
-		return false
+	parts := []string{
+		n.Host,
+		n.Namespace,
+		n.Model,
+		n.Tag,
 	}
-	if !isValidPart(kindNamespace, n.Namespace) {
-		return false
-	}
-	// Kind is optional - only validate if present
-	if n.Kind != "" && !isValidPart(kindKind, n.Kind) {
-		return false
-	}
-	if !isValidPart(kindModel, n.Model) {
-		return false
-	}
-	if !isValidPart(kindTag, n.Tag) {
-		return false
+	for i, part := range parts {
+		if !isValidPart(partKind(i), part) {
+			return false
+		}
 	}
 	return true
 }
@@ -332,7 +276,6 @@ func (n Name) IsFullyQualified() bool {
 // host to tag as a directory in the form:
 //
 //	{host}/{namespace}/{model}/{tag}
-//	{host}/{namespace}/{kind}/{model}/{tag}
 //
 // It uses the system's filepath separator and ensures the path is clean.
 //
@@ -342,15 +285,6 @@ func (n Name) Filepath() string {
 	if !n.IsFullyQualified() {
 		panic("illegal attempt to get filepath of invalid name")
 	}
-	if n.Kind != "" {
-		return filepath.Join(
-			n.Host,
-			n.Namespace,
-			n.Kind,
-			n.Model,
-			n.Tag,
-		)
-	}
 	return filepath.Join(
 		n.Host,
 		n.Namespace,
@@ -367,7 +301,6 @@ func (n Name) LogValue() slog.Value {
 func (n Name) EqualFold(o Name) bool {
 	return strings.EqualFold(n.Host, o.Host) &&
 		strings.EqualFold(n.Namespace, o.Namespace) &&
-		strings.EqualFold(n.Kind, o.Kind) &&
 		strings.EqualFold(n.Model, o.Model) &&
 		strings.EqualFold(n.Tag, o.Tag)
 }
@@ -384,11 +317,6 @@ func isValidLen(kind partKind, s string) bool {
 }
 
 func isValidPart(kind partKind, s string) bool {
-	// Kind must be one of the valid values
-	if kind == kindKind {
-		return ValidKinds[s]
-	}
-
 	if !isValidLen(kind, s) {
 		return false
 	}

x/agent/approval.go

@@ -4,6 +4,7 @@ package agent
 import (
 	"fmt"
 	"os"
+	"path"
 	"path/filepath"
 	"strings"
 	"sync"
@@ -179,6 +180,7 @@ func FormatDeniedResult(command string, pattern string) string {
 // 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.
+// Paths with ".." traversal that escape the base directory return empty string for security.
 func extractBashPrefix(command string) string {
 	// Split command by pipes and get the first part
 	parts := strings.Split(command, "|")
@@ -204,8 +206,8 @@ func extractBashPrefix(command string) string {
 		return ""
 	}
 
-	// Find the first path-like argument (must contain / or start with .)
-	// First pass: look for clear paths (containing / or starting with .)
+	// Find the first path-like argument (must contain / or \ or start with .)
+	// First pass: look for clear paths (containing path separators or starting with .)
 	for _, arg := range fields[1:] {
 		// Skip flags
 		if strings.HasPrefix(arg, "-") {
@@ -215,19 +217,49 @@ func extractBashPrefix(command string) string {
 		if isNumeric(arg) {
 			continue
 		}
-		// Only process if it looks like a path (contains / or starts with .)
-		if !strings.Contains(arg, "/") && !strings.HasPrefix(arg, ".") {
+		// Only process if it looks like a path (contains / or \ or starts with .)
+		if !strings.Contains(arg, "/") && !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)
+		// Normalize to forward slashes for consistent cross-platform matching
+		arg = strings.ReplaceAll(arg, "\\", "/")
+
+		// Security: reject absolute paths
+		if path.IsAbs(arg) {
+			return "" // Absolute path - don't create prefix
 		}
-		// Get the directory part of a file path
-		dir := filepath.Dir(arg)
+
+		// Normalize the path using stdlib path.Clean (resolves . and ..)
+		cleaned := path.Clean(arg)
+
+		// Security: reject if cleaned path escapes to parent directory
+		if strings.HasPrefix(cleaned, "..") {
+			return "" // Path escapes - don't create prefix
+		}
+
+		// Security: if original had "..", verify cleaned path didn't escape to sibling
+		// e.g., "tools/a/b/../../../etc" -> "etc" (escaped tools/ to sibling)
+		if strings.Contains(arg, "..") {
+			origBase := strings.SplitN(arg, "/", 2)[0]
+			cleanedBase := strings.SplitN(cleaned, "/", 2)[0]
+			if origBase != cleanedBase {
+				return "" // Path escaped to sibling directory
+			}
+		}
+
+		// Check if arg ends with / (explicit directory)
+		isDir := strings.HasSuffix(arg, "/")
+
+		// Get the directory part
+		var dir string
+		if isDir {
+			dir = cleaned
+		} else {
+			dir = path.Dir(cleaned)
+		}
+
 		if dir == "." {
-			// Path is just a directory like "tools" or "src" (no trailing /)
-			return fmt.Sprintf("%s:%s/", baseCmd, arg)
+			return fmt.Sprintf("%s:./", baseCmd)
 		}
 		return fmt.Sprintf("%s:%s/", baseCmd, dir)
 	}
@@ -332,6 +364,8 @@ func AllowlistKey(toolName string, args map[string]any) string {
 }
 
 // IsAllowed checks if a tool/command is allowed (exact match or prefix match).
+// For bash commands, hierarchical path matching is used - if "cat:tools/" is allowed,
+// then "cat:tools/subdir/" is also allowed (subdirectories inherit parent permissions).
 func (a *ApprovalManager) IsAllowed(toolName string, args map[string]any) bool {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
@@ -342,12 +376,20 @@ func (a *ApprovalManager) IsAllowed(toolName string, args map[string]any) bool {
 		return true
 	}
 
-	// For bash commands, check prefix matches
+	// For bash commands, check prefix matches with hierarchical path support
 	if toolName == "bash" {
 		if cmd, ok := args["command"].(string); ok {
 			prefix := extractBashPrefix(cmd)
-			if prefix != "" && a.prefixes[prefix] {
-				return true
+			if prefix != "" {
+				// Check exact prefix match first
+				if a.prefixes[prefix] {
+					return true
+				}
+				// Check hierarchical match: if any stored prefix is a parent of current prefix
+				// e.g., stored "cat:tools/" should match current "cat:tools/subdir/"
+				if a.matchesHierarchicalPrefix(prefix) {
+					return true
+				}
 			}
 		}
 	}
@@ -360,6 +402,40 @@ func (a *ApprovalManager) IsAllowed(toolName string, args map[string]any) bool {
 	return false
 }
 
+// matchesHierarchicalPrefix checks if the given prefix matches any stored prefix hierarchically.
+// For example, if "cat:tools/" is stored, it will match "cat:tools/subdir/" or "cat:tools/a/b/c/".
+func (a *ApprovalManager) matchesHierarchicalPrefix(currentPrefix string) bool {
+	// Split prefix into command and path parts (format: "cmd:path/")
+	colonIdx := strings.Index(currentPrefix, ":")
+	if colonIdx == -1 {
+		return false
+	}
+	currentCmd := currentPrefix[:colonIdx]
+	currentPath := currentPrefix[colonIdx+1:]
+
+	for storedPrefix := range a.prefixes {
+		storedColonIdx := strings.Index(storedPrefix, ":")
+		if storedColonIdx == -1 {
+			continue
+		}
+		storedCmd := storedPrefix[:storedColonIdx]
+		storedPath := storedPrefix[storedColonIdx+1:]
+
+		// Commands must match exactly
+		if currentCmd != storedCmd {
+			continue
+		}
+
+		// Check if current path starts with stored path (hierarchical match)
+		// e.g., "tools/subdir/" starts with "tools/"
+		if strings.HasPrefix(currentPath, storedPath) {
+			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) {
@@ -443,11 +519,12 @@ func formatToolDisplay(toolName string, args map[string]any) string {
 		}
 	}
 
-	// For web search, show query
+	// For web search, show query and internet notice
 	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))
+			sb.WriteString(fmt.Sprintf("Query: %s\n", query))
+			sb.WriteString("Uses internet via ollama.com")
 			return sb.String()
 		}
 	}
@@ -951,3 +1028,79 @@ func FormatDenyResult(toolName string, reason string) string {
 	}
 	return fmt.Sprintf("User denied execution of %s.", toolName)
 }
+
+// PromptYesNo displays a simple Yes/No prompt and returns the user's choice.
+// Returns true for Yes, false for No.
+func PromptYesNo(question string) (bool, error) {
+	fd := int(os.Stdin.Fd())
+	oldState, err := term.MakeRaw(fd)
+	if err != nil {
+		return false, err
+	}
+	defer term.Restore(fd, oldState)
+
+	selected := 0 // 0 = Yes, 1 = No
+	options := []string{"Yes", "No"}
+
+	// Hide cursor
+	fmt.Fprint(os.Stderr, "\033[?25l")
+	defer fmt.Fprint(os.Stderr, "\033[?25h")
+
+	renderYesNo := func() {
+		// Move to start of line and clear
+		fmt.Fprintf(os.Stderr, "\r\033[K")
+		fmt.Fprintf(os.Stderr, "\033[36m%s\033[0m ", question)
+		for i, opt := range options {
+			if i == selected {
+				fmt.Fprintf(os.Stderr, "\033[1;32m[%s]\033[0m ", opt)
+			} else {
+				fmt.Fprintf(os.Stderr, "\033[90m %s \033[0m ", opt)
+			}
+		}
+		fmt.Fprintf(os.Stderr, "\033[90m(←/→ or y/n, Enter to confirm)\033[0m")
+	}
+
+	renderYesNo()
+
+	buf := make([]byte, 3)
+	for {
+		n, err := os.Stdin.Read(buf)
+		if err != nil {
+			return false, err
+		}
+
+		if n == 1 {
+			switch buf[0] {
+			case 'y', 'Y':
+				selected = 0
+				renderYesNo()
+			case 'n', 'N':
+				selected = 1
+				renderYesNo()
+			case '\r', '\n': // Enter
+				fmt.Fprintf(os.Stderr, "\r\033[K") // Clear line
+				return selected == 0, nil
+			case 3: // Ctrl+C
+				fmt.Fprintf(os.Stderr, "\r\033[K")
+				return false, nil
+			case 27: // Escape - could be arrow key
+				// Read more bytes for arrow keys
+				continue
+			}
+		} else if n == 3 && buf[0] == 27 && buf[1] == 91 {
+			// Arrow keys
+			switch buf[2] {
+			case 'D': // Left
+				if selected > 0 {
+					selected--
+				}
+				renderYesNo()
+			case 'C': // Right
+				if selected < len(options)-1 {
+					selected++
+				}
+				renderYesNo()
+			}
+		}
+	}
+}

x/agent/approval_test.go

@@ -151,6 +151,27 @@ func TestExtractBashPrefix(t *testing.T) {
 			command:  "head -n 100",
 			expected: "",
 		},
+		// Path traversal security tests
+		{
+			name:     "path traversal - parent escape",
+			command:  "cat tools/../../etc/passwd",
+			expected: "", // Should NOT create a prefix - path escapes
+		},
+		{
+			name:     "path traversal - deep escape",
+			command:  "cat tools/a/b/../../../etc/passwd",
+			expected: "", // Normalizes to "../etc/passwd" - escapes
+		},
+		{
+			name:     "path traversal - absolute path",
+			command:  "cat /etc/passwd",
+			expected: "", // Absolute paths should not create prefix
+		},
+		{
+			name:     "path with safe dotdot - normalized",
+			command:  "cat tools/subdir/../file.go",
+			expected: "cat:tools/", // Normalizes to tools/file.go - safe, creates prefix
+		},
 	}
 
 	for _, tt := range tests {
@@ -164,6 +185,34 @@ func TestExtractBashPrefix(t *testing.T) {
 	}
 }
 
+func TestApprovalManager_PathTraversalBlocked(t *testing.T) {
+	am := NewApprovalManager()
+
+	// Allow "cat tools/file.go" - creates prefix "cat:tools/"
+	am.AddToAllowlist("bash", map[string]any{"command": "cat tools/file.go"})
+
+	// Path traversal attack: should NOT be allowed
+	if am.IsAllowed("bash", map[string]any{"command": "cat tools/../../etc/passwd"}) {
+		t.Error("SECURITY: path traversal attack should NOT be allowed")
+	}
+
+	// Another traversal variant
+	if am.IsAllowed("bash", map[string]any{"command": "cat tools/../../../etc/shadow"}) {
+		t.Error("SECURITY: deep path traversal should NOT be allowed")
+	}
+
+	// Valid subdirectory access should still work
+	if !am.IsAllowed("bash", map[string]any{"command": "cat tools/subdir/file.go"}) {
+		t.Error("expected cat tools/subdir/file.go to be allowed")
+	}
+
+	// Safe ".." that normalizes to within allowed directory should work
+	// tools/subdir/../other.go normalizes to tools/other.go which is under tools/
+	if !am.IsAllowed("bash", map[string]any{"command": "cat tools/subdir/../other.go"}) {
+		t.Error("expected cat tools/subdir/../other.go to be allowed (normalizes to tools/other.go)")
+	}
+}
+
 func TestApprovalManager_PrefixAllowlist(t *testing.T) {
 	am := NewApprovalManager()
 
@@ -186,6 +235,119 @@ func TestApprovalManager_PrefixAllowlist(t *testing.T) {
 	}
 }
 
+func TestApprovalManager_HierarchicalPrefixAllowlist(t *testing.T) {
+	am := NewApprovalManager()
+
+	// Allow "cat tools/file.go" - this creates prefix "cat:tools/"
+	am.AddToAllowlist("bash", map[string]any{"command": "cat tools/file.go"})
+
+	// Should allow subdirectories (hierarchical matching)
+	if !am.IsAllowed("bash", map[string]any{"command": "cat tools/subdir/file.go"}) {
+		t.Error("expected cat tools/subdir/file.go to be allowed via hierarchical prefix")
+	}
+
+	// Should allow deeply nested subdirectories
+	if !am.IsAllowed("bash", map[string]any{"command": "cat tools/a/b/c/deep.go"}) {
+		t.Error("expected cat tools/a/b/c/deep.go to be allowed via hierarchical prefix")
+	}
+
+	// Should still allow same directory
+	if !am.IsAllowed("bash", map[string]any{"command": "cat tools/another.go"}) {
+		t.Error("expected cat tools/another.go to be allowed")
+	}
+
+	// Should NOT allow different base directory
+	if am.IsAllowed("bash", map[string]any{"command": "cat src/main.go"}) {
+		t.Error("expected cat src/main.go to NOT be allowed")
+	}
+
+	// Should NOT allow different command even in subdirectory
+	if am.IsAllowed("bash", map[string]any{"command": "ls tools/subdir/"}) {
+		t.Error("expected ls tools/subdir/ to NOT be allowed (different command)")
+	}
+
+	// Should NOT allow similar but different directory name
+	if am.IsAllowed("bash", map[string]any{"command": "cat toolsbin/file.go"}) {
+		t.Error("expected cat toolsbin/file.go to NOT be allowed (different directory)")
+	}
+}
+
+func TestApprovalManager_HierarchicalPrefixAllowlist_CrossPlatform(t *testing.T) {
+	am := NewApprovalManager()
+
+	// Allow with forward slashes (Unix-style)
+	am.AddToAllowlist("bash", map[string]any{"command": "cat tools/file.go"})
+
+	// Should work with backslashes too (Windows-style) - normalized internally
+	if !am.IsAllowed("bash", map[string]any{"command": "cat tools\\subdir\\file.go"}) {
+		t.Error("expected cat tools\\subdir\\file.go to be allowed via hierarchical prefix (Windows path)")
+	}
+
+	// Mixed slashes should also work
+	if !am.IsAllowed("bash", map[string]any{"command": "cat tools\\a/b\\c/deep.go"}) {
+		t.Error("expected mixed slash path to be allowed via hierarchical prefix")
+	}
+}
+
+func TestMatchesHierarchicalPrefix(t *testing.T) {
+	am := NewApprovalManager()
+
+	// Add prefix for "cat:tools/"
+	am.prefixes["cat:tools/"] = true
+
+	tests := []struct {
+		name     string
+		prefix   string
+		expected bool
+	}{
+		{
+			name:     "exact match",
+			prefix:   "cat:tools/",
+			expected: true, // exact match also passes HasPrefix - caller handles exact match first
+		},
+		{
+			name:     "subdirectory",
+			prefix:   "cat:tools/subdir/",
+			expected: true,
+		},
+		{
+			name:     "deeply nested",
+			prefix:   "cat:tools/a/b/c/",
+			expected: true,
+		},
+		{
+			name:     "different base directory",
+			prefix:   "cat:src/",
+			expected: false,
+		},
+		{
+			name:     "different command same path",
+			prefix:   "ls:tools/",
+			expected: false,
+		},
+		{
+			name:     "similar directory name",
+			prefix:   "cat:toolsbin/",
+			expected: false,
+		},
+		{
+			name:     "invalid prefix format",
+			prefix:   "cattools",
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := am.matchesHierarchicalPrefix(tt.prefix)
+			if result != tt.expected {
+				t.Errorf("matchesHierarchicalPrefix(%q) = %v, expected %v",
+					tt.prefix, result, tt.expected)
+			}
+		})
+	}
+}
+
 func TestFormatApprovalResult(t *testing.T) {
 	tests := []struct {
 		name     string

x/cmd/run.go

@@ -6,10 +6,12 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"net/url"
 	"os"
 	"os/signal"
 	"strings"
 	"syscall"
+	"time"
 
 	"github.com/spf13/cobra"
 	"golang.org/x/term"
@@ -22,6 +24,101 @@ import (
 	"github.com/ollama/ollama/x/tools"
 )
 
+// Tool output capping constants
+const (
+	// localModelTokenLimit is the token limit for local models (smaller context).
+	localModelTokenLimit = 4000
+
+	// defaultTokenLimit is the token limit for cloud/remote models.
+	defaultTokenLimit = 10000
+
+	// charsPerToken is a rough estimate of characters per token.
+	// TODO: Estimate tokens more accurately using tokenizer if available
+	charsPerToken = 4
+)
+
+// isLocalModel checks if the model is running locally (not a cloud model).
+// TODO: Improve local/cloud model identification - could check model metadata
+func isLocalModel(modelName string) bool {
+	return !strings.HasSuffix(modelName, "-cloud")
+}
+
+// isLocalServer checks if connecting to a local Ollama server.
+// TODO: Could also check other indicators of local vs cloud server
+func isLocalServer() bool {
+	host := os.Getenv("OLLAMA_HOST")
+	if host == "" {
+		return true // Default is localhost:11434
+	}
+
+	// Parse the URL to check host
+	parsed, err := url.Parse(host)
+	if err != nil {
+		return true // If can't parse, assume local
+	}
+
+	hostname := parsed.Hostname()
+	return hostname == "localhost" || hostname == "127.0.0.1" || strings.Contains(parsed.Host, ":11434")
+}
+
+// truncateToolOutput truncates tool output to prevent context overflow.
+// Uses a smaller limit (4k tokens) for local models, larger (10k) for cloud/remote.
+func truncateToolOutput(output, modelName string) string {
+	var tokenLimit int
+	if isLocalModel(modelName) && isLocalServer() {
+		tokenLimit = localModelTokenLimit
+	} else {
+		tokenLimit = defaultTokenLimit
+	}
+
+	maxChars := tokenLimit * charsPerToken
+	if len(output) > maxChars {
+		return output[:maxChars] + "\n... (output truncated)"
+	}
+	return output
+}
+
+// waitForOllamaSignin shows the signin URL and polls until authentication completes.
+func waitForOllamaSignin(ctx context.Context) error {
+	client, err := api.ClientFromEnvironment()
+	if err != nil {
+		return err
+	}
+
+	// Get signin URL from initial Whoami call
+	_, err = client.Whoami(ctx)
+	if err != nil {
+		var aErr api.AuthorizationError
+		if errors.As(err, &aErr) && aErr.SigninURL != "" {
+			fmt.Fprintf(os.Stderr, "\n  To sign in, navigate to:\n")
+			fmt.Fprintf(os.Stderr, "      \033[36m%s\033[0m\n\n", aErr.SigninURL)
+			fmt.Fprintf(os.Stderr, "  \033[90mWaiting for sign in to complete...\033[0m")
+
+			// Poll until auth succeeds
+			ticker := time.NewTicker(2 * time.Second)
+			defer ticker.Stop()
+
+			for {
+				select {
+				case <-ctx.Done():
+					fmt.Fprintf(os.Stderr, "\n")
+					return ctx.Err()
+				case <-ticker.C:
+					user, whoamiErr := client.Whoami(ctx)
+					if whoamiErr == nil && user != nil && user.Name != "" {
+						fmt.Fprintf(os.Stderr, "\r\033[K  \033[32mSigned in as %s\033[0m\n", user.Name)
+						return nil
+					}
+					// Still waiting, show dot
+					fmt.Fprintf(os.Stderr, ".")
+				}
+			}
+		}
+		return err
+	}
+	return nil
+}
+
 // RunOptions contains options for running an interactive agent session.
 type RunOptions struct {
 	Model        string
@@ -37,6 +134,16 @@ type RunOptions struct {
 	// Agent fields (managed externally for session persistence)
 	Tools    *tools.Registry
 	Approval *agent.ApprovalManager
+
+	// YoloMode skips all tool approval prompts
+	YoloMode bool
+
+	// LastToolOutput stores the full output of the last tool execution
+	// for Ctrl+O expansion. Updated by Chat(), read by caller.
+	LastToolOutput *string
+
+	// LastToolOutputTruncated stores the truncated version shown inline
+	LastToolOutputTruncated *string
 }
 
 // Chat runs an agent chat loop with tool support.
@@ -77,6 +184,7 @@ func Chat(ctx context.Context, opts RunOptions) (*api.Message, error) {
 	var thinkTagOpened bool = false
 	var thinkTagClosed bool = false
 	var pendingToolCalls []api.ToolCall
+	var consecutiveErrors int // Track consecutive 500 errors for retry limit
 
 	role := "assistant"
 	messages := opts.Messages
@@ -159,6 +267,58 @@ func Chat(ctx context.Context, opts RunOptions) (*api.Message, error) {
 				return nil, nil
 			}
 
+			// Check for 401 Unauthorized - prompt user to sign in
+			var authErr api.AuthorizationError
+			if errors.As(err, &authErr) {
+				p.StopAndClear()
+				fmt.Fprintf(os.Stderr, "\033[33mAuthentication required to use this cloud model.\033[0m\n")
+				result, promptErr := agent.PromptYesNo("Sign in to Ollama?")
+				if promptErr == nil && result {
+					if signinErr := waitForOllamaSignin(ctx); signinErr == nil {
+						// Retry the chat request
+						fmt.Fprintf(os.Stderr, "\033[90mRetrying...\033[0m\n")
+						continue // Retry the loop
+					}
+				}
+				return nil, fmt.Errorf("authentication required - run 'ollama signin' to authenticate")
+			}
+
+			// Check for 500 errors (often tool parsing failures) - inform the model
+			var statusErr api.StatusError
+			if errors.As(err, &statusErr) && statusErr.StatusCode >= 500 {
+				consecutiveErrors++
+				p.StopAndClear()
+
+				if consecutiveErrors >= 3 {
+					fmt.Fprintf(os.Stderr, "\033[31m✗ Too many consecutive errors, giving up\033[0m\n")
+					return nil, fmt.Errorf("too many consecutive server errors: %s", statusErr.ErrorMessage)
+				}
+
+				fmt.Fprintf(os.Stderr, "\033[33m⚠ Server error (attempt %d/3): %s\033[0m\n", consecutiveErrors, statusErr.ErrorMessage)
+
+				// Include both the model's response and the error so it can learn
+				assistantContent := fullResponse.String()
+				if assistantContent == "" {
+					assistantContent = "(empty response)"
+				}
+				errorMsg := fmt.Sprintf("Your previous response caused an error: %s\n\nYour response was:\n%s\n\nPlease try again with a valid response.", statusErr.ErrorMessage, assistantContent)
+				messages = append(messages,
+					api.Message{Role: "user", Content: errorMsg},
+				)
+
+				// Reset state and retry
+				fullResponse.Reset()
+				thinkingContent.Reset()
+				thinkTagOpened = false
+				thinkTagClosed = false
+				pendingToolCalls = nil
+				state = &displayResponseState{}
+				p = progress.NewProgress(os.Stderr)
+				spinner = progress.NewSpinner("")
+				p.Add("", spinner)
+				continue
+			}
+
 			if strings.Contains(err.Error(), "upstream error") {
 				p.StopAndClear()
 				fmt.Println("An error occurred while processing your message. Please try again.")
@@ -168,6 +328,9 @@ func Chat(ctx context.Context, opts RunOptions) (*api.Message, error) {
 			return nil, err
 		}
 
+		// Reset consecutive error counter on success
+		consecutiveErrors = 0
+
 		// If no tool calls, we're done
 		if len(pendingToolCalls) == 0 || toolRegistry == nil {
 			break
@@ -216,7 +379,12 @@ func Chat(ctx context.Context, opts RunOptions) (*api.Message, error) {
 			}
 
 			// Check approval (uses prefix matching for bash commands)
-			if !skipApproval && !approval.IsAllowed(toolName, args) {
+			// In yolo mode, skip all approval prompts
+			if opts.YoloMode {
+				if !skipApproval {
+					fmt.Fprintf(os.Stderr, "\033[90m▶ Running: %s\033[0m\n", formatToolShort(toolName, args))
+				}
+			} else if !skipApproval && !approval.IsAllowed(toolName, args) {
 				result, err := approval.RequestApproval(toolName, args)
 				if err != nil {
 					fmt.Fprintf(os.Stderr, "Error requesting approval: %v\n", err)
@@ -250,6 +418,23 @@ func Chat(ctx context.Context, opts RunOptions) (*api.Message, error) {
 			// Execute the tool
 			toolResult, err := toolRegistry.Execute(call)
 			if err != nil {
+				// Check if web search needs authentication
+				if errors.Is(err, tools.ErrWebSearchAuthRequired) {
+					// Prompt user to sign in
+					fmt.Fprintf(os.Stderr, "\033[33m  Web search requires authentication.\033[0m\n")
+					result, promptErr := agent.PromptYesNo("Sign in to Ollama?")
+					if promptErr == nil && result {
+						// Get signin URL and wait for auth completion
+						if signinErr := waitForOllamaSignin(ctx); signinErr == nil {
+							// Retry the web search
+							fmt.Fprintf(os.Stderr, "\033[90m  Retrying web search...\033[0m\n")
+							toolResult, err = toolRegistry.Execute(call)
+							if err == nil {
+								goto toolSuccess
+							}
+						}
+					}
+				}
 				fmt.Fprintf(os.Stderr, "\033[31m  Error: %v\033[0m\n", err)
 				toolResults = append(toolResults, api.Message{
 					Role:       "tool",
@@ -258,20 +443,34 @@ func Chat(ctx context.Context, opts RunOptions) (*api.Message, error) {
 				})
 				continue
 			}
+		toolSuccess:
 
 			// Display tool output (truncated for display)
+			truncatedOutput := ""
 			if toolResult != "" {
 				output := toolResult
 				if len(output) > 300 {
-					output = output[:300] + "... (truncated)"
+					output = output[:300] + "... (truncated, press Ctrl+O to expand)"
 				}
+				truncatedOutput = output
 				// Show result in grey, indented
 				fmt.Fprintf(os.Stderr, "\033[90m  %s\033[0m\n", strings.ReplaceAll(output, "\n", "\n  "))
 			}
 
+			// Store full and truncated output for Ctrl+O toggle
+			if opts.LastToolOutput != nil {
+				*opts.LastToolOutput = toolResult
+			}
+			if opts.LastToolOutputTruncated != nil {
+				*opts.LastToolOutputTruncated = truncatedOutput
+			}
+
+			// Truncate output to prevent context overflow
+			toolResultForLLM := truncateToolOutput(toolResult, opts.Model)
+
 			toolResults = append(toolResults, api.Message{
 				Role:       "tool",
-				Content:    toolResult,
+				Content:    toolResultForLLM,
 				ToolCallID: call.ID,
 			})
 		}
@@ -449,7 +648,8 @@ func checkModelCapabilities(ctx context.Context, modelName string) (supportsTool
 
 // 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 {
+// If yoloMode is true, all tool approvals are skipped.
+func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, options map[string]any, think *api.ThinkValue, hideThinking bool, keepAlive *api.Duration, yoloMode bool) error {
 	scanner, err := readline.New(readline.Prompt{
 		Prompt:         ">>> ",
 		AltPrompt:      "... ",
@@ -474,11 +674,11 @@ func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, op
 	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")
+		if toolRegistry.Count() > 0 {
+			fmt.Fprintf(os.Stderr, "\033[90mTools available: %s\033[0m\n", strings.Join(toolRegistry.Names(), ", "))
+		}
+		if yoloMode {
+			fmt.Fprintf(os.Stderr, "\033[33m⚠ YOLO mode: All tool approvals will be skipped\033[0m\n")
 		}
 	} else {
 		fmt.Fprintf(os.Stderr, "\033[33mNote: Model does not support tools - running in chat-only mode\033[0m\n")
@@ -490,6 +690,11 @@ func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, op
 	var messages []api.Message
 	var sb strings.Builder
 
+	// Track last tool output for Ctrl+O toggle
+	var lastToolOutput string
+	var lastToolOutputTruncated string
+	var toolOutputExpanded bool
+
 	for {
 		line, err := scanner.Readline()
 		switch {
@@ -502,6 +707,20 @@ func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, op
 			}
 			sb.Reset()
 			continue
+		case errors.Is(err, readline.ErrExpandOutput):
+			// Ctrl+O pressed - toggle between expanded and collapsed tool output
+			if lastToolOutput == "" {
+				fmt.Fprintf(os.Stderr, "\033[90mNo tool output to expand\033[0m\n")
+			} else if toolOutputExpanded {
+				// Currently expanded, show truncated
+				fmt.Fprintf(os.Stderr, "\033[90m  %s\033[0m\n", strings.ReplaceAll(lastToolOutputTruncated, "\n", "\n  "))
+				toolOutputExpanded = false
+			} else {
+				// Currently collapsed, show full
+				fmt.Fprintf(os.Stderr, "\033[90m  %s\033[0m\n", strings.ReplaceAll(lastToolOutput, "\n", "\n  "))
+				toolOutputExpanded = true
+			}
+			continue
 		case err != nil:
 			return err
 		}
@@ -524,6 +743,9 @@ func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, op
 			fmt.Fprintln(os.Stderr, "  /bye            Exit")
 			fmt.Fprintln(os.Stderr, "  /?, /help       Help for a command")
 			fmt.Fprintln(os.Stderr, "")
+			fmt.Fprintln(os.Stderr, "Keyboard Shortcuts:")
+			fmt.Fprintln(os.Stderr, "  Ctrl+O          Expand last tool output")
+			fmt.Fprintln(os.Stderr, "")
 			continue
 		case strings.HasPrefix(line, "/"):
 			fmt.Printf("Unknown command '%s'. Type /? for help\n", strings.Fields(line)[0])
@@ -537,16 +759,21 @@ func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, op
 			messages = append(messages, newMessage)
 
 			opts := RunOptions{
-				Model:        modelName,
-				Messages:     messages,
-				WordWrap:     wordWrap,
-				Options:      options,
-				Think:        think,
-				HideThinking: hideThinking,
-				KeepAlive:    keepAlive,
-				Tools:        toolRegistry,
-				Approval:     approval,
+				Model:                   modelName,
+				Messages:                messages,
+				WordWrap:                wordWrap,
+				Options:                 options,
+				Think:                   think,
+				HideThinking:            hideThinking,
+				KeepAlive:               keepAlive,
+				Tools:                   toolRegistry,
+				Approval:                approval,
+				YoloMode:                yoloMode,
+				LastToolOutput:          &lastToolOutput,
+				LastToolOutputTruncated: &lastToolOutputTruncated,
 			}
+			// Reset expanded state for new tool execution
+			toolOutputExpanded = false
 
 			assistant, err := Chat(cmd.Context(), opts)
 			if err != nil {

x/cmd/run_test.go

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

x/tools/registry.go

@@ -3,6 +3,7 @@ package tools
 
 import (
 	"fmt"
+	"os"
 	"sort"
 
 	"github.com/ollama/ollama/api"
@@ -88,9 +89,16 @@ func (r *Registry) Count() int {
 }
 
 // DefaultRegistry creates a registry with all built-in tools.
+// Tools can be disabled via environment variables:
+// - OLLAMA_AGENT_DISABLE_WEBSEARCH=1 disables web_search
+// - OLLAMA_AGENT_DISABLE_BASH=1 disables bash
 func DefaultRegistry() *Registry {
 	r := NewRegistry()
-	r.Register(&WebSearchTool{})
-	r.Register(&BashTool{})
+	if os.Getenv("OLLAMA_AGENT_DISABLE_WEBSEARCH") == "" {
+		r.Register(&WebSearchTool{})
+	}
+	if os.Getenv("OLLAMA_AGENT_DISABLE_BASH") == "" {
+		r.Register(&BashTool{})
+	}
 	return r
 }

x/tools/registry_test.go

@@ -108,6 +108,57 @@ func TestDefaultRegistry(t *testing.T) {
 	}
 }
 
+func TestDefaultRegistry_DisableWebsearch(t *testing.T) {
+	t.Setenv("OLLAMA_AGENT_DISABLE_WEBSEARCH", "1")
+
+	r := DefaultRegistry()
+
+	if r.Count() != 1 {
+		t.Errorf("expected 1 tool with websearch disabled, got %d", r.Count())
+	}
+
+	_, ok := r.Get("bash")
+	if !ok {
+		t.Error("expected bash tool in registry")
+	}
+
+	_, ok = r.Get("web_search")
+	if ok {
+		t.Error("expected web_search to be disabled")
+	}
+}
+
+func TestDefaultRegistry_DisableBash(t *testing.T) {
+	t.Setenv("OLLAMA_AGENT_DISABLE_BASH", "1")
+
+	r := DefaultRegistry()
+
+	if r.Count() != 1 {
+		t.Errorf("expected 1 tool with bash disabled, got %d", r.Count())
+	}
+
+	_, ok := r.Get("web_search")
+	if !ok {
+		t.Error("expected web_search tool in registry")
+	}
+
+	_, ok = r.Get("bash")
+	if ok {
+		t.Error("expected bash to be disabled")
+	}
+}
+
+func TestDefaultRegistry_DisableBoth(t *testing.T) {
+	t.Setenv("OLLAMA_AGENT_DISABLE_WEBSEARCH", "1")
+	t.Setenv("OLLAMA_AGENT_DISABLE_BASH", "1")
+
+	r := DefaultRegistry()
+
+	if r.Count() != 0 {
+		t.Errorf("expected 0 tools with both disabled, got %d", r.Count())
+	}
+}
+
 func TestBashTool_Schema(t *testing.T) {
 	tool := &BashTool{}
 

x/tools/websearch.go

@@ -2,15 +2,19 @@ package tools
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
-	"os"
+	"net/url"
+	"strconv"
 	"strings"
 	"time"
 
 	"github.com/ollama/ollama/api"
+	"github.com/ollama/ollama/auth"
 )
 
 const (
@@ -18,6 +22,9 @@ const (
 	webSearchTimeout = 15 * time.Second
 )
 
+// ErrWebSearchAuthRequired is returned when web search requires authentication
+var ErrWebSearchAuthRequired = errors.New("web search requires authentication")
+
 // WebSearchTool implements web search using Ollama's hosted API.
 type WebSearchTool struct{}
 
@@ -68,17 +75,13 @@ type webSearchResult struct {
 }
 
 // Execute performs the web search.
+// Uses Ollama key signing for authentication - this makes requests via ollama.com API.
 func (w *WebSearchTool) Execute(args map[string]any) (string, error) {
 	query, ok := args["query"].(string)
 	if !ok || query == "" {
 		return "", fmt.Errorf("query parameter is required")
 	}
 
-	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,
@@ -90,13 +93,34 @@ func (w *WebSearchTool) Execute(args map[string]any) (string, error) {
 		return "", fmt.Errorf("marshaling request: %w", err)
 	}
 
-	req, err := http.NewRequest("POST", webSearchAPI, bytes.NewBuffer(jsonBody))
+	// Parse URL and add timestamp for signing
+	searchURL, err := url.Parse(webSearchAPI)
+	if err != nil {
+		return "", fmt.Errorf("parsing search URL: %w", err)
+	}
+
+	q := searchURL.Query()
+	q.Add("ts", strconv.FormatInt(time.Now().Unix(), 10))
+	searchURL.RawQuery = q.Encode()
+
+	// Sign the request using Ollama key (~/.ollama/id_ed25519)
+	// This authenticates with ollama.com using the local signing key
+	ctx := context.Background()
+	data := fmt.Appendf(nil, "%s,%s", http.MethodPost, searchURL.RequestURI())
+	signature, err := auth.Sign(ctx, data)
+	if err != nil {
+		return "", fmt.Errorf("signing request: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, searchURL.String(), bytes.NewBuffer(jsonBody))
 	if err != nil {
 		return "", fmt.Errorf("creating request: %w", err)
 	}
 
 	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Authorization", "Bearer "+apiKey)
+	if signature != "" {
+		req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", signature))
+	}
 
 	// Send request
 	client := &http.Client{Timeout: webSearchTimeout}
@@ -111,6 +135,9 @@ func (w *WebSearchTool) Execute(args map[string]any) (string, error) {
 		return "", fmt.Errorf("reading response: %w", err)
 	}
 
+	if resp.StatusCode == http.StatusUnauthorized {
+		return "", ErrWebSearchAuthRequired
+	}
 	if resp.StatusCode != http.StatusOK {
 		return "", fmt.Errorf("web search API returned status %d: %s", resp.StatusCode, string(body))
 	}

x/tools/websearch_test.go

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