Skip to content

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

50.0 KB
Raw Blame
package server

import (
	"bytes"
	"context"
	"crypto/sha256"
	"encoding/json"
	"errors"
	"fmt"
	"net"
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"github.com/ollama/ollama/api"
	gguftest "github.com/ollama/ollama/internal/testutil/gguf"
	"github.com/ollama/ollama/manifest"
	"github.com/ollama/ollama/template"
	"github.com/ollama/ollama/types/model"
	"github.com/ollama/ollama/version"
)

func TestModelFromManifestReusesConfigReadForRunnerSelection(t *testing.T) {
	t.Setenv("OLLAMA_MODELS", t.TempDir())
	name := model.ParseName("legacy-runner-selection")
	config, err := manifest.NewLayer(strings.NewReader(`{"model_format":"safetensors"}`), "application/vnd.docker.container.image.v1+json")
	if err != nil {
		t.Fatal(err)
	}
	data, err := json.Marshal(manifest.Manifest{SchemaVersion: 2, Config: config})
	if err != nil {
		t.Fatal(err)
	}
	if err := manifest.WriteManifestData(name, data); err != nil {
		t.Fatal(err)
	}

	selected, err := manifest.ParseNamedManifestForRunner(name, manifest.RunnerMLX)
	if err != nil {
		t.Fatal(err)
	}
	configPath, err := manifest.BlobsPath(config.Digest)
	if err != nil {
		t.Fatal(err)
	}
	if err := os.Remove(configPath); err != nil {
		t.Fatal(err)
	}
	m, err := modelFromManifest(name, selected)
	if err != nil {
		t.Fatal(err)
	}
	if m.Config.ModelFormat != "safetensors" {
		t.Fatalf("model format = %q, want safetensors", m.Config.ModelFormat)
	}
}

func TestPruneLayersSkipsRecentOrphans(t *testing.T) {
	t.Setenv("OLLAMA_MODELS", t.TempDir())

	recentDigest := "sha256:0000000000000000000000000000000000000000000000000000000000000001"
	oldDigest := "sha256:0000000000000000000000000000000000000000000000000000000000000002"

	for _, digest := range []string{recentDigest, oldDigest} {
		p, err := manifest.BlobsPath(digest)
		if err != nil {
			t.Fatal(err)
		}
		if err := os.WriteFile(p, nil, 0o644); err != nil {
			t.Fatal(err)
		}
	}

	oldPath, err := manifest.BlobsPath(oldDigest)
	if err != nil {
		t.Fatal(err)
	}
	oldTime := time.Now().Add(-layerPruneGracePeriod - time.Hour)
	if err := os.Chtimes(oldPath, oldTime, oldTime); err != nil {
		t.Fatal(err)
	}

	if err := PruneLayers(); err != nil {
		t.Fatal(err)
	}

	recentPath, err := manifest.BlobsPath(recentDigest)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := os.Stat(recentPath); err != nil {
		t.Fatalf("recent orphan was pruned: %v", err)
	}
	if _, err := os.Stat(oldPath); !os.IsNotExist(err) {
		t.Fatalf("old orphan still exists: %v", err)
	}
}

func TestGenerationDefaultsFromMetadata(t *testing.T) {
	file, err := os.CreateTemp(t.TempDir(), "model-*.gguf")
	if err != nil {
		t.Fatal(err)
	}

	if err := gguftest.Write(file, gguftest.KV{
		"general.architecture":             "llama",
		"general.sampling.top_k":           uint32(40),
		"general.sampling.top_p":           int32(1),
		"general.sampling.min_p":           float32(0),
		"general.sampling.typ_p":           float32(0.95),
		"general.sampling.temp":            uint32(1),
		"general.sampling.penalty_last_n":  float32(64),
		"general.sampling.penalty_repeat":  float32(1.05),
		"general.sampling.penalty_freq":    uint32(0),
		"general.sampling.penalty_present": int32(0),
		"general.sampling.xtc_threshold":   float32(0.5),
		"general.sampling.mirostat_tau":    float32(5),
	}, nil); err != nil {
		t.Fatal(err)
	}
	if err := file.Close(); err != nil {
		t.Fatal(err)
	}

	md, err := extractGGUFMetadata(file.Name())
	if err != nil {
		t.Fatal(err)
	}

	defaults := generationDefaultsFromMetadata(md)
	check := func(key string, want any) {
		t.Helper()
		if got := defaults[key]; got != want {
			t.Fatalf("%s = %#v, want %#v", key, got, want)
		}
	}

	check("top_k", int64(40))
	check("top_p", float64(1))
	check("min_p", float64(0))
	check("typical_p", float64(0.95))
	check("temperature", float64(1))
	check("repeat_last_n", int64(64))
	check("repeat_penalty", float64(1.05))
	check("frequency_penalty", float64(0))
	check("presence_penalty", float64(0))
	if _, ok := defaults["mirostat_tau"]; ok {
		t.Fatal("mirostat_tau should not be mapped to an Ollama option")
	}
	if _, ok := defaults["xtc_threshold"]; ok {
		t.Fatal("xtc_threshold should not be mapped to an Ollama option")
	}
}

func TestGetModelTemplateMetadata(t *testing.T) {
	customTemplate := "CUSTOM {{ .Prompt }}"

	t.Run("records chat template and Go TEMPLATE layer", func(t *testing.T) {
		t.Setenv("OLLAMA_MODELS", t.TempDir())
		t.Setenv("OLLAMA_GO_TEMPLATE", "")

		_, digest := createBinFile(t, gguftest.KV{
			"general.architecture":    "llama",
			"tokenizer.chat_template": "{{ bos_token }}{{ messages[0]['content'] }}",
		}, nil)
		writeTestModelManifest(t, "template-disabled", digest, customTemplate)

		m, err := GetModelForRunner("template-disabled", "")
		if err != nil {
			t.Fatal(err)
		}
		if !m.HasChatTemplate {
			t.Fatal("expected GGUF chat template to be detected")
		}
		if !m.HasGoTemplate {
			t.Fatal("expected Go TEMPLATE layer to be detected")
		}
		if got := m.Template.String(); got != customTemplate {
			t.Fatalf("template = %q, want %q", got, customTemplate)
		}
	})

	t.Run("prefers chat template when Go TEMPLATE has fewer capabilities", func(t *testing.T) {
		t.Setenv("OLLAMA_MODELS", t.TempDir())
		t.Setenv("OLLAMA_GO_TEMPLATE", "")

		_, digest := createBinFile(t, gguftest.KV{
			"general.architecture":    "llama",
			"tokenizer.chat_template": "{% if tools %}{{ tools }}{% endif %}{{ messages[0]['content'] }}",
		}, nil)
		writeTestModelManifest(t, "chat-template-tools", digest, customTemplate)

		m, err := GetModelForRunner("chat-template-tools", "")
		if err != nil {
			t.Fatal(err)
		}
		if !m.PreferChatTemplate {
			t.Fatal("expected chat template to be preferred")
		}
		if got := m.CheckCapabilities(model.CapabilityTools); got != nil {
			t.Fatalf("expected tools capability, got %v", got)
		}
	})

	t.Run("prefers Qwen chat template with tools and inferred thinking", func(t *testing.T) {
		t.Setenv("OLLAMA_MODELS", t.TempDir())
		t.Setenv("OLLAMA_GO_TEMPLATE", "")

		_, digest := createBinFile(t, gguftest.KV{
			"general.architecture":    "llama",
			"tokenizer.chat_template": "{% if tools %}{{ tools }}{% endif %}{% set content = (content.split('</think>')|last) %}",
		}, nil)
		writeTestModelManifest(t, "chat-template-tools-thinking", digest, "{{ range .Messages }}{{ if .Thinking }}<think>{{ .Thinking }}</think>{{ end }}{{ .Content }}{{ end }}")

		m, err := GetModelForRunner("chat-template-tools-thinking", "")
		if err != nil {
			t.Fatal(err)
		}
		if !m.PreferChatTemplate {
			t.Fatal("expected chat template to be preferred")
		}
		if got := m.CheckCapabilities(model.CapabilityTools); got != nil {
			t.Fatalf("expected tools capability, got %v", got)
		}
		if got := m.CheckCapabilities(model.CapabilityThinking); got != nil {
			t.Fatalf("expected thinking capability, got %v", got)
		}
	})

	t.Run("prefers chat template with stronger tool round trip", func(t *testing.T) {
		t.Setenv("OLLAMA_MODELS", t.TempDir())
		t.Setenv("OLLAMA_GO_TEMPLATE", "")

		_, digest := createBinFile(t, gguftest.KV{
			"general.architecture": "llama",
			"tokenizer.chat_template": `{% if tools %}{{ tools }}{% endif %}
{% for message in messages %}
{% if message.tool_calls %}
{% for tool_call in message.tool_calls %}{{ tool_call.function.name }}{% endfor %}
{% endif %}
{% if message.role == 'tool' %}tool_response {{ message.content }}{% endif %}
{% endfor %}`,
		}, nil)
		writeTestModelManifest(t, "chat-template-tool-round-trip", digest, `{{ if .Tools }}tools{{ end }}
{{ range .Messages }}
{{ range .ToolCalls }}{{ .Function.Name }}{{ end }}
{{ end }}`)

		m, err := GetModelForRunner("chat-template-tool-round-trip", "")
		if err != nil {
			t.Fatal(err)
		}
		if !m.PreferChatTemplate {
			t.Fatal("expected chat template to be preferred")
		}
		if got := m.CheckCapabilities(model.CapabilityTools); got != nil {
			t.Fatalf("expected tools capability, got %v", got)
		}
	})

	t.Run("keeps Go TEMPLATE when chat template has weaker tool support", func(t *testing.T) {
		t.Setenv("OLLAMA_MODELS", t.TempDir())
		t.Setenv("OLLAMA_GO_TEMPLATE", "")

		_, digest := createBinFile(t, gguftest.KV{
			"general.architecture": "llama",
			"tokenizer.chat_template": `{%- if tools and not available_tools -%}
{{- set available_tools = tools -}}
{%- endif -%}
{%- if available_tools -%}
{{ '<|start_of_role|>available_tools<|end_of_role|>' }}{{ available_tools | tojson }}{{ '<|end_of_text|>' }}
{%- endif -%}
{%- if thinking -%}<think></think><response></response>{%- endif -%}
{%- for message in messages -%}
{{ '<|start_of_role|>' + message['role'] + '<|end_of_role|>' + message['content'] + '<|end_of_text|>' }}
{%- endfor -%}`,
		}, nil)
		writeTestModelManifest(t, "chat-template-weaker-tools", digest, `{{ if .Tools }}tools{{ end }}
{{ range .Messages }}
{{ if eq .Role "tool" }}tool_response{{ else }}{{ .Role }}{{ end }}
{{ if .ToolCalls }}<|tool_call|>{{ range .ToolCalls }}{{ .Function.Name }}{{ end }}{{ else }}{{ .Content }}{{ end }}
{{ end }}`)

		m, err := GetModelForRunner("chat-template-weaker-tools", "")
		if err != nil {
			t.Fatal(err)
		}
		if m.PreferChatTemplate {
			t.Fatal("expected Go TEMPLATE to be preferred")
		}
		if got := m.CheckCapabilities(model.CapabilityTools); got != nil {
			t.Fatalf("expected tools capability, got %v", got)
		}
		if got := m.CheckCapabilities(model.CapabilityThinking); got == nil {
			t.Fatal("expected thinking capability to remain unavailable on Go TEMPLATE path")
		}
	})

	t.Run("prefers Mistral chat template with tool call IDs", func(t *testing.T) {
		t.Setenv("OLLAMA_MODELS", t.TempDir())
		t.Setenv("OLLAMA_GO_TEMPLATE", "")

		_, digest := createBinFile(t, map[string]any{
			"general.architecture": "llama",
			"tokenizer.chat_template": `{% if tools %}{{ tools }}{% endif %}
{% for message in messages %}
{% if message.get('tool_calls') %}{% for tool_call in message.tool_calls %}[TOOL_CALLS]{{ tool_call.function.name }}[CALL_ID]{{ tool_call.id }}[ARGS]{{ tool_call['function']['arguments']|tojson }}{% endfor %}{% endif %}
{% if message['role'] == 'tool' %}tool_response{{ message['content'] }}{% endif %}
{% endfor %}`,
		}, nil)
		writeTestModelManifest(t, "chat-template-tool-call-ids", digest, `{{ if .Tools }}tools{{ end }}
{{ range .Messages }}
{{ if eq .Role "tool" }}tool_response{{ else }}{{ .Role }}{{ end }}
{{ if .ToolCalls }}[TOOL_CALLS]{{ range .ToolCalls }}{{ .Function.Name }}[CALL_ID]0[ARGS]{{ .Function.Arguments }}{{ end }}{{ else }}{{ .Content }}{{ end }}
{{ end }}`)

		m, err := GetModelForRunner("chat-template-tool-call-ids", "")
		if err != nil {
			t.Fatal(err)
		}
		if !m.PreferChatTemplate {
			t.Fatal("expected chat template to be preferred")
		}
		if got := m.CheckCapabilities(model.CapabilityTools); got != nil {
			t.Fatalf("expected tools capability, got %v", got)
		}
	})

	t.Run("respects explicit Go TEMPLATE enablement", func(t *testing.T) {
		t.Setenv("OLLAMA_MODELS", t.TempDir())
		t.Setenv("OLLAMA_GO_TEMPLATE", "1")

		_, digest := createBinFile(t, gguftest.KV{
			"general.architecture":    "llama",
			"tokenizer.chat_template": "{% if tools %}{{ tools }}{% endif %}{{ messages[0]['content'] }}",
		}, nil)
		writeTestModelManifest(t, "go-template-forced", digest, customTemplate)

		m, err := GetModelForRunner("go-template-forced", "")
		if err != nil {
			t.Fatal(err)
		}
		if m.PreferChatTemplate {
			t.Fatal("expected explicit Go TEMPLATE setting to suppress chat_template preference")
		}
		if got := m.CheckCapabilities(model.CapabilityTools); got == nil {
			t.Fatal("expected tools capability to be unavailable when Go TEMPLATE is explicitly enabled")
		}
	})

	t.Run("respects explicit Go TEMPLATE disablement", func(t *testing.T) {
		t.Setenv("OLLAMA_MODELS", t.TempDir())
		t.Setenv("OLLAMA_GO_TEMPLATE", "0")

		_, digest := createBinFile(t, gguftest.KV{
			"general.architecture":    "llama",
			"tokenizer.chat_template": "{% if tools %}{{ tools }}{% endif %}{{ messages[0]['content'] }}",
		}, nil)
		writeTestModelManifest(t, "go-template-disabled", digest, customTemplate)

		m, err := GetModelForRunner("go-template-disabled", "")
		if err != nil {
			t.Fatal(err)
		}
		if m.PreferChatTemplate {
			t.Fatal("expected explicit Go TEMPLATE setting to suppress chat_template preference")
		}
		if got := m.CheckCapabilities(model.CapabilityTools); got != nil {
			t.Fatalf("expected tools capability from GGUF chat_template, got %v", got)
		}
	})

	t.Run("records missing chat template", func(t *testing.T) {
		t.Setenv("OLLAMA_MODELS", t.TempDir())
		t.Setenv("OLLAMA_GO_TEMPLATE", "")

		_, digest := createBinFile(t, gguftest.KV{
			"general.architecture": "llama",
		}, nil)
		writeTestModelManifest(t, "missing-chat-template", digest, customTemplate)

		m, err := GetModelForRunner("missing-chat-template", "")
		if err != nil {
			t.Fatal(err)
		}
		if m.HasChatTemplate {
			t.Fatal("expected missing GGUF chat template")
		}
		if !m.HasGoTemplate {
			t.Fatal("expected Go TEMPLATE layer to be detected")
		}
	})
}

func writeTestModelManifest(t *testing.T, name, digest, tmpl string) {
	t.Helper()

	modelLayer, err := manifest.NewLayerFromLayer(digest, "application/vnd.ollama.image.model", "")
	if err != nil {
		t.Fatal(err)
	}
	templateLayer, err := manifest.NewLayer(strings.NewReader(tmpl), "application/vnd.ollama.image.template")
	if err != nil {
		t.Fatal(err)
	}

	layers := []manifest.Layer{modelLayer, templateLayer}
	configLayer, err := createConfigLayer(model.ConfigV2{
		ModelFormat:   "gguf",
		ModelFamily:   "llama",
		ModelFamilies: []string{"llama"},
	})
	if err != nil {
		t.Fatal(err)
	}
	if err := manifest.WriteManifest(model.ParseName(name), *configLayer, layers); err != nil {
		t.Fatal(err)
	}
}

// loadTestMetadata fills in what GetModel would have read from the metadata
// files, so
// hand-built models resolve capabilities the same way loaded ones do.
func loadTestMetadata(t *testing.T, m *Model) {
	t.Helper()
	if m.ModelPath != "" {
		md, err := extractGGUFMetadata(m.ModelPath)
		if err != nil {
			t.Fatalf("metadata for %s: %v", m.ModelPath, err)
		}
		m.metadata = md
	}
	m.projectorMetadata = nil
	for _, path := range m.ProjectorPaths {
		md, err := extractGGUFMetadata(path)
		if err != nil {
			t.Fatalf("projector metadata for %s: %v", path, err)
		}
		m.projectorMetadata = append(m.projectorMetadata, md)
	}
}

func TestPushLayersForManifestListIncludesChildManifests(t *testing.T) {
	t.Setenv("OLLAMA_MODELS", t.TempDir())

	writeChild := func(name, runner, formatName, layerMediaType string) (manifest.Manifest, manifest.Layer, manifest.Layer) {
		t.Helper()

		config, err := manifest.NewLayer(strings.NewReader(name+" config"), "application/vnd.docker.container.image.v1+json")
		if err != nil {
			t.Fatal(err)
		}
		layer, err := manifest.NewLayer(strings.NewReader(name+" layer"), layerMediaType)
		if err != nil {
			t.Fatal(err)
		}
		if err := manifest.WriteManifestWithMetadata(model.ParseName(name), config, []manifest.Layer{layer}, runner, formatName); err != nil {
			t.Fatal(err)
		}
		mf, err := manifest.ParseNamedManifestForRunner(model.ParseName(name), runner)
		if err != nil {
			t.Fatal(err)
		}
		return *mf, config, layer
	}

	mlx, mlxConfig, mlxLayer := writeChild("library/push-mlx:latest", manifest.RunnerMLX, manifest.FormatSafetensors, manifest.MediaTypeImageTensor)
	ggml, ggmlConfig, ggmlLayer := writeChild("library/push-ggml:latest", manifest.RunnerGGML, manifest.FormatGGUF, "application/vnd.ollama.image.model")

	mlxRef, err := manifest.NewManifestReference(mlx.BlobDigest(), mlx.Runner, mlx.Format)
	if err != nil {
		t.Fatal(err)
	}
	ggmlRef, err := manifest.NewManifestReference(ggml.BlobDigest(), ggml.Runner, ggml.Format)
	if err != nil {
		t.Fatal(err)
	}

	layers, err := pushLayersForManifestList(manifest.Manifest{
		SchemaVersion: 2,
		MediaType:     manifest.MediaTypeManifestList,
		Manifests:     []manifest.Manifest{mlxRef, ggmlRef},
	})
	if err != nil {
		t.Fatal(err)
	}

	want := map[string]string{
		mlx.BlobDigest():  manifest.MediaTypeManifest,
		ggml.BlobDigest(): manifest.MediaTypeManifest,
		mlxConfig.Digest:  mlxConfig.MediaType,
		mlxLayer.Digest:   mlxLayer.MediaType,
		ggmlConfig.Digest: ggmlConfig.MediaType,
		ggmlLayer.Digest:  ggmlLayer.MediaType,
	}
	if len(layers) != len(want) {
		t.Fatalf("layer count = %d, want %d: %#v", len(layers), len(want), layers)
	}
	for _, layer := range layers {
		if wantMediaType, ok := want[layer.Digest]; !ok {
			t.Fatalf("unexpected layer digest %q", layer.Digest)
		} else if layer.MediaType != wantMediaType {
			t.Fatalf("layer %q media type = %q, want %q", layer.Digest, layer.MediaType, wantMediaType)
		}
		if layer.Size == 0 {
			t.Fatalf("layer %q has zero size", layer.Digest)
		}
	}
	if !hasTensorLayers(layers) {
		t.Fatal("manifest list push layers did not preserve tensor media type")
	}
}

func TestCopyModelNarrowsManifestListToLocalChildren(t *testing.T) {
	t.Setenv("OLLAMA_MODELS", t.TempDir())

	writeChild := func(name, runner, formatName string) manifest.Manifest {
		t.Helper()

		config, err := manifest.NewLayer(strings.NewReader(name+" config"), "application/vnd.docker.container.image.v1+json")
		if err != nil {
			t.Fatal(err)
		}
		layer, err := manifest.NewLayer(strings.NewReader(name+" layer"), "application/vnd.ollama.image.model")
		if err != nil {
			t.Fatal(err)
		}
		if err := manifest.WriteManifestWithMetadata(model.ParseName(name), config, []manifest.Layer{layer}, runner, formatName); err != nil {
			t.Fatal(err)
		}
		mf, err := manifest.ParseNamedManifestForRunner(model.ParseName(name), runner)
		if err != nil {
			t.Fatal(err)
		}
		return *mf
	}

	local := writeChild("library/narrow-local:latest", manifest.RunnerGGML, manifest.FormatGGUF)
	localRef, err := manifest.NewManifestReference(local.BlobDigest(), local.Runner, local.Format)
	if err != nil {
		t.Fatal(err)
	}
	// A child the registry advertised but pull never materialized.
	absentRef, err := manifest.NewManifestReference(fmt.Sprintf("sha256:%064d", 1), manifest.RunnerMLX, manifest.FormatSafetensors)
	if err != nil {
		t.Fatal(err)
	}

	writeList := func(name string, refs []manifest.Manifest) model.Name {
		t.Helper()
		n := model.ParseName(name)
		if _, err := manifest.WriteManifestList(n, refs); err != nil {
			t.Fatal(err)
		}
		return n
	}

	t.Run("drops absent children and warns", func(t *testing.T) {
		src := writeList("library/narrow-src:latest", []manifest.Manifest{localRef, absentRef})
		dst := model.ParseName("library/narrow-dst:latest")

		warning, err := CopyModel(src, dst)
		if err != nil {
			t.Fatalf("CopyModel() = %v, want nil", err)
		}
		if !strings.Contains(warning, manifest.RunnerMLX) {
			t.Errorf("warning = %q, want it to name the dropped %s child", warning, manifest.RunnerMLX)
		}

		data, err := manifest.ReadManifestData(dst)
		if err != nil {
			t.Fatal(err)
		}
		var copied manifest.Manifest
		if err := json.Unmarshal(data, &copied); err != nil {
			t.Fatal(err)
		}
		if len(copied.Manifests) != 1 {
			t.Fatalf("copy has %d children, want 1: %#v", len(copied.Manifests), copied.Manifests)
		}
		if got := copied.Manifests[0].BlobDigest(); got != local.BlobDigest() {
			t.Errorf("copied child digest = %q, want %q", got, local.BlobDigest())
		}
	})

	t.Run("fully local list is copied verbatim", func(t *testing.T) {
		src := writeList("library/intact-src:latest", []manifest.Manifest{localRef})
		dst := model.ParseName("library/intact-dst:latest")

		warning, err := CopyModel(src, dst)
		if err != nil {
			t.Fatalf("CopyModel() = %v, want nil", err)
		}
		if warning != "" {
			t.Errorf("warning = %q, want none", warning)
		}

		srcData, err := manifest.ReadManifestData(src)
		if err != nil {
			t.Fatal(err)
		}
		dstData, err := manifest.ReadManifestData(dst)
		if err != nil {
			t.Fatal(err)
		}
		if !bytes.Equal(srcData, dstData) {
			t.Errorf("copy differs from source:\n got %s\nwant %s", dstData, srcData)
		}
	})

	t.Run("no local children is an error", func(t *testing.T) {
		src := writeList("library/empty-src:latest", []manifest.Manifest{absentRef})
		dst := model.ParseName("library/empty-dst:latest")

		if _, err := CopyModel(src, dst); !errors.Is(err, manifest.ErrNoCompatibleManifest) {
			t.Fatalf("CopyModel() = %v, want ErrNoCompatibleManifest", err)
		}
		if _, err := manifest.ReadManifestData(dst); err == nil {
			t.Error("destination manifest was written despite the error")
		}
	})
}

func TestPullModelManifestListDownloadsSelectedChildOnly(t *testing.T) {
	t.Setenv("OLLAMA_MODELS", t.TempDir())
	oldVersion := version.Version
	t.Cleanup(func() { version.Version = oldVersion })
	version.Version = "0.40.0-rc0"

	configData := []byte(`{"architecture":"test","requires":"0.40.0"}`)
	configDigest := fmt.Sprintf("sha256:%x", sha256.Sum256(configData))
	layerData := bytes.Repeat([]byte("selected tensor layer"), 64)
	layerDigest := fmt.Sprintf("sha256:%x", sha256.Sum256(layerData))

	child := manifest.Manifest{
		SchemaVersion: 2,
		MediaType:     manifest.MediaTypeManifest,
		Runner:        manifest.RunnerLlamaCPP,
		Format:        manifest.FormatGGUF,
		Config: manifest.Layer{
			MediaType: "application/vnd.docker.container.image.v1+json",
			Digest:    configDigest,
			Size:      int64(len(configData)),
		},
		Layers: []manifest.Layer{
			{
				MediaType: manifest.MediaTypeImageTensor,
				Digest:    layerDigest,
				Size:      int64(len(layerData)),
			},
		},
	}
	childData, err := json.Marshal(child)
	if err != nil {
		t.Fatal(err)
	}
	childDigest := fmt.Sprintf("sha256:%x", sha256.Sum256(childData))
	childRef, err := manifest.NewManifestReference(childDigest, manifest.RunnerLlamaCPP, manifest.FormatGGUF)
	if err != nil {
		t.Fatal(err)
	}
	unselectedDigest := "sha256:" + strings.Repeat("f", 64)
	unselectedRef, err := manifest.NewManifestReference(unselectedDigest, manifest.RunnerGGML, manifest.FormatGGUF)
	if err != nil {
		t.Fatal(err)
	}
	parent := manifest.Manifest{
		SchemaVersion: 2,
		MediaType:     manifest.MediaTypeManifestList,
		Manifests:     []manifest.Manifest{childRef, unselectedRef},
	}
	parentData, err := json.Marshal(parent)
	if err != nil {
		t.Fatal(err)
	}

	blobs := map[string][]byte{
		childDigest:  childData,
		configDigest: configData,
		layerDigest:  layerData,
	}
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && r.URL.Path == "/v2/library/test/manifests/latest":
			w.Header().Set("Content-Type", manifest.MediaTypeManifestList)
			w.Header().Set("Content-Length", strconv.Itoa(len(parentData)))
			_, _ = w.Write(parentData)
		case (r.Method == http.MethodHead || r.Method == http.MethodGet) && strings.HasPrefix(r.URL.Path, "/v2/library/test/blobs/"):
			digest := strings.TrimPrefix(r.URL.Path, "/v2/library/test/blobs/")
			if digest == unselectedDigest {
				t.Errorf("requested unselected child manifest %s", digest)
				http.Error(w, "unselected child requested", http.StatusNotFound)
				return
			}
			data, ok := blobs[digest]
			if !ok {
				http.NotFound(w, r)
				return
			}
			w.Header().Set("Content-Length", strconv.Itoa(len(data)))
			if r.Method == http.MethodGet {
				_, _ = w.Write(data)
			}
		default:
			http.NotFound(w, r)
		}
	}))
	defer ts.Close()

	name := strings.TrimPrefix(ts.URL, "http://") + "/library/test:latest"
	// Blobs download in parallel, so progress arrives from several goroutines.
	var mu sync.Mutex
	var progress []api.ProgressResponse
	if err := PullModel(t.Context(), name, "", &registryOptions{Insecure: true}, func(resp api.ProgressResponse) {
		mu.Lock()
		defer mu.Unlock()
		progress = append(progress, resp)
	}); err != nil {
		t.Fatal(err)
	}

	payloadTotal := int64(len(configData) + len(layerData))
	childManifestTotal := int64(len(childData))
	if payloadTotal == childManifestTotal {
		t.Fatalf("test fixture payload total equals child manifest size: %d", payloadTotal)
	}
	var sawPayloadProgress bool
	for _, resp := range progress {
		if resp.Digest != "sha256:model" {
			continue
		}
		if resp.Total == childManifestTotal {
			t.Fatalf("reported child manifest as model progress: %#v", resp)
		}
		if resp.Total == payloadTotal {
			sawPayloadProgress = true
		}
	}
	if !sawPayloadProgress {
		t.Fatalf("missing selected payload progress with total %d in %#v", payloadTotal, progress)
	}

	n := model.ParseName(name)
	gotParentData, err := manifest.ReadManifestData(n)
	if err != nil {
		t.Fatal(err)
	}
	if !bytes.Equal(gotParentData, parentData) {
		t.Fatal("named manifest does not contain the parent manifest list")
	}

	m, err := manifest.ParseNamedManifest(n)
	if err != nil {
		t.Fatal(err)
	}
	if m.Runner != manifest.RunnerLlamaCPP {
		t.Fatalf("runner = %q, want %q", m.Runner, manifest.RunnerLlamaCPP)
	}
	if m.Config.Digest != configDigest {
		t.Fatalf("config digest = %q, want %q", m.Config.Digest, configDigest)
	}

	for _, digest := range []string{childDigest, configDigest, layerDigest} {
		path, err := manifest.BlobsPath(digest)
		if err != nil {
			t.Fatal(err)
		}
		if _, err := os.Stat(path); err != nil {
			t.Fatalf("expected blob %s to exist: %v", digest, err)
		}
	}
	path, err := manifest.BlobsPath(unselectedDigest)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := os.Stat(path); !os.IsNotExist(err) {
		t.Fatalf("unselected child manifest blob exists: %v", err)
	}
}

func TestModelCapabilities(t *testing.T) {
	decisionModelPath, _ := createBinFile(t, gguftest.KV{
		"general.architecture":    "qwen35",
		"qwen35.decision.type":    "clef",
		"tokenizer.chat_template": `{% if tools %}{{ tools }}{% endif %}<think>{{ messages }}</think>`,
	}, []*gguftest.Tensor{})

	// Create completion model (llama architecture without vision)
	completionModelPath, _ := createBinFile(t, gguftest.KV{
		"general.architecture": "llama",
	}, []*gguftest.Tensor{})

	ggufToolTemplateModelPath, _ := createBinFile(t, gguftest.KV{
		"general.architecture":    "llama",
		"tokenizer.chat_template": `{% if tools %}<tool_call>{{ tools }}</tool_call>{% endif %}<think>{{ messages[0]['content'] }}</think>`,
	}, []*gguftest.Tensor{})

	// Create vision model (llama architecture with vision block count)
	visionModelPath, _ := createBinFile(t, gguftest.KV{
		"general.architecture":     "llama",
		"llama.vision.block_count": uint32(1),
	}, []*gguftest.Tensor{})

	// Create embedding model (bert architecture with pooling type)
	embeddingModelPath, _ := createBinFile(t, gguftest.KV{
		"general.architecture": "bert",
		"bert.pooling_type":    uint32(1),
	}, []*gguftest.Tensor{})

	audioProjectorPath, _ := createBinFile(t, gguftest.KV{
		"general.architecture":    "clip",
		"clip.has_audio_encoder":  true,
		"vision.projector_type":   "pixtral",
		"clip.vision.block_count": uint32(1),
	}, []*gguftest.Tensor{})

	nemotronOmniModelPath, _ := createBinFile(t, gguftest.KV{
		"general.architecture":                 "nemotron_h_omni",
		"nemotron_h_omni.vision.block_count":   uint32(1),
		"nemotron_h_omni.audio.block_count":    uint32(1),
		"nemotron_h_omni.embedding_length":     uint32(1),
		"nemotron_h_omni.attention.head_count": uint32(1),
	}, []*gguftest.Tensor{})

	suppressedAudioProjectorPath, _ := createBinFile(t, gguftest.KV{
		"general.architecture":    "clip",
		"clip.has_audio_encoder":  true,
		"vision.projector_type":   "gemma4v",
		"clip.vision.block_count": uint32(1),
	}, []*gguftest.Tensor{})

	toolsInsertTemplate, err := template.Parse("{{ .prompt }}{{ if .tools }}{{ .tools }}{{ end }}{{ if .suffix }}{{ .suffix }}{{ end }}")
	if err != nil {
		t.Fatalf("Failed to parse template: %v", err)
	}

	chatTemplate, err := template.Parse("{{ .prompt }}")
	if err != nil {
		t.Fatalf("Failed to parse template: %v", err)
	}

	toolsTemplate, err := template.Parse("{{ .prompt }}{{ if .tools }}{{ .tools }}{{ end }}")
	if err != nil {
		t.Fatalf("Failed to parse template: %v", err)
	}

	testModels := []struct {
		name         string
		model        Model
		expectedCaps []model.Capability
	}{
		{
			name: "Clef exposes decision instead of completion",
			model: Model{
				ModelPath: decisionModelPath,
			},
			expectedCaps: []model.Capability{model.CapabilityDecision},
		},
		{
			name: "Clef filters inherited generation capabilities",
			model: Model{
				ModelPath:      decisionModelPath,
				ProjectorPaths: []string{visionModelPath},
				Config:         model.ConfigV2{Capabilities: []string{"decision", "vision", "completion", "insert", "tools", "thinking"}},
			},
			expectedCaps: []model.Capability{model.CapabilityDecision, model.CapabilityVision},
		},
		{
			name: "model with image generation capability via config",
			model: Model{
				Config: model.ConfigV2{
					Capabilities: []string{"image"},
				},
			},
			expectedCaps: []model.Capability{model.CapabilityImage},
		},
		{
			name: "model with image and vision capability (image editing)",
			model: Model{
				Config: model.ConfigV2{
					Capabilities: []string{"image", "vision"},
				},
			},
			expectedCaps: []model.Capability{model.CapabilityImage, model.CapabilityVision},
		},
		{
			name: "model with completion capability",
			model: Model{
				ModelPath: completionModelPath,
				Template:  chatTemplate,
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion},
		},

		{
			name: "model with completion, tools, and insert capability",
			model: Model{
				ModelPath: completionModelPath,
				Template:  toolsInsertTemplate,
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityTools, model.CapabilityInsert},
		},
		{
			name: "model with tools capability",
			model: Model{
				ModelPath: completionModelPath,
				Template:  toolsTemplate,
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityTools},
		},
		{
			name: "model with GGUF chat_template tools and thinking",
			model: Model{
				ModelPath: ggufToolTemplateModelPath,
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityTools, model.CapabilityThinking},
		},
		{
			name: "model with Go TEMPLATE ignores GGUF chat_template capabilities",
			model: Model{
				ModelPath:       ggufToolTemplateModelPath,
				Template:        chatTemplate,
				HasGoTemplate:   true,
				HasChatTemplate: true,
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion},
		},
		{
			name: "model with tools capability from config and parser",
			model: Model{
				Config: model.ConfigV2{
					Capabilities: []string{"completion", "tools"},
					Parser:       "qwen3-coder",
				},
				Template: chatTemplate,
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityTools},
		},
		{
			name: "model with vision capability",
			model: Model{
				ModelPath: visionModelPath,
				Template:  chatTemplate,
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision},
		},
		{
			name: "model with vision, tools, and insert capability",
			model: Model{
				ModelPath: visionModelPath,
				Template:  toolsInsertTemplate,
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision, model.CapabilityTools, model.CapabilityInsert},
		},
		{
			name: "model with embedding capability",
			model: Model{
				ModelPath: embeddingModelPath,
				Template:  chatTemplate,
			},
			expectedCaps: []model.Capability{model.CapabilityEmbedding},
		},
		{
			name: "model with audio projector capability",
			model: Model{
				ModelPath:      completionModelPath,
				ProjectorPaths: []string{audioProjectorPath},
				Template:       chatTemplate,
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision, model.CapabilityAudio},
		},
		{
			name: "model with parser and projector capabilities without template",
			model: Model{
				ModelPath:      completionModelPath,
				ProjectorPaths: []string{audioProjectorPath},
				Config: model.ConfigV2{
					Parser: "functiongemma",
				},
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision, model.CapabilityAudio, model.CapabilityTools},
		},
		{
			name: "gemma4 projector exposes audio capability",
			model: Model{
				ModelPath:      completionModelPath,
				ProjectorPaths: []string{suppressedAudioProjectorPath},
				Template:       chatTemplate,
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision, model.CapabilityAudio},
		},
		{
			name: "gemma4 gguf exposes audio capability",
			model: Model{
				ModelPath:      completionModelPath,
				ProjectorPaths: []string{audioProjectorPath},
				Config: model.ConfigV2{
					Renderer:     gemma4RendererSmall,
					Capabilities: []string{"audio"},
				},
				Template: chatTemplate,
			},
			expectedCaps: []model.Capability{model.CapabilityAudio, model.CapabilityCompletion, model.CapabilityVision},
		},
		{
			name: "nemotron3 gguf suppresses audio capability",
			model: Model{
				ModelPath: nemotronOmniModelPath,
				Template:  chatTemplate,
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision},
		},
		{
			name: "nemotron3 projector suppresses audio capability",
			model: Model{
				ModelPath:      completionModelPath,
				ProjectorPaths: []string{audioProjectorPath},
				Config: model.ConfigV2{
					ModelFamily: "nemotron_h_omni",
				},
				Template: chatTemplate,
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision},
		},
		{
			name: "nemotron3 safetensors exposes vision and suppresses audio",
			model: Model{
				Config: model.ConfigV2{
					ModelFormat:  "safetensors",
					Parser:       "nemotron-3-nano",
					Renderer:     "nemotron-3-nano",
					Capabilities: []string{"completion", "vision", "audio"},
				},
				Template: chatTemplate,
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision, model.CapabilityTools, model.CapabilityThinking},
		},
		{
			name: "nemotron3.5 safetensors exposes vision and suppresses audio",
			model: Model{
				Config: model.ConfigV2{
					ModelFormat:  "safetensors",
					Parser:       "nemotron-3.5-nano",
					Renderer:     "nemotron-3.5-nano",
					Capabilities: []string{"completion", "vision", "audio"},
				},
				Template: chatTemplate,
			},
			expectedCaps: []model.Capability{model.CapabilityCompletion, model.CapabilityVision, model.CapabilityTools, model.CapabilityThinking},
		},
	}

	// compare two slices of model.Capability regardless of order
	compareCapabilities := func(a, b []model.Capability) bool {
		if len(a) != len(b) {
			return false
		}

		aCount := make(map[model.Capability]int)
		for _, cap := range a {
			aCount[cap]++
		}

		bCount := make(map[model.Capability]int)
		for _, cap := range b {
			bCount[cap]++
		}

		for cap, count := range aCount {
			if bCount[cap] != count {
				return false
			}
		}

		return true
	}

	for _, tt := range testModels {
		t.Run(tt.name, func(t *testing.T) {
			loadTestMetadata(t, &tt.model)

			// Test Capabilities method
			caps := tt.model.Capabilities()
			if !compareCapabilities(caps, tt.expectedCaps) {
				t.Errorf("Expected capabilities %v, got %v", tt.expectedCaps, caps)
			}
		})
	}
}

func TestModelCheckCapabilities(t *testing.T) {
	// Create simple model file for tests that don't depend on GGUF content
	completionModelPath, _ := createBinFile(t, gguftest.KV{
		"general.architecture": "llama",
	}, []*gguftest.Tensor{})

	// Create vision model (llama architecture with vision block count)
	visionModelPath, _ := createBinFile(t, gguftest.KV{
		"general.architecture":     "llama",
		"llama.vision.block_count": uint32(1),
	}, []*gguftest.Tensor{})

	// Create embedding model (bert architecture with pooling type)
	embeddingModelPath, _ := createBinFile(t, gguftest.KV{
		"general.architecture": "bert",
		"bert.pooling_type":    uint32(1),
	}, []*gguftest.Tensor{})

	toolsInsertTemplate, err := template.Parse("{{ .prompt }}{{ if .tools }}{{ .tools }}{{ end }}{{ if .suffix }}{{ .suffix }}{{ end }}")
	if err != nil {
		t.Fatalf("Failed to parse template: %v", err)
	}

	chatTemplate, err := template.Parse("{{ .prompt }}")
	if err != nil {
		t.Fatalf("Failed to parse template: %v", err)
	}

	toolsTemplate, err := template.Parse("{{ .prompt }}{{ if .tools }}{{ .tools }}{{ end }}")
	if err != nil {
		t.Fatalf("Failed to parse template: %v", err)
	}

	tests := []struct {
		name           string
		model          Model
		checkCaps      []model.Capability
		expectedErrMsg string
	}{
		{
			name: "completion model without tools capability",
			model: Model{
				ModelPath: completionModelPath,
				Template:  chatTemplate,
			},
			checkCaps:      []model.Capability{model.CapabilityTools},
			expectedErrMsg: "does not support tools",
		},
		{
			name: "model with all needed capabilities",
			model: Model{
				ModelPath: completionModelPath,
				Template:  toolsInsertTemplate,
			},
			checkCaps: []model.Capability{model.CapabilityTools, model.CapabilityInsert},
		},
		{
			name: "model missing insert capability",
			model: Model{
				ModelPath: completionModelPath,
				Template:  toolsTemplate,
			},
			checkCaps:      []model.Capability{model.CapabilityInsert},
			expectedErrMsg: "does not support insert",
		},
		{
			name: "model missing vision capability",
			model: Model{
				ModelPath: completionModelPath,
				Template:  toolsTemplate,
			},
			checkCaps:      []model.Capability{model.CapabilityVision},
			expectedErrMsg: "does not support vision",
		},
		{
			name: "model with vision capability",
			model: Model{
				ModelPath: visionModelPath,
				Template:  chatTemplate,
			},
			checkCaps: []model.Capability{model.CapabilityVision},
		},
		{
			name: "model with embedding capability",
			model: Model{
				ModelPath: embeddingModelPath,
				Template:  chatTemplate,
			},
			checkCaps: []model.Capability{model.CapabilityEmbedding},
		},
		{
			name: "unknown capability",
			model: Model{
				ModelPath: completionModelPath,
				Template:  chatTemplate,
			},
			checkCaps:      []model.Capability{"unknown"},
			expectedErrMsg: "unknown capability",
		},
		{
			name: "model missing image generation capability",
			model: Model{
				ModelPath: completionModelPath,
				Template:  chatTemplate,
			},
			checkCaps:      []model.Capability{model.CapabilityImage},
			expectedErrMsg: "does not support image generation",
		},
		{
			name: "model with image generation capability",
			model: Model{
				Config: model.ConfigV2{
					Capabilities: []string{"image"},
				},
			},
			checkCaps: []model.Capability{model.CapabilityImage},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			loadTestMetadata(t, &tt.model)

			// Test CheckCapabilities method
			err := tt.model.CheckCapabilities(tt.checkCaps...)
			if tt.expectedErrMsg == "" {
				if err != nil {
					t.Errorf("Expected no error, got: %v", err)
				}
			} else {
				if err == nil {
					t.Errorf("Expected error containing %q, got nil", tt.expectedErrMsg)
				} else if !strings.Contains(err.Error(), tt.expectedErrMsg) {
					t.Errorf("Expected error containing %q, got: %v", tt.expectedErrMsg, err)
				}
			}
		})
	}
}

func TestPullModelManifest(t *testing.T) {
	cases := []struct {
		name     string
		manifest string
	}{
		{
			name: "pretty printed",
			manifest: `{  "schemaVersion": 2,  "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
  "config": { "digest": "sha256:abc", "mediaType": "application/vnd.docker.container.image.v1+json", "size": 50 },
  "layers": [{ "digest": "sha256:t1", "mediaType": "application/vnd.ollama.image.tensor", "size": 1024, "name": "model.weight" }]
}`,
		},
		{
			name:     "non-standard field order",
			manifest: `{"layers":[{"size":999,"digest":"sha256:def","mediaType":"application/vnd.ollama.image.model"}],"schemaVersion":2,"config":{"size":50,"digest":"sha256:abc","mediaType":"application/vnd.docker.container.image.v1+json"},"mediaType":"application/vnd.docker.distribution.manifest.v2+json"}`,
		},
	}

	for _, tt := range cases {
		t.Run(tt.name, func(t *testing.T) {
			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				w.Write([]byte(tt.manifest))
			}))
			defer ts.Close()

			n := model.ParseName("test/model:latest")
			n.ProtocolScheme = "http"
			n.Host = strings.TrimPrefix(ts.URL, "http://")

			mf, data, err := pullModelManifest(t.Context(), n, &registryOptions{})
			if err != nil {
				t.Fatal(err)
			}

			// Raw bytes must be byte-for-byte identical to what the server sent
			if string(data) != tt.manifest {
				t.Fatalf("raw bytes differ from server response")
			}

			// SHA256 of returned data must match the expected registry digest
			expectedDigest := fmt.Sprintf("%x", sha256.Sum256([]byte(tt.manifest)))
			gotDigest := fmt.Sprintf("%x", sha256.Sum256(data))
			if gotDigest != expectedDigest {
				t.Fatalf("digest mismatch\ngot:  %s\nwant: %s", gotDigest, expectedDigest)
			}

			// Parsed manifest must still be usable
			if mf.SchemaVersion != 2 {
				t.Fatalf("schemaVersion = %d, want 2", mf.SchemaVersion)
			}
			if mf.Config.Digest == "" {
				t.Fatal("config digest is empty")
			}
			if len(mf.Layers) == 0 {
				t.Fatal("expected at least one layer")
			}
		})
	}
}

// TestPullModelDuplicateDigestVerifiesBlob pulls a manifest whose config and
// layer share a digest. The registry redirects blob downloads via Location to
// an "internal" path serving bytes that don't match the digest, so PullModel
// must reject the pull with errDigestMismatch.
func TestPullModelDuplicateDigestVerifiesBlob(t *testing.T) {
	t.Setenv("OLLAMA_MODELS", t.TempDir())

	const bogusDigest = "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

	backendURL := ""
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case strings.Contains(r.URL.Path, "/manifests/"):
			w.Header().Set("Content-Type", "application/vnd.docker.distribution.manifest.v2+json")
			fmt.Fprintf(w, `{
				"schemaVersion": 2,
				"mediaType": "application/vnd.docker.distribution.manifest.v2+json",
				"config": {
					"mediaType": "application/vnd.ollama.image.config",
					"digest": %q,
					"size": 5
				},
				"layers": [{
					"mediaType": "application/vnd.ollama.image.model",
					"digest": %q,
					"size": 5
				}]
			}`, bogusDigest, bogusDigest)
		case strings.Contains(r.URL.Path, "/internal/blobs/"):
			w.Write([]byte("attacker-controlled-bytes"))
		case strings.Contains(r.URL.Path, "/blobs/"):
			w.Header().Set("Location", backendURL+"/internal"+r.URL.Path)
			w.WriteHeader(http.StatusOK)
		default:
			http.NotFound(w, r)
		}
	}))
	defer ts.Close()
	backendURL = ts.URL

	u, err := url.Parse(ts.URL)
	if err != nil {
		t.Fatal(err)
	}
	n := model.ParseName(u.Host + "/test/attack")
	n.ProtocolScheme = "http"

	err = PullModel(t.Context(), n.String(), "", &registryOptions{Insecure: true}, func(api.ProgressResponse) {})
	if !errors.Is(err, errDigestMismatch) {
		t.Fatalf("PullModel = %v, want errDigestMismatch (unverified blob would persist)", err)
	}
}

// TestPullManifestRejectsCrossHostRedirect: a registry can't redirect a
// pull at an internal address; cross-host redirects to public addresses
// (hf.co's CDN) are fine. --insecure opts out.
func TestPullManifestRejectsCrossHostRedirect(t *testing.T) {
	t.Setenv("OLLAMA_MODELS", t.TempDir())

	var internalHit atomic.Bool
	internal := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		internalHit.Store(true)
	}))
	defer internal.Close()

	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		http.Redirect(w, r, internal.URL+r.URL.Path, http.StatusFound)
	}))
	defer ts.Close()

	requestURL, err := url.Parse(ts.URL + "/v2/test/attack/manifests/latest")
	if err != nil {
		t.Fatal(err)
	}

	// Default policy: cross-host redirect is refused before any request
	// leaves for the internal host. (regOpts nil exercises the makeRequest
	// default; the insecure protocol check doesn't apply at this level.)
	blockedResp, err := makeRequest(t.Context(), http.MethodGet, requestURL, nil, nil, &registryOptions{})
	// On a CheckRedirect failure the client returns the pre-redirect
	// response with its body already closed; close again defensively to
	// satisfy bodyclose (double close is a no-op).
	if blockedResp != nil && blockedResp.Body != nil {
		blockedResp.Body.Close()
	}
	if !errors.Is(err, errBlockedRedirect) {
		t.Fatalf("makeRequest = %v, want errBlockedRedirect", err)
	}
	if internalHit.Load() {
		t.Fatal("internal host received a request despite the blocked redirect")
	}

	// Insecure opts out: the cross-host redirect is followed.
	resp, err := makeRequest(t.Context(), http.MethodGet, requestURL, nil, nil, &registryOptions{Insecure: true})
	if err != nil {
		t.Fatalf("makeRequest with Insecure = %v, want redirect followed", err)
	}
	resp.Body.Close()
	if !internalHit.Load() {
		t.Fatal("redirect target was not reached with Insecure set")
	}
}

// TestPullManifestRedirectPolicy: cross-host redirects are blocked by
// default except between allowlisted hosts.
func TestPullManifestRedirectPolicy(t *testing.T) {
	for _, tc := range []struct {
		name    string
		origin  string // registry host receiving the initial request
		target  string // redirect target
		allowed bool
	}{
		{name: "hf to cdn sibling", origin: "hf.co", target: "us.aws.cdn.hf.co", allowed: true},
		{name: "hf to huggingface", origin: "hf.co", target: "huggingface.co", allowed: true},
		{name: "ollama registry to cdn", origin: "registry.ollama.ai", target: "cdn.ollama.com", allowed: true},
		{name: "public third party", origin: "hf.co", target: "93.184.216.34", allowed: false},
		{name: "other registry cross-host", origin: "registry.example.com", target: "cdn.example.com", allowed: false},
	} {
		t.Run(tc.name, func(t *testing.T) {
			var hit bool
			cdn := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				hit = true
				w.Write([]byte("ok"))
			}))
			defer cdn.Close()
			_, cdnPort, err := net.SplitHostPort(strings.TrimPrefix(cdn.URL, "http://"))
			if err != nil {
				t.Fatal(err)
			}

			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				http.Redirect(w, r, "http://"+net.JoinHostPort(tc.target, cdnPort)+r.URL.Path, http.StatusFound)
			}))
			defer ts.Close()

			// Steer all dials at the local servers so tests stay offline.
			prev := testMakeRequestDialContext
			testMakeRequestDialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
				host, _, err := net.SplitHostPort(addr)
				if err != nil {
					return nil, err
				}
				if host == tc.target {
					addr = net.JoinHostPort("127.0.0.1", cdnPort)
				} else {
					_, port, _ := net.SplitHostPort(strings.TrimPrefix(ts.URL, "http://"))
					addr = net.JoinHostPort("127.0.0.1", port)
				}
				return new(net.Dialer).DialContext(ctx, network, addr)
			}
			defer func() { testMakeRequestDialContext = prev }()

			requestURL, err := url.Parse(ts.URL + "/v2/unsloth/model/manifests/latest")
			if err != nil {
				t.Fatal(err)
			}
			requestURL.Host = net.JoinHostPort(tc.origin, requestURL.Port())

			resp, err := makeRequest(t.Context(), http.MethodGet, requestURL, nil, nil, &registryOptions{})
			if tc.allowed {
				if err != nil {
					t.Fatalf("makeRequest = %v, want %s -> %s followed", err, tc.origin, tc.target)
				}
				resp.Body.Close()
				if !hit {
					t.Fatal("redirect target not reached")
				}
				return
			}
			if !errors.Is(err, errBlockedRedirect) {
				t.Fatalf("makeRequest = %v, want errBlockedRedirect", err)
			}
			if hit {
				t.Fatal("blocked redirect target received a request")
			}
		})
	}
}

func TestCheckPullRequires(t *testing.T) {
	tests := []struct {
		name          string
		requires      string
		clientVersion string
		wantErr       bool
		wantMessage   string
	}{
		{
			name:          "empty requires passes",
			requires:      "",
			clientVersion: "0.33.3",
		},
		{
			name:          "older requirement passes",
			requires:      "0.33.0",
			clientVersion: "0.33.3",
		},
		{
			name:          "exact requirement passes",
			requires:      "0.33.3",
			clientVersion: "0.33.3",
		},
		{
			name:          "release candidate satisfies release requirement",
			requires:      "0.40.0",
			clientVersion: "0.40.0-rc0",
		},
		{
			name:          "development release candidate satisfies release requirement",
			requires:      "0.40.0",
			clientVersion: "0.40.0-rc0-g75b952780f",
		},
		{
			name:          "prerelease with build metadata satisfies release requirement",
			requires:      "v0.40.0",
			clientVersion: "0.40.0-beta.1+build.2",
		},
		{
			name:          "release candidate does not satisfy newer patch requirement",
			requires:      "0.40.1",
			clientVersion: "0.40.0-rc0-g75b952780f",
			wantErr:       true,
			wantMessage:   "model requires ollama version v0.40.1 or newer (current version is v0.40.0-rc0-g75b952780f)",
		},
		{
			name:          "older release candidate fails",
			requires:      "0.40.0",
			clientVersion: "0.39.0-rc1",
			wantErr:       true,
			wantMessage:   "model requires ollama version v0.40.0 or newer (current version is v0.39.0-rc1)",
		},
		{
			name:          "malformed prerelease fails",
			requires:      "0.40.0",
			clientVersion: "0.40.0-rc?",
			wantErr:       true,
			wantMessage:   "model requires ollama version v0.40.0 or newer (current version is v0.40.0-rc?)",
		},
		{
			name:          "newer requirement fails",
			requires:      "0.35.0",
			clientVersion: "0.33.3",
			wantErr:       true,
			wantMessage:   "model requires ollama version v0.35.0 or newer (current version is v0.33.3)",
		},
		{
			name:          "dev build skips check",
			requires:      "99.0.0",
			clientVersion: "0.0.0",
		},
		{
			name:          "v-prefixed requirement passes",
			requires:      "v0.33.0",
			clientVersion: "0.33.3",
		},
		{
			name:          "malformed requirement fails open",
			requires:      "banana",
			clientVersion: "0.33.3",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := checkPullRequires(tt.requires, tt.clientVersion)
			if tt.wantErr {
				if err == nil {
					t.Fatalf("checkPullRequires(%q, %q) = nil, want error", tt.requires, tt.clientVersion)
				}
				if err.Error() != tt.wantMessage {
					t.Fatalf("checkPullRequires error = %q, want %q", err.Error(), tt.wantMessage)
				}
				return
			}
			if err != nil {
				t.Fatalf("checkPullRequires(%q, %q) = %v, want nil", tt.requires, tt.clientVersion, err)
			}
		})
	}
}

func TestCheckPullRequiresUsesRunningVersion(t *testing.T) {
	oldVersion := version.Version
	t.Cleanup(func() { version.Version = oldVersion })

	// A dev build skips the check, but a stamped client that is too old
	// must fail the pull before any model layers are downloaded.
	version.Version = "0.33.3"
	if err := checkPullRequires("0.35.0", version.Version); err == nil {
		t.Fatal("expected stamped client below requires to fail")
	}
}