Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.
package server
import (
"bytes"
"cmp"
"context"
"crypto/sha256"
"encoding/json"
"errors"
"fmt"
"io"
"maps"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"reflect"
"runtime"
"slices"
"strings"
"testing"
"github.com/gin-gonic/gin"
gocmp "github.com/google/go-cmp/cmp"
gocmpopts "github.com/google/go-cmp/cmp/cmpopts"
"github.com/ollama/ollama/api"
"github.com/ollama/ollama/create"
"github.com/ollama/ollama/envconfig"
"github.com/ollama/ollama/fs/gguf"
st "github.com/ollama/ollama/fs/safetensors"
gguftest "github.com/ollama/ollama/internal/testutil/gguf"
"github.com/ollama/ollama/manifest"
"github.com/ollama/ollama/mlxrunner"
"github.com/ollama/ollama/types/model"
)
var stream bool = false
func createBinFile(t *testing.T, kv map[string]any, ti []*gguftest.Tensor) (string, string) {
t.Helper()
t.Setenv("OLLAMA_MODELS", cmp.Or(os.Getenv("OLLAMA_MODELS"), t.TempDir()))
f, err := os.CreateTemp(t.TempDir(), "")
if err != nil {
t.Fatal(err)
}
defer f.Close()
base := gguftest.KV{"general.architecture": "test"}
maps.Copy(base, kv)
if err := gguftest.Write(f, base, ti); err != nil {
t.Fatal(err)
}
// Calculate sha256 of file
if _, err := f.Seek(0, 0); err != nil {
t.Fatal(err)
}
digest, _ := GetSHA256Digest(f)
if err := f.Close(); err != nil {
t.Fatal(err)
}
blobPath, err := manifest.BlobsPath(digest)
if err != nil {
t.Fatal(err)
}
linkOrCopyTestBlob(t, f.Name(), blobPath)
return f.Name(), digest
}
func linkOrCopyTestBlob(t *testing.T, src, dst string) {
t.Helper()
if err := os.Remove(dst); err != nil && !errors.Is(err, os.ErrNotExist) {
t.Fatal(err)
}
if err := linkOrCopyFile(t.Context(), src, dst); err != nil {
t.Fatal(err)
}
}
type responseRecorder struct {
*httptest.ResponseRecorder
http.CloseNotifier
}
func NewRecorder() *responseRecorder {
return &responseRecorder{
ResponseRecorder: httptest.NewRecorder(),
}
}
func (t *responseRecorder) CloseNotify() <-chan bool {
return make(chan bool)
}
func createRequest(t *testing.T, fn func(*gin.Context), body any) *httptest.ResponseRecorder {
t.Helper()
// if OLLAMA_MODELS is not set, set it to the temp directory
t.Setenv("OLLAMA_MODELS", cmp.Or(os.Getenv("OLLAMA_MODELS"), t.TempDir()))
w := NewRecorder()
c, _ := gin.CreateTestContext(w)
var b bytes.Buffer
if err := json.NewEncoder(&b).Encode(body); err != nil {
t.Fatal(err)
}
c.Request = &http.Request{
Body: io.NopCloser(&b),
}
fn(c)
return w.ResponseRecorder
}
func TestCreateHandlerRejectsInvalidInfoTypes(t *testing.T) {
gin.SetMode(gin.TestMode)
testCases := []struct {
name string
info map[string]any
err string
}{
{
name: "string_field",
info: map[string]any{
"model_family": float64(1),
},
err: "model_family",
},
{
name: "fractional_integer_field",
info: map[string]any{
"context_length": 1.5,
},
err: "context_length",
},
{
name: "capabilities_not_array",
info: map[string]any{
"capabilities": "completion",
},
err: "capabilities",
},
{
name: "capabilities_non_string",
info: map[string]any{
"capabilities": []any{"completion", float64(1)},
},
err: "capabilities",
},
}
for _, tt := range testCases {
t.Run(tt.name, func(t *testing.T) {
var s Server
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "test-create-invalid-info",
Files: map[string]string{
"test.gguf": digest,
},
Info: tt.info,
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("expected status code 400, got %d", w.Code)
}
var resp map[string]string
if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
t.Fatal(err)
}
if got := resp["error"]; !strings.Contains(got, tt.err) {
t.Fatalf("expected %s error, got %q", tt.err, got)
}
})
}
}
func TestCreateHandlerRejectsInvalidFiles(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
validDigest := "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
tests := []struct {
name string
files map[string]string
}{
{
name: "invalid digest",
files: map[string]string{"model.gguf": "not-a-digest"},
},
{
name: "dot path",
files: map[string]string{".": validDigest},
},
{
name: "backslash path",
files: map[string]string{`nested\model.gguf`: validDigest},
},
{
name: "mixed model types",
files: map[string]string{
"model.gguf": validDigest,
"model.safetensors": validDigest,
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "test-create-invalid-files",
Files: tt.files,
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400: %s", w.Code, w.Body.String())
}
})
}
}
func TestCreateHandlerRejectsInvalidQuantizeOptions(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
validDigest := "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
tests := []struct {
name string
req api.CreateRequest
wantErrSub string
}{
{
name: "gguf quantize",
req: api.CreateRequest{
Files: map[string]string{"model.gguf": validDigest},
Quantize: "Q4_K_M",
},
wantErrSub: "create-time quantization",
},
{
name: "safetensors quantize",
req: api.CreateRequest{
Files: map[string]string{"model.safetensors": validDigest},
Quantize: "Q4_K_M",
},
wantErrSub: "unsupported quantize",
},
{
name: "safetensors draft quantize",
req: api.CreateRequest{
Files: map[string]string{"model.safetensors": validDigest},
DraftFiles: map[string]string{"model.safetensors": validDigest},
DraftQuantize: "Q4_K_M",
},
wantErrSub: "unsupported draft quantize",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tt.req.Model = "test-create-invalid-quantize"
tt.req.Stream = &stream
w := createRequest(t, s.CreateHandler, tt.req)
if w.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400: %s", w.Code, w.Body.String())
}
if !strings.Contains(w.Body.String(), tt.wantErrSub) {
t.Fatalf("error = %s, want substring %q", w.Body.String(), tt.wantErrSub)
}
})
}
}
func readCreatedModelConfig(t *testing.T, name string) model.ConfigV2 {
t.Helper()
mf, err := manifest.ParseNamedManifest(model.ParseName(name))
if err != nil {
t.Fatalf("parse manifest: %v", err)
}
if mf.Config.Digest == "" {
t.Fatalf("unexpected empty config digest for manifest")
}
configPath, err := manifest.BlobsPath(mf.Config.Digest)
if err != nil {
t.Fatalf("config blob path: %v", err)
}
cfgFile, err := os.Open(configPath)
if err != nil {
t.Fatalf("open config blob: %v", err)
}
defer cfgFile.Close()
var cfg model.ConfigV2
if err := json.NewDecoder(cfgFile).Decode(&cfg); err != nil {
t.Fatalf("decode config: %v", err)
}
return cfg
}
func TestCreateModelInfersGGUFFileTypesWithoutRewrite(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
for fileType := gguf.FileTypeF32; fileType < gguf.FileTypeUnknown; fileType++ {
want := fileType.String()
if want == "unknown" {
continue
}
t.Run(want, func(t *testing.T) {
_, digest := createBinFile(t, map[string]any{
"general.architecture": "gemma4",
"general.file_type": uint32(fileType),
}, []*gguftest.Tensor{
{
Name: "v.patch_embd.weight",
Type: gguf.TensorTypeF32,
Shape: []uint64{1, 1},
WriterTo: bytes.NewReader(make([]byte, 4)),
},
})
baseLayers, err := ggufLayersWithMediaType(digest, "test.gguf", "", func(api.ProgressResponse) {})
if err != nil {
t.Fatal(err)
}
name := model.ParseName(fmt.Sprintf("test-create-file-type-%d:latest", uint32(fileType)))
config := new(model.ConfigV2)
req := api.CreateRequest{Model: name.String()}
if err := createModel(t.Context(), req, name, baseLayers, config, func(api.ProgressResponse) {}); err != nil {
t.Fatal(err)
}
mf, err := manifest.ParseNamedManifest(name)
if err != nil {
t.Fatal(err)
}
var found bool
for _, layer := range mf.Layers {
if layer.MediaType == "application/vnd.ollama.image.model" {
found = true
}
}
if !found {
t.Fatal("created manifest is missing a model layer")
}
if mf.Layers[0].Digest != digest {
t.Fatalf("model layer digest = %q, want original digest %q", mf.Layers[0].Digest, digest)
}
if got := readCreatedModelConfig(t, name.String()).FileType; got != want {
t.Fatalf("model file type = %q, want %q", got, want)
}
})
}
}
func createSplitGGUFShard(t *testing.T, splitNo, splitCount uint32, tensorCount int32, tensorName string) string {
t.Helper()
return createSplitGGUFShardWithKV(t, gguftest.KV{
"general.architecture": "llama",
"general.file_type": uint32(gguf.FileTypeF32),
"split.no": splitNo,
"split.count": splitCount,
"split.tensors.count": tensorCount,
}, tensorName)
}
func createSplitGGUFShardWithKV(t *testing.T, kv gguftest.KV, tensorName string) string {
t.Helper()
_, digest := createBinFile(t, kv, []*gguftest.Tensor{
{
Name: tensorName,
Type: gguf.TensorTypeF32,
Shape: []uint64{1, 1},
WriterTo: bytes.NewReader(make([]byte, 4)),
},
})
return digest
}
func TestCreateModelRetainsSplitGGUF(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
firstDigest := createSplitGGUFShard(t, 0, 2, 2, "blk.0.attn_q.weight")
secondDigest := createSplitGGUFShard(t, 1, 2, 2, "blk.1.attn_q.weight")
baseLayers, err := convertModelFromFiles(t.Context(), map[string]string{
"model-00001-of-00002.gguf": firstDigest,
"model-00002-of-00002.gguf": secondDigest,
}, func(api.ProgressResponse) {})
if err != nil {
t.Fatal(err)
}
if len(baseLayers) != 1 {
t.Fatalf("base layers = %d, want 1", len(baseLayers))
}
if got := len(baseLayers[0].splitLayers); got != 2 {
t.Fatalf("split parts = %d, want 2", got)
}
name := model.ParseName("test-create-retain-split-gguf:latest")
config := new(model.ConfigV2)
req := api.CreateRequest{Model: name.String()}
if err := createModel(t.Context(), req, name, baseLayers, config, func(api.ProgressResponse) {}); err != nil {
t.Fatal(err)
}
mf, err := manifest.ParseNamedManifest(name)
if err != nil {
t.Fatal(err)
}
var modelLayers []manifest.Layer
for _, layer := range mf.Layers {
if layer.MediaType == "application/vnd.ollama.image.model" {
modelLayers = append(modelLayers, layer)
}
}
if len(modelLayers) != 2 {
t.Fatalf("created manifest has %d model layers, want 2", len(modelLayers))
}
if got, want := []string{modelLayers[0].Digest, modelLayers[1].Digest}, []string{firstDigest, secondDigest}; !slices.Equal(got, want) {
t.Fatalf("model layer digests = %q, want %q", got, want)
}
created, err := GetModel(name.String())
if err != nil {
t.Fatal(err)
}
firstPath, err := manifest.BlobsPath(firstDigest)
if err != nil {
t.Fatal(err)
}
secondPath, err := manifest.BlobsPath(secondDigest)
if err != nil {
t.Fatal(err)
}
if created.ModelPath != firstPath {
t.Fatalf("model path = %q, want %q", created.ModelPath, firstPath)
}
if !slices.Equal(created.ModelShardPaths, []string{secondPath}) {
t.Fatalf("model shard paths = %q, want %q", created.ModelShardPaths, []string{secondPath})
}
if got := created.Config.ModelType; got != "2" {
t.Fatalf("model parameter size = %q, want 2", got)
}
if got := created.Config.Requires; got != splitGGUFMinOllamaVersion {
t.Fatalf("minimum Ollama version = %q, want %q", got, splitGGUFMinOllamaVersion)
}
kv, tensors, err := getModelData(created.modelPaths(), true)
if err != nil {
t.Fatal(err)
}
if got := kv.FileType(); got != gguf.FileTypeF32 {
t.Fatalf("file type = %v, want %v", got, gguf.FileTypeF32)
}
if got := kv.ParameterCount(); got != 2 {
t.Fatalf("shown parameter count = %d, want 2", got)
}
if got := len(tensors.Items()); got != 2 {
t.Fatalf("shown tensor count = %d, want 2", got)
}
for _, tensor := range tensors.Items() {
if tensor.Type != gguf.TensorTypeF32 {
t.Fatalf("shown tensor type = %q, want F32", tensor.Type)
}
}
inheritedLayers, inheritedConfig, err := parseFromModel(t.Context(), name, func(api.ProgressResponse) {})
if err != nil {
t.Fatal(err)
}
if len(inheritedLayers) != 1 || len(inheritedLayers[0].splitLayers) != 2 {
t.Fatalf("inherited layers contain %d logical layers, want one split layer", len(inheritedLayers))
}
derivedName := model.ParseName("test-create-from-split-gguf:latest")
if err := createModel(t.Context(), api.CreateRequest{Model: derivedName.String()}, derivedName, inheritedLayers, &inheritedConfig, func(api.ProgressResponse) {}); err != nil {
t.Fatal(err)
}
derived, err := GetModel(derivedName.String())
if err != nil {
t.Fatal(err)
}
if !slices.Equal(derived.Config.ModelFamilies, []string{"llama"}) {
t.Fatalf("derived model families = %q, want llama", derived.Config.ModelFamilies)
}
if got := derived.Config.Requires; got != splitGGUFMinOllamaVersion {
t.Fatalf("derived minimum Ollama version = %q, want %q", got, splitGGUFMinOllamaVersion)
}
explicitName := model.ParseName("test-create-explicit-version-split-gguf:latest")
explicitConfig := &model.ConfigV2{Requires: "0.14.0"}
if err := createModel(t.Context(), api.CreateRequest{Model: explicitName.String()}, explicitName, baseLayers, explicitConfig, func(api.ProgressResponse) {}); err != nil {
t.Fatal(err)
}
if got := readCreatedModelConfig(t, explicitName.String()).Requires; got != "0.14.0" {
t.Fatalf("minimum Ollama version = %q, want 0.14.0", got)
}
}
func TestCreateModelRetainsSplitDraftGGUF(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
_, modelDigest := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
"general.file_type": uint32(gguf.FileTypeF32),
}, []*gguftest.Tensor{
{
Name: "blk.0.attn_q.weight",
Type: gguf.TensorTypeF32,
Shape: []uint64{1, 1},
WriterTo: bytes.NewReader(make([]byte, 4)),
},
})
baseLayers, err := ggufLayersWithMediaType(modelDigest, "model.gguf", "", func(api.ProgressResponse) {})
if err != nil {
t.Fatal(err)
}
firstDigest := createSplitGGUFShard(t, 0, 2, 2, "blk.0.attn_q.weight")
secondDigest := createSplitGGUFShard(t, 1, 2, 2, "blk.1.attn_q.weight")
draftLayers, err := convertDraftModelFromFiles(t.Context(), map[string]string{
"draft-00001-of-00002.gguf": firstDigest,
"draft-00002-of-00002.gguf": secondDigest,
}, func(api.ProgressResponse) {})
if err != nil {
t.Fatal(err)
}
baseLayers = append(baseLayers, draftLayers...)
name := model.ParseName("test-create-retain-split-draft-gguf:latest")
if err := createModel(t.Context(), api.CreateRequest{Model: name.String()}, name, baseLayers, new(model.ConfigV2), func(api.ProgressResponse) {}); err != nil {
t.Fatal(err)
}
created, err := GetModel(name.String())
if err != nil {
t.Fatal(err)
}
firstPath, err := manifest.BlobsPath(firstDigest)
if err != nil {
t.Fatal(err)
}
secondPath, err := manifest.BlobsPath(secondDigest)
if err != nil {
t.Fatal(err)
}
if created.DraftPath != firstPath {
t.Fatalf("draft path = %q, want %q", created.DraftPath, firstPath)
}
if !slices.Equal(created.DraftShardPaths, []string{secondPath}) {
t.Fatalf("draft shard paths = %q, want %q", created.DraftShardPaths, []string{secondPath})
}
if created.Config.Draft == nil || created.Config.Draft.Architecture != "llama" {
t.Fatalf("draft config = %#v, want llama architecture", created.Config.Draft)
}
if got := created.Config.Requires; got != splitGGUFMinOllamaVersion {
t.Fatalf("minimum Ollama version = %q, want %q", got, splitGGUFMinOllamaVersion)
}
}
func TestCreateModelDoesNotGroupSplitGGUFsAcrossDirectories(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
firstDigest := createSplitGGUFShard(t, 0, 2, 2, "blk.0.attn_q.weight")
secondDigest := createSplitGGUFShard(t, 1, 2, 2, "blk.1.attn_q.weight")
_, err := convertModelFromFiles(t.Context(), map[string]string{
"first/model-00001-of-00002.gguf": firstDigest,
"second/model-00002-of-00002.gguf": secondDigest,
}, func(api.ProgressResponse) {})
if !errors.Is(err, errInvalidSplitGGUF) {
t.Fatalf("convertModelFromFiles() error = %v, want errInvalidSplitGGUF", err)
}
}
func TestCreateModelGroupsSplitGGUFWithUnknownShardMetadata(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
firstDigest := createSplitGGUFShard(t, 0, 2, 2, "blk.0.attn_q.weight")
secondDigest := createSplitGGUFShardWithKV(t, gguftest.KV{
"general.architecture": "unknown",
"unknown.split.no": uint32(1),
"unknown.split.count": uint32(2),
"unknown.split.tensors.count": int32(2),
}, "blk.1.attn_q.weight")
baseLayers, err := convertModelFromFiles(t.Context(), map[string]string{
"model-00001-of-00002.gguf": firstDigest,
"model-00002-of-00002.gguf": secondDigest,
}, func(api.ProgressResponse) {})
if err != nil {
t.Fatal(err)
}
if len(baseLayers) != 1 {
t.Fatalf("base layers = %d, want 1", len(baseLayers))
}
if got := len(baseLayers[0].splitLayers); got != 2 {
t.Fatalf("split parts = %d, want 2", got)
}
}
func TestCreateModelRejectsMissingSplitGGUFShard(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
firstDigest := createSplitGGUFShard(t, 0, 2, 2, "blk.0.attn_q.weight")
baseLayers, err := convertModelFromFiles(t.Context(), map[string]string{
"model-00001-of-00002.gguf": firstDigest,
}, func(api.ProgressResponse) {})
if err == nil {
t.Fatalf("convertModelFromFiles() = %v, nil, want error", baseLayers)
}
if !errors.Is(err, errInvalidSplitGGUF) {
t.Fatalf("convertModelFromFiles() error = %v, want errInvalidSplitGGUF", err)
}
if !strings.Contains(err.Error(), "has 1 shards, expected 2") {
t.Fatalf("unexpected error: %v", err)
}
}
func TestCreateModelRejectsTooManySplitGGUFShards(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
digest := createSplitGGUFShard(t, 0, uint32(maxSplitGGUFParts+1), 1, "blk.0.attn_q.weight")
baseLayers, err := convertModelFromFiles(t.Context(), map[string]string{
fmt.Sprintf("model-00001-of-%05d.gguf", maxSplitGGUFParts+1): digest,
}, func(api.ProgressResponse) {})
if err == nil {
t.Fatalf("convertModelFromFiles() = %v, nil, want error", baseLayers)
}
if !errors.Is(err, errInvalidSplitGGUF) {
t.Fatalf("convertModelFromFiles() error = %v, want errInvalidSplitGGUF", err)
}
if !strings.Contains(err.Error(), "too many shards") {
t.Fatalf("unexpected error: %v", err)
}
}
func TestCreateModelRejectsDuplicateSplitGGUFTensors(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
firstDigest := createSplitGGUFShard(t, 0, 2, 2, "blk.0.attn_q.weight")
secondDigest := createSplitGGUFShard(t, 1, 2, 2, "blk.0.attn_q.weight")
_, err := convertModelFromFiles(t.Context(), map[string]string{
"model-00001-of-00002.gguf": firstDigest,
"model-00002-of-00002.gguf": secondDigest,
}, func(api.ProgressResponse) {})
if !errors.Is(err, errInvalidSplitGGUF) || !strings.Contains(err.Error(), "duplicate tensor") {
t.Fatalf("convertModelFromFiles() error = %v, want invalid split duplicate tensor", err)
}
}
func TestGGUFLayersClassifiesMMProjAsProjector(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
_, digest := createBinFile(t, map[string]any{
"general.architecture": "clip",
"general.type": "mmproj",
"clip.has_vision_encoder": true,
"clip.vision.block_count": uint32(0),
"clip.vision.projector_type": "gemma4uv",
"clip.has_audio_encoder": true,
"clip.audio.block_count": uint32(0),
"clip.audio.projector_type": "gemma4ua",
"clip.vision.projection_dim": uint32(3840),
"clip.vision.embedding_length": uint32(3840),
"clip.audio.projection_dim": uint32(3840),
"clip.audio.embedding_length": uint32(3840),
"clip.vision.feed_forward_length": uint32(0),
"clip.audio.feed_forward_length": uint32(0),
}, []*gguftest.Tensor{
{
Name: "mm.input_projection.weight",
Type: gguf.TensorTypeF32,
Shape: []uint64{1, 1},
WriterTo: bytes.NewReader(make([]byte, 4)),
},
})
layers, err := ggufLayersWithMediaType(digest, "mmproj-gemma-4-12B-it-bf16.gguf", "", func(api.ProgressResponse) {})
if err != nil {
t.Fatal(err)
}
if len(layers) != 1 {
t.Fatalf("layers = %d, want 1", len(layers))
}
if got := layers[0].MediaType; got != "application/vnd.ollama.image.projector" {
t.Fatalf("media type = %q, want projector", got)
}
}
func TestCreateModelRejectsGGUFQuantize(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
_, digest := createBinFile(t, map[string]any{
"general.architecture": "llama",
"general.file_type": uint32(gguf.FileTypeF16),
}, []*gguftest.Tensor{
{
Name: "blk.0.attn_q.weight",
Type: gguf.TensorTypeF16,
Shape: []uint64{1, 1},
WriterTo: bytes.NewReader(make([]byte, 2)),
},
})
baseLayers, err := ggufLayersWithMediaType(digest, "test.gguf", "", func(api.ProgressResponse) {})
if err != nil {
t.Fatal(err)
}
name := model.ParseName("test-create-quantize-embedded-gguf:latest")
config := new(model.ConfigV2)
req := api.CreateRequest{Model: name.String(), Quantize: "Q4_K_M"}
err = createModel(t.Context(), req, name, baseLayers, config, func(api.ProgressResponse) {})
if err == nil {
t.Fatal("expected create to fail")
}
if !strings.Contains(err.Error(), "create-time quantization is only supported for safetensors imports") {
t.Fatalf("unexpected error: %v", err)
}
}
func TestCreateModelDoesNotPublishAfterCancellation(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
ctx, cancel := context.WithCancel(t.Context())
name := model.ParseName("test-create-canceled:latest")
err := createModel(ctx, api.CreateRequest{Model: name.String()}, name, nil, new(model.ConfigV2), func(resp api.ProgressResponse) {
if resp.Status == "writing manifest" {
cancel()
}
})
if !errors.Is(err, context.Canceled) {
t.Fatalf("createModel() error = %v, want context.Canceled", err)
}
if _, err := manifest.ParseNamedManifest(name); !errors.Is(err, os.ErrNotExist) {
t.Fatalf("ParseNamedManifest() error = %v, want os.ErrNotExist", err)
}
}
func checkFileExists(t *testing.T, p string, expect []string) {
t.Helper()
actual, err := filepath.Glob(p)
if err != nil {
t.Fatal(err)
}
if strings.HasSuffix(filepath.ToSlash(p), "/blobs/*") {
actual = slices.DeleteFunc(actual, isManifestBlobForTest)
}
if diff := gocmp.Diff(expect, actual, gocmpopts.SortSlices(strings.Compare), gocmpopts.EquateEmpty()); diff != "" {
t.Errorf("file exists mismatch (-want +got):\n%s", diff)
}
}
func checkManifestFiles(t *testing.T, names ...string) {
t.Helper()
expect := make([]string, len(names))
for i, name := range names {
p, err := manifest.V2PathForName(model.ParseName(name))
if err != nil {
t.Fatal(err)
}
expect[i] = p
}
checkFileExists(t, filepath.Join(envconfig.Models(), "manifests-v2", "*", "*", "*", "*"), expect)
}
func isManifestBlobForTest(path string) bool {
data, err := os.ReadFile(path)
if err != nil {
return false
}
var m manifest.Manifest
if err := json.Unmarshal(data, &m); err != nil {
return false
}
return m.SchemaVersion != 0 && m.MediaType != "" && (m.Config.Digest != "" || len(m.Layers) > 0)
}
func TestCreateFromBin(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
Stream: &stream,
})
if w.Code != http.StatusOK {
fmt.Println(w)
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkManifestFiles(t, "test")
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
filepath.Join(p, "blobs", "sha256-89a2116c3a82d6a97f59f748d86ed4417214353fd178ee54df418fde32495fad"),
})
t.Run("empty file digest", func(t *testing.T) {
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "my-gguf-model",
Files: map[string]string{"0.gguf": ""},
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("expected status 400, got %d", w.Code)
}
if !strings.Contains(w.Body.String(), "invalid digest format") {
t.Errorf("expected invalid digest format error, got:\n%s", w.Body.String())
}
})
t.Run("adapters", func(t *testing.T) {
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "my-gguf-model",
Files: map[string]string{"0.gguf": digest},
Adapters: map[string]string{"adapter.gguf": "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"},
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("expected status 400, got %d", w.Code)
}
if !strings.Contains(w.Body.String(), errAdaptersUnsupported.Error()) {
t.Errorf("expected adapters unsupported error, got:\n%s", w.Body.String())
}
})
t.Run("deprecated parameter is rejected", func(t *testing.T) {
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "my-gguf-model",
Files: map[string]string{"0.gguf": digest},
Parameters: map[string]any{"typical_p": 0.5},
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("expected status 400, got %d: %s", w.Code, w.Body.String())
}
if !strings.Contains(w.Body.String(), errTypicalPDeprecated.Error()) {
t.Errorf("expected deprecated parameter error, got:\n%s", w.Body.String())
}
})
}
func TestCreateFromModel(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkManifestFiles(t, "test")
w = createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test2",
From: "test",
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkManifestFiles(t, "test", "test2")
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
filepath.Join(p, "blobs", "sha256-89a2116c3a82d6a97f59f748d86ed4417214353fd178ee54df418fde32495fad"),
})
}
func TestCreateFromModelInheritsRendererParser(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
const (
renderer = "custom-renderer"
parser = "custom-parser"
)
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "base",
Files: map[string]string{"base.gguf": digest},
Renderer: renderer,
Parser: parser,
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
baseConfig := readCreatedModelConfig(t, "base")
w = createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "child",
From: "base",
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
mf, err := manifest.ParseNamedManifest(model.ParseName("child"))
if err != nil {
t.Fatalf("parse manifest: %v", err)
}
if mf.Config.Digest == "" {
t.Fatalf("unexpected empty config digest for child manifest")
}
configPath, err := manifest.BlobsPath(mf.Config.Digest)
if err != nil {
t.Fatalf("config blob path: %v", err)
}
cfgFile, err := os.Open(configPath)
if err != nil {
t.Fatalf("open config blob: %v", err)
}
defer cfgFile.Close()
var cfg model.ConfigV2
if err := json.NewDecoder(cfgFile).Decode(&cfg); err != nil {
t.Fatalf("decode config: %v", err)
}
if cfg.Renderer != renderer {
t.Fatalf("expected renderer %q, got %q", renderer, cfg.Renderer)
}
if cfg.Parser != parser {
t.Fatalf("expected parser %q, got %q", parser, cfg.Parser)
}
if cfg.FileType != baseConfig.FileType {
t.Fatalf("expected file type %q, got %q", baseConfig.FileType, cfg.FileType)
}
}
func TestCreateRemovesLayers(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
Template: "{{ .Prompt }}",
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkManifestFiles(t, "test")
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-89a2116c3a82d6a97f59f748d86ed4417214353fd178ee54df418fde32495fad"),
filepath.Join(p, "blobs", "sha256-b507b9c2f6ca642bffcd06665ea7c91f235fd32daeefdf875a0f938db05fb315"),
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
})
w = createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
Template: "{{ .System }} {{ .Prompt }}",
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkManifestFiles(t, "test")
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
filepath.Join(p, "blobs", "sha256-89a2116c3a82d6a97f59f748d86ed4417214353fd178ee54df418fde32495fad"),
filepath.Join(p, "blobs", "sha256-fe7ac77b725cda2ccad03f88a880ecdfd7a33192d6cae08fce2c0ee1455991ed"),
})
}
func writeManifestListVariant(t *testing.T, name, modelFormat string) {
t.Helper()
configData, err := json.Marshal(model.ConfigV2{
ModelFormat: modelFormat,
Capabilities: []string{"completion"},
})
if err != nil {
t.Fatal(err)
}
configLayer, err := manifest.NewLayer(bytes.NewReader(configData), "application/vnd.docker.container.image.v1+json")
if err != nil {
t.Fatal(err)
}
modelLayer, err := manifest.NewLayer(strings.NewReader(name+" layer"), "application/vnd.ollama.image.license")
if err != nil {
t.Fatal(err)
}
if err := manifest.WriteManifest(model.ParseName(name), configLayer, []manifest.Layer{modelLayer}); err != nil {
t.Fatal(err)
}
}
func TestCreateManifestList(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
writeManifestListVariant(t, "test-gguf", manifest.FormatGGUF)
writeManifestListVariant(t, "test-safetensors", manifest.FormatSafetensors)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "test-list",
List: []string{"test-gguf", "test-safetensors"},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d: %s", w.Code, w.Body.String())
}
data, err := manifest.ReadManifestData(model.ParseName("test-list"))
if err != nil {
t.Fatal(err)
}
var parent manifest.Manifest
if err := json.Unmarshal(data, &parent); err != nil {
t.Fatal(err)
}
if parent.MediaType != manifest.MediaTypeManifestList {
t.Fatalf("mediaType = %q, want %q", parent.MediaType, manifest.MediaTypeManifestList)
}
if len(parent.Manifests) != 2 {
t.Fatalf("manifest count = %d, want 2", len(parent.Manifests))
}
selected, err := manifest.ParseNamedManifest(model.ParseName("test-list"))
if err != nil {
t.Fatal(err)
}
if selected.Config.Digest == "" {
t.Fatal("selected manifest is missing config")
}
mlxInfo, err := GetModelInfo(api.ShowRequest{Model: "test-list", Runner: manifest.RunnerMLX})
if err != nil {
t.Fatal(err)
}
if mlxInfo.Details.Format != manifest.FormatSafetensors {
t.Fatalf("mlx show format = %q, want %q", mlxInfo.Details.Format, manifest.FormatSafetensors)
}
want := map[string]string{
manifest.RunnerGGML: manifest.FormatGGUF,
manifest.RunnerMLX: manifest.FormatSafetensors,
}
for _, child := range parent.Manifests {
if got := want[child.Runner]; got != child.Format {
t.Fatalf("child runner/format = %q/%q, want one of %v", child.Runner, child.Format, want)
}
if child.BlobDigest() == "" {
t.Fatal("child manifest reference is missing digest")
}
if child.Config.Digest != "" || len(child.Layers) != 0 {
t.Fatalf("child manifest reference embedded config/layers: config=%q layers=%d", child.Config.Digest, len(child.Layers))
}
childBlob, err := manifest.BlobsPath(child.BlobDigest())
if err != nil {
t.Fatal(err)
}
childData, err := os.ReadFile(childBlob)
if err != nil {
t.Fatalf("child manifest blob missing: %v", err)
}
var resolved manifest.Manifest
if err := json.Unmarshal(childData, &resolved); err != nil {
t.Fatal(err)
}
if resolved.Config.Digest == "" || len(resolved.Layers) == 0 {
t.Fatalf("resolved child manifest missing config/layers: config=%q layers=%d", resolved.Config.Digest, len(resolved.Layers))
}
}
// The legacy downgrade anchor must reference the manifest document blobs
// so a pre-manifest-list daemon cannot garbage-collect them.
legacyPath, err := manifest.LegacyPathForName(model.ParseName("test-list"))
if err != nil {
t.Fatal(err)
}
legacyData, err := os.ReadFile(legacyPath)
if err != nil {
t.Fatalf("legacy downgrade anchor missing: %v", err)
}
var anchor manifest.Manifest
if err := json.Unmarshal(legacyData, &anchor); err != nil {
t.Fatal(err)
}
docLayers := make(map[string]string)
for _, layer := range anchor.Layers {
if layer.MediaType == manifest.MediaTypeManifestList || layer.MediaType == manifest.MediaTypeManifest {
docLayers[layer.Digest] = layer.MediaType
}
}
wantDocs := map[string]string{
"parent manifest list": manifest.MediaTypeManifestList,
"ggml child manifest": manifest.MediaTypeManifest,
"safetensors child manifest": manifest.MediaTypeManifest,
}
if len(docLayers) != len(wantDocs) {
t.Fatalf("anchor manifest document layers = %v, want %d documents", docLayers, len(wantDocs))
}
for digest := range docLayers {
if _, err := os.Stat(mustBlobsPath(t, digest)); err != nil {
t.Fatalf("anchor document %s missing: %v", digest, err)
}
}
// The anchor describes the GGML child, which is what a pre-manifest-list
// daemon would load itself.
if anchor.Runner != manifest.RunnerGGML {
t.Fatalf("anchor runner = %q, want %q", anchor.Runner, manifest.RunnerGGML)
}
}
func TestCreateManifestListRejectsAmbiguousChildren(t *testing.T) {
gin.SetMode(gin.TestMode)
for _, tt := range []struct {
name string
models []string
wantError string
}{
{
name: "duplicate digest",
models: []string{"test-gguf-a", "test-gguf-a"},
wantError: "resolve to the same manifest",
},
{
name: "duplicate runner",
models: []string{"test-gguf-a", "test-gguf-b"},
wantError: "use the same runner",
},
} {
t.Run(tt.name, func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
writeManifestListVariant(t, "test-gguf-a", manifest.FormatGGUF)
writeManifestListVariant(t, "test-gguf-b", manifest.FormatGGUF)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "test-list",
List: tt.models,
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("status code = %d, want 400: %s", w.Code, w.Body.String())
}
if !strings.Contains(w.Body.String(), tt.wantError) {
t.Fatalf("error = %s, want substring %q", w.Body.String(), tt.wantError)
}
})
}
}
func TestCreateManifestListRejectsInvalidRequests(t *testing.T) {
for _, tt := range []struct {
name string
req api.CreateRequest
wantError string
}{
{
name: "empty list",
req: api.CreateRequest{},
wantError: "must contain at least one model",
},
{
name: "from",
req: api.CreateRequest{
List: []string{"test-gguf", "test-safetensors"},
From: "base-model",
},
wantError: "cannot be combined",
},
{
name: "draft files",
req: api.CreateRequest{
List: []string{"test-gguf", "test-safetensors"},
DraftFiles: map[string]string{"draft.gguf": "sha256-test"},
},
wantError: "cannot be combined",
},
{
name: "template",
req: api.CreateRequest{
List: []string{"test-gguf", "test-safetensors"},
Template: "{{ .Prompt }}",
},
wantError: "cannot be combined",
},
{
name: "renderer",
req: api.CreateRequest{
List: []string{"test-gguf", "test-safetensors"},
Renderer: "qwen3",
},
wantError: "cannot be combined",
},
{
name: "quantize",
req: api.CreateRequest{
List: []string{"test-gguf", "test-safetensors"},
Quantize: "Q4_K_M",
},
wantError: "cannot be combined",
},
{
name: "capabilities",
req: api.CreateRequest{
List: []string{"test-gguf", "test-safetensors"}, Capabilities: []string{"decision"},
},
wantError: "cannot be combined",
},
} {
t.Run(tt.name, func(t *testing.T) {
err := validateCreateManifestListRequest(tt.req)
if err == nil {
t.Fatal("expected error")
}
if !strings.Contains(err.Error(), tt.wantError) {
t.Fatalf("error = %v, want substring %q", err, tt.wantError)
}
var requestErr manifestListRequestError
if !errors.As(err, &requestErr) {
t.Fatalf("error = %T, want manifestListRequestError so CreateHandler responds with %d", err, http.StatusBadRequest)
}
})
}
}
func TestCreateUnsetsSystem(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
System: "Say hi!",
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkManifestFiles(t, "test")
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
filepath.Join(p, "blobs", "sha256-89a2116c3a82d6a97f59f748d86ed4417214353fd178ee54df418fde32495fad"),
filepath.Join(p, "blobs", "sha256-f29e82a8284dbdf5910b1555580ff60b04238b8da9d5e51159ada67a4d0d5851"),
})
w = createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
System: "",
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkManifestFiles(t, "test")
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
filepath.Join(p, "blobs", "sha256-89a2116c3a82d6a97f59f748d86ed4417214353fd178ee54df418fde32495fad"),
})
}
func TestCreateMergeParameters(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
Parameters: map[string]any{
"temperature": 1,
"top_k": 10,
"stop": []string{"USER:", "ASSISTANT:"},
},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkManifestFiles(t, "test")
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-1d0ad71299d48c2fb7ae2b98e683643e771f8a5b72be34942af90d97a91c1e37"),
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
filepath.Join(p, "blobs", "sha256-89a2116c3a82d6a97f59f748d86ed4417214353fd178ee54df418fde32495fad"),
})
// in order to merge parameters, the second model must be created FROM the first
w = createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test2",
From: "test",
Parameters: map[string]any{
"temperature": 0.6,
"top_p": 0.7,
},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkManifestFiles(t, "test", "test2")
// Display contents of each blob in the directory
blobDir := filepath.Join(p, "blobs")
entries, err := os.ReadDir(blobDir)
if err != nil {
t.Fatalf("failed to read blobs directory: %v", err)
}
for _, entry := range entries {
blobPath := filepath.Join(blobDir, entry.Name())
content, err := os.ReadFile(blobPath)
if err != nil {
t.Fatalf("failed to read blob %s: %v", entry.Name(), err)
}
t.Logf("Contents of %s:\n%s", entry.Name(), string(content))
}
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-1d0ad71299d48c2fb7ae2b98e683643e771f8a5b72be34942af90d97a91c1e37"),
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
filepath.Join(p, "blobs", "sha256-89a2116c3a82d6a97f59f748d86ed4417214353fd178ee54df418fde32495fad"),
filepath.Join(p, "blobs", "sha256-e29a7b3c47287a2489c895d21fe413c20f859a85d20e749492f52a838e36e1ba"),
})
actual, err := os.ReadFile(filepath.Join(p, "blobs", "sha256-e29a7b3c47287a2489c895d21fe413c20f859a85d20e749492f52a838e36e1ba"))
if err != nil {
t.Fatal(err)
}
expect, err := json.Marshal(map[string]any{"temperature": 0.6, "top_k": 10, "top_p": 0.7, "stop": []string{"USER:", "ASSISTANT:"}})
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(bytes.TrimSpace(expect), bytes.TrimSpace(actual)) {
t.Errorf("expected %s, actual %s", string(expect), string(actual))
}
// slices are replaced
w = createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test2",
From: "test",
Parameters: map[string]any{
"temperature": 0.6,
"top_p": 0.7,
"stop": []string{"<|endoftext|>"},
},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkManifestFiles(t, "test", "test2")
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-12f58bb75cb3042d69a7e013ab87fb3c3c7088f50ddc62f0c77bd332f0d44d35"),
filepath.Join(p, "blobs", "sha256-1d0ad71299d48c2fb7ae2b98e683643e771f8a5b72be34942af90d97a91c1e37"),
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
filepath.Join(p, "blobs", "sha256-89a2116c3a82d6a97f59f748d86ed4417214353fd178ee54df418fde32495fad"),
})
actual, err = os.ReadFile(filepath.Join(p, "blobs", "sha256-12f58bb75cb3042d69a7e013ab87fb3c3c7088f50ddc62f0c77bd332f0d44d35"))
if err != nil {
t.Fatal(err)
}
expect, err = json.Marshal(map[string]any{"temperature": 0.6, "top_k": 10, "top_p": 0.7, "stop": []string{"<|endoftext|>"}})
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(bytes.TrimSpace(expect), bytes.TrimSpace(actual)) {
t.Errorf("expected %s, actual %s", string(expect), string(actual))
}
}
func TestCreateReplacesMessages(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
Messages: []api.Message{
{
Role: "assistant",
Content: "What is my purpose?",
},
{
Role: "user",
Content: "You run tests.",
},
{
Role: "assistant",
Content: "Oh, my god.",
},
},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkManifestFiles(t, "test")
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-298baeaf6928a60cf666d88d64a1ba606feb43a2865687c39e40652e407bffc4"),
filepath.Join(p, "blobs", "sha256-89a2116c3a82d6a97f59f748d86ed4417214353fd178ee54df418fde32495fad"),
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
})
w = createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test2",
From: "test",
Messages: []api.Message{
{
Role: "assistant",
Content: "You're a test, Harry.",
},
{
Role: "user",
Content: "I-I'm a what?",
},
{
Role: "assistant",
Content: "A test. And a thumping good one at that, I'd wager.",
},
},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkManifestFiles(t, "test", "test2")
// Old layers will not have been pruned
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
filepath.Join(p, "blobs", "sha256-298baeaf6928a60cf666d88d64a1ba606feb43a2865687c39e40652e407bffc4"),
filepath.Join(p, "blobs", "sha256-89a2116c3a82d6a97f59f748d86ed4417214353fd178ee54df418fde32495fad"),
filepath.Join(p, "blobs", "sha256-a60ecc9da299ec7ede453f99236e5577fd125e143689b646d9f0ddc9971bf4db"),
})
type message struct {
Role string `json:"role"`
Content string `json:"content"`
}
f, err := os.Open(filepath.Join(p, "blobs", "sha256-a60ecc9da299ec7ede453f99236e5577fd125e143689b646d9f0ddc9971bf4db"))
if err != nil {
t.Fatal(err)
}
defer f.Close()
var actual []message
if err := json.NewDecoder(f).Decode(&actual); err != nil {
t.Fatal(err)
}
expect := []message{
{Role: "assistant", Content: "You're a test, Harry."},
{Role: "user", Content: "I-I'm a what?"},
{Role: "assistant", Content: "A test. And a thumping good one at that, I'd wager."},
}
if !slices.Equal(actual, expect) {
t.Errorf("expected %s, actual %s", expect, actual)
}
}
func TestCreateTemplateSystem(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
Template: "{{ .System }} {{ .Prompt }}",
System: "Say bye!",
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkManifestFiles(t, "test")
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
filepath.Join(p, "blobs", "sha256-4c5f51faac758fecaff8db42f0b7382891a4d0c0bb885f7b86be88c814a7cc86"),
filepath.Join(p, "blobs", "sha256-89a2116c3a82d6a97f59f748d86ed4417214353fd178ee54df418fde32495fad"),
filepath.Join(p, "blobs", "sha256-fe7ac77b725cda2ccad03f88a880ecdfd7a33192d6cae08fce2c0ee1455991ed"),
})
template, err := os.ReadFile(filepath.Join(p, "blobs", "sha256-fe7ac77b725cda2ccad03f88a880ecdfd7a33192d6cae08fce2c0ee1455991ed"))
if err != nil {
t.Fatal(err)
}
if string(template) != "{{ .System }} {{ .Prompt }}" {
t.Errorf("expected \"{{ .System }} {{ .Prompt }}\", actual %s", template)
}
system, err := os.ReadFile(filepath.Join(p, "blobs", "sha256-4c5f51faac758fecaff8db42f0b7382891a4d0c0bb885f7b86be88c814a7cc86"))
if err != nil {
t.Fatal(err)
}
if string(system) != "Say bye!" {
t.Errorf("expected \"Say bye!\", actual %s", system)
}
t.Run("incomplete template", func(t *testing.T) {
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
Template: "{{ .Prompt",
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("expected status code 400, actual %d", w.Code)
}
})
t.Run("template with unclosed if", func(t *testing.T) {
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
Template: "{{ if .Prompt }}",
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("expected status code 400, actual %d", w.Code)
}
})
t.Run("template with undefined function", func(t *testing.T) {
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
Template: "{{ Prompt }}",
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("expected status code 400, actual %d", w.Code)
}
})
}
func TestCreateAndShowRemoteModel(t *testing.T) {
gin.SetMode(gin.TestMode)
var s Server
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "test",
From: "bob",
RemoteHost: "https://ollama.com",
Info: map[string]any{
"capabilities": []string{"completion", "tools", "thinking"},
"model_family": "gptoss",
"context_length": 131072,
"embedding_length": 2880,
"quantization_level": "MXFP4",
"parameter_size": "20.9B",
},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("exected status code 200, actual %d", w.Code)
}
w = createRequest(t, s.ShowHandler, api.ShowRequest{Model: "test"})
if w.Code != http.StatusOK {
t.Fatalf("exected status code 200, actual %d", w.Code)
}
var resp api.ShowResponse
if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
t.Fatal(err)
}
expectedDetails := api.ModelDetails{
ParentModel: "",
Format: "",
Family: "gptoss",
Families: []string{"gptoss"},
ParameterSize: "20.9B",
QuantizationLevel: "MXFP4",
}
if !reflect.DeepEqual(resp.Details, expectedDetails) {
t.Errorf("model details: expected %#v, actual %#v", expectedDetails, resp.Details)
}
expectedCaps := []model.Capability{
model.Capability("completion"),
model.Capability("tools"),
model.Capability("thinking"),
}
if !slices.Equal(resp.Capabilities, expectedCaps) {
t.Errorf("capabilities: expected %#v, actual %#v", expectedCaps, resp.Capabilities)
}
v, ok := resp.ModelInfo["gptoss.context_length"]
ctxlen := v.(float64)
if !ok || int(ctxlen) != 131072 {
t.Errorf("context len: expected %d, actual %d", 131072, int(ctxlen))
}
v, ok = resp.ModelInfo["gptoss.embedding_length"]
embedlen := v.(float64)
if !ok || int(embedlen) != 2880 {
t.Errorf("embed len: expected %d, actual %d", 2880, int(embedlen))
}
fmt.Printf("resp = %#v\n", resp)
}
func TestCreateRemoteModelRejectsDraftFiles(t *testing.T) {
gin.SetMode(gin.TestMode)
var s Server
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "test-remote-draft",
From: "bob",
RemoteHost: "https://ollama.com",
DraftFiles: map[string]string{"draft.gguf": digest},
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("expected status code 400, got %d", w.Code)
}
var resp map[string]string
if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
t.Fatal(err)
}
if resp["error"] != errRemoteDraftUnsupported.Error() {
t.Fatalf("expected error %q, got %q", errRemoteDraftUnsupported, resp["error"])
}
}
func TestCreateFromCloudSourceSuffix(t *testing.T) {
gin.SetMode(gin.TestMode)
var s Server
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "test-cloud-from-suffix",
From: "gpt-oss:20b:cloud",
Info: map[string]any{
"capabilities": []string{"completion"},
},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, got %d", w.Code)
}
w = createRequest(t, s.ShowHandler, api.ShowRequest{Model: "test-cloud-from-suffix"})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, got %d", w.Code)
}
var resp api.ShowResponse
if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
t.Fatal(err)
}
if resp.RemoteHost != "https://ollama.com:443" {
t.Fatalf("expected remote host https://ollama.com:443, got %q", resp.RemoteHost)
}
if resp.RemoteModel != "gpt-oss:20b" {
t.Fatalf("expected remote model gpt-oss:20b, got %q", resp.RemoteModel)
}
}
func TestCreateLicenses(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
License: []string{"MIT", "Apache-2.0"},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkManifestFiles(t, "test")
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-2af71558e438db0b73a20beab92dc278a94e1bbe974c00c1a33e3ab62d53a608"),
filepath.Join(p, "blobs", "sha256-89a2116c3a82d6a97f59f748d86ed4417214353fd178ee54df418fde32495fad"),
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
filepath.Join(p, "blobs", "sha256-e5dcffe836b6ec8a58e492419b550e65fb8cbdc308503979e5dacb33ac7ea3b7"),
})
mit, err := os.ReadFile(filepath.Join(p, "blobs", "sha256-e5dcffe836b6ec8a58e492419b550e65fb8cbdc308503979e5dacb33ac7ea3b7"))
if err != nil {
t.Fatal(err)
}
if string(mit) != "MIT" {
t.Errorf("expected MIT, actual %s", mit)
}
apache, err := os.ReadFile(filepath.Join(p, "blobs", "sha256-2af71558e438db0b73a20beab92dc278a94e1bbe974c00c1a33e3ab62d53a608"))
if err != nil {
t.Fatal(err)
}
if string(apache) != "Apache-2.0" {
t.Errorf("expected Apache-2.0, actual %s", apache)
}
}
func TestCreateDetectTemplate(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
t.Run("matched", func(t *testing.T) {
_, digest := createBinFile(t, gguftest.KV{
"tokenizer.chat_template": "{{ bos_token }}{% for message in messages %}{{'<|' + message['role'] + '|>' + '\n' + message['content'] + '<|end|>\n' }}{% endfor %}{% if add_generation_prompt %}{{ '<|assistant|>\n' }}{% else %}{{ eos_token }}{% endif %}",
}, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-0d79f567714c62c048378f2107fb332dabee0135d080c302d884317da9433cc5"),
filepath.Join(p, "blobs", "sha256-3322a0c650c758b7386ff55629d27d07c07b6c3d3515e259dc3e5598c41e9f4e"),
filepath.Join(p, "blobs", "sha256-35360843d0c84fb1506952a131bbef13cd2bb4a541251f22535170c05b56e672"),
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
})
})
t.Run("unmatched", func(t *testing.T) {
_, digest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
checkFileExists(t, filepath.Join(p, "blobs", "*"), []string{
filepath.Join(p, "blobs", "sha256-eb4aa77a05d4846c309cc5ccf00a3eeda12d4d207bde3ec2b597bed8a73c3a9d"),
filepath.Join(p, "blobs", "sha256-89a2116c3a82d6a97f59f748d86ed4417214353fd178ee54df418fde32495fad"),
})
})
}
func TestCreateGemma4KeepsDynamicRendererAlias(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
_, digest := createBinFile(t, gguftest.KV{
"general.architecture": "gemma4",
"general.parameter_count": uint64(25_200_000_000),
}, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
mf, err := manifest.ParseNamedManifest(model.ParseName("test"))
if err != nil {
t.Fatalf("parse manifest: %v", err)
}
if mf.Config.Digest == "" {
t.Fatalf("unexpected empty config digest for manifest")
}
configPath, err := manifest.BlobsPath(mf.Config.Digest)
if err != nil {
t.Fatalf("config blob path: %v", err)
}
cfgFile, err := os.Open(configPath)
if err != nil {
t.Fatalf("open config blob: %v", err)
}
defer cfgFile.Close()
var cfg model.ConfigV2
if err := json.NewDecoder(cfgFile).Decode(&cfg); err != nil {
t.Fatalf("decode config: %v", err)
}
if cfg.Renderer != gemma4RendererLegacy {
t.Fatalf("expected renderer %q, got %q", gemma4RendererLegacy, cfg.Renderer)
}
if cfg.Parser != "gemma4" {
t.Fatalf("expected parser %q, got %q", "gemma4", cfg.Parser)
}
}
func TestCreateLagunaDetectsRendererParser(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
_, digest := createBinFile(t, gguftest.KV{
"general.architecture": "laguna",
"general.parameter_count": uint64(33_400_000_000),
}, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: "test",
Files: map[string]string{"test.gguf": digest},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
mf, err := manifest.ParseNamedManifest(model.ParseName("test"))
if err != nil {
t.Fatalf("parse manifest: %v", err)
}
if mf.Config.Digest == "" {
t.Fatalf("unexpected empty config digest for manifest")
}
configPath, err := manifest.BlobsPath(mf.Config.Digest)
if err != nil {
t.Fatalf("config blob path: %v", err)
}
cfgFile, err := os.Open(configPath)
if err != nil {
t.Fatalf("open config blob: %v", err)
}
defer cfgFile.Close()
var cfg model.ConfigV2
if err := json.NewDecoder(cfgFile).Decode(&cfg); err != nil {
t.Fatalf("decode config: %v", err)
}
if cfg.Renderer != "laguna" {
t.Fatalf("expected renderer %q, got %q", "laguna", cfg.Renderer)
}
if cfg.Parser != "laguna" {
t.Fatalf("expected parser %q, got %q", "laguna", cfg.Parser)
}
}
func TestCreateNemotronHDefaultsRendererParser(t *testing.T) {
gin.SetMode(gin.TestMode)
for _, arch := range []string{"nemotron_h", "nemotron_h_moe", "nemotron_h_omni"} {
t.Run(arch, func(t *testing.T) {
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
_, digest := createBinFile(t, gguftest.KV{
"general.architecture": arch,
}, nil)
name := strings.ReplaceAll(arch, "_", "-")
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: name,
Files: map[string]string{"test.gguf": digest},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
cfg := readCreatedModelConfig(t, name)
if cfg.Renderer != "nemotron-3-nano" {
t.Fatalf("expected renderer %q, got %q", "nemotron-3-nano", cfg.Renderer)
}
if cfg.Parser != "nemotron-3-nano" {
t.Fatalf("expected parser %q, got %q", "nemotron-3-nano", cfg.Parser)
}
})
}
}
func TestCreateNemotronHDefaultsKeepExplicitRendererParser(t *testing.T) {
gin.SetMode(gin.TestMode)
for _, arch := range []string{"nemotron_h", "nemotron_h_moe", "nemotron_h_omni"} {
t.Run(arch, func(t *testing.T) {
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
_, digest := createBinFile(t, gguftest.KV{
"general.architecture": arch,
}, nil)
const (
renderer = "custom-renderer"
parser = "custom-parser"
)
name := strings.ReplaceAll(arch, "_", "-") + "-custom"
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Name: name,
Files: map[string]string{"test.gguf": digest},
Renderer: renderer,
Parser: parser,
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status code 200, actual %d", w.Code)
}
cfg := readCreatedModelConfig(t, name)
if cfg.Renderer != renderer {
t.Fatalf("expected renderer %q, got %q", renderer, cfg.Renderer)
}
if cfg.Parser != parser {
t.Fatalf("expected parser %q, got %q", parser, cfg.Parser)
}
})
}
}
func TestDetectModelTypeFromFiles(t *testing.T) {
t.Run("gguf file", func(t *testing.T) {
_, digest := createBinFile(t, nil, nil)
files := map[string]string{
"model.gguf": digest,
}
modelType, err := detectModelTypeFromFiles(files)
if err != nil {
t.Fatalf("detectModelTypeFromFiles() error = %v", err)
}
if modelType != "gguf" {
t.Fatalf("expected model type 'gguf', got %q", modelType)
}
})
t.Run("gguf file w/o extension", func(t *testing.T) {
_, digest := createBinFile(t, nil, nil)
files := map[string]string{
fmt.Sprintf("%x", digest): digest,
}
modelType, err := detectModelTypeFromFiles(files)
if err != nil {
t.Fatalf("detectModelTypeFromFiles() error = %v", err)
}
if modelType != "gguf" {
t.Fatalf("expected model type 'gguf', got %q", modelType)
}
})
t.Run("big-endian gguf file w/o extension", func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
digest := createTestBlob(t, []byte("FUGG"))
modelType, err := detectModelTypeFromFiles(map[string]string{"model": digest})
if err != nil {
t.Fatalf("detectModelTypeFromFiles() error = %v", err)
}
if modelType != "gguf" {
t.Fatalf("expected model type 'gguf', got %q", modelType)
}
})
t.Run("legacy ggml file w/o extension", func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
digest := createTestBlob(t, []byte("gguf"))
modelType, err := detectModelTypeFromFiles(map[string]string{"model": digest})
if err != nil {
t.Fatalf("detectModelTypeFromFiles() error = %v", err)
}
if modelType != "" {
t.Fatalf("expected empty model type for legacy GGML, got %q", modelType)
}
})
t.Run("safetensors file", func(t *testing.T) {
files := map[string]string{
"model.safetensors": "sha256:abc123",
}
modelType, err := detectModelTypeFromFiles(files)
if err != nil {
t.Fatalf("detectModelTypeFromFiles() error = %v", err)
}
if modelType != "safetensors" {
t.Fatalf("expected model type 'safetensors', got %q", modelType)
}
})
t.Run("safetensors file with sidecars", func(t *testing.T) {
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
configDigest := createTestBlob(t, []byte(`{"model_type":"test"}`))
files := map[string]string{
"model.safetensors": "sha256:abc123",
"config.json": configDigest,
}
modelType, err := detectModelTypeFromFiles(files)
if err != nil {
t.Fatalf("detectModelTypeFromFiles() error = %v", err)
}
if modelType != "safetensors" {
t.Fatalf("expected model type 'safetensors', got %q", modelType)
}
})
t.Run("mixed file types", func(t *testing.T) {
files := map[string]string{
"model.gguf": "sha256:abc123",
"model.safetensors": "sha256:def456",
}
_, err := detectModelTypeFromFiles(files)
if !errors.Is(err, errMixedModelTypes) {
t.Fatalf("detectModelTypeFromFiles() error = %v, want errMixedModelTypes", err)
}
})
t.Run("unsupported file type", func(t *testing.T) {
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
data := []byte("12345678")
digest := fmt.Sprintf("sha256:%x", sha256.Sum256(data))
if err := os.MkdirAll(filepath.Join(p, "blobs"), 0o755); err != nil {
t.Fatal(err)
}
f, err := os.Create(filepath.Join(p, "blobs", fmt.Sprintf("sha256-%s", strings.TrimPrefix(digest, "sha256:"))))
if err != nil {
t.Fatal(err)
}
defer f.Close()
if _, err := f.Write(data); err != nil {
t.Fatal(err)
}
files := map[string]string{
"model.bin": digest,
}
modelType, err := detectModelTypeFromFiles(files)
if err != nil {
t.Fatalf("detectModelTypeFromFiles() error = %v", err)
}
if modelType != "" {
t.Fatalf("expected empty model type for unsupported file, got %q", modelType)
}
})
t.Run("file with less than 4 bytes", func(t *testing.T) {
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
data := []byte("123")
digest := fmt.Sprintf("sha256:%x", sha256.Sum256(data))
if err := os.MkdirAll(filepath.Join(p, "blobs"), 0o755); err != nil {
t.Fatal(err)
}
f, err := os.Create(filepath.Join(p, "blobs", fmt.Sprintf("sha256-%s", strings.TrimPrefix(digest, "sha256:"))))
if err != nil {
t.Fatal(err)
}
defer f.Close()
if _, err := f.Write(data); err != nil {
t.Fatal(err)
}
files := map[string]string{
"noext": digest,
}
modelType, err := detectModelTypeFromFiles(files)
if err != nil {
t.Fatalf("detectModelTypeFromFiles() error = %v", err)
}
if modelType != "" {
t.Fatalf("expected empty model type for small file, got %q", modelType)
}
})
t.Run("blob read error", func(t *testing.T) {
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
digest := "sha256:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
blobPath, err := manifest.BlobsPath(digest)
if err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(blobPath, 0o755); err != nil {
t.Fatal(err)
}
_, err = detectModelTypeFromFiles(map[string]string{
"noext": digest,
})
if err == nil {
t.Fatal("detectModelTypeFromFiles() error = nil, want blob read error")
}
if !strings.Contains(err.Error(), "read noext") {
t.Fatalf("detectModelTypeFromFiles() error = %v, want read noext", err)
}
})
}
// createTestBlob creates a blob in the blobs directory and returns its digest.
func createTestBlob(t *testing.T, data []byte) string {
t.Helper()
digest := fmt.Sprintf("sha256:%x", sha256.Sum256(data))
blobPath, err := manifest.BlobsPath(digest)
if err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(filepath.Dir(blobPath), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(blobPath, data, 0o644); err != nil {
t.Fatal(err)
}
return digest
}
func TestHeadBlobHandler(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
digest := createTestBlob(t, []byte("blob"))
missingDigest := "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
tests := []struct {
name string
digest string
status int
}{
{
name: "exists",
digest: digest,
status: http.StatusOK,
},
{
name: "missing",
digest: missingDigest,
status: http.StatusNotFound,
},
{
name: "invalid digest",
digest: "not-a-digest",
status: http.StatusBadRequest,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
w := headBlobRequest(t, &s, tt.digest)
if w.Code != tt.status {
t.Fatalf("status = %d, want %d; body: %s", w.Code, tt.status, w.Body.String())
}
})
}
}
func TestHeadBlobHandlerReturnsStatErrors(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("chmod permission semantics differ on windows")
}
if os.Geteuid() == 0 {
t.Skip("root can stat through chmod 0 directories")
}
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
digest := "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
blobPath, err := manifest.BlobsPath(digest)
if err != nil {
t.Fatal(err)
}
blobDir := filepath.Dir(blobPath)
if err := os.MkdirAll(blobDir, 0o755); err != nil {
t.Fatal(err)
}
if err := os.Chmod(blobDir, 0); err != nil {
t.Fatal(err)
}
t.Cleanup(func() {
if err := os.Chmod(blobDir, 0o755); err != nil {
t.Logf("failed to restore blob directory permissions: %v", err)
}
})
w := headBlobRequest(t, &s, digest)
if w.Code != http.StatusInternalServerError {
t.Fatalf("status = %d, want %d; body: %s", w.Code, http.StatusInternalServerError, w.Body.String())
}
}
func headBlobRequest(t *testing.T, s *Server, digest string) *httptest.ResponseRecorder {
t.Helper()
router := gin.New()
router.HEAD("/api/blobs/:digest", s.HeadBlobHandler)
w := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodHead, "/api/blobs/"+digest, nil)
router.ServeHTTP(w, req)
return w
}
func createTestSafetensorsBlob(t *testing.T, tensors []*st.TensorData) string {
t.Helper()
data, err := io.ReadAll(st.BuildPackedSafetensorsReader(tensors))
if err != nil {
t.Fatalf("failed to build safetensors: %v", err)
}
return createTestBlob(t, data)
}
func createTestLayerInfo(t *testing.T, name, mediaType string, data []byte) create.LayerInfo {
t.Helper()
return create.LayerInfo{
Name: name,
MediaType: mediaType,
Digest: createTestBlob(t, data),
Size: int64(len(data)),
}
}
func TestCreateSafetensorsRejectsUnsupportedArchitecture(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
modelDigest := createTestSafetensorsBlob(t, []*st.TensorData{
st.NewTensorDataFromBytes("model.embed_tokens.weight", "BF16", []int32{8, 8}, make([]byte, 8*8*2)),
})
configDigest := createTestBlob(t, []byte(`{"architectures":["UnsupportedForCausalLM"]}`))
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "unsupported-safetensors",
Files: map[string]string{
"model.safetensors": modelDigest,
"config.json": configDigest,
},
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want %d: %s", w.Code, http.StatusBadRequest, w.Body.String())
}
if !strings.Contains(w.Body.String(), create.ErrUnsupportedMLXArchitecture.Error()) {
t.Fatalf("response = %s, want unsupported architecture error", w.Body.String())
}
if _, err := manifest.ParseNamedManifest(model.ParseName("unsupported-safetensors")); !errors.Is(err, os.ErrNotExist) {
t.Fatalf("unsupported model was created: %v", err)
}
}
func TestCreateSafetensorsRejectsInvalidInfo(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
modelDigest := createTestSafetensorsBlob(t, []*st.TensorData{
st.NewTensorDataFromBytes("model.embed_tokens.weight", "BF16", []int32{8, 8}, make([]byte, 8*8*2)),
})
configDigest := createTestBlob(t, []byte(`{"architectures":["Qwen3ForCausalLM"]}`))
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "invalid-info-safetensors",
Files: map[string]string{
"model.safetensors": modelDigest,
"config.json": configDigest,
},
Info: map[string]any{"context_length": 1.5},
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want %d: %s", w.Code, http.StatusBadRequest, w.Body.String())
}
if !strings.Contains(w.Body.String(), "context_length") {
t.Fatalf("response = %s, want context_length error", w.Body.String())
}
}
func TestCreateSafetensorsRejectsInvalidRequires(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
modelDigest := createTestSafetensorsBlob(t, []*st.TensorData{
st.NewTensorDataFromBytes("model.embed_tokens.weight", "BF16", []int32{8, 8}, make([]byte, 8*8*2)),
})
configDigest := createTestBlob(t, []byte(`{"architectures":["Qwen3ForCausalLM"]}`))
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "invalid-requires-safetensors",
Files: map[string]string{
"model.safetensors": modelDigest,
"config.json": configDigest,
},
Requires: "not-semver",
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want %d: %s", w.Code, http.StatusBadRequest, w.Body.String())
}
if !strings.Contains(w.Body.String(), "not valid semantic version") {
t.Fatalf("response = %s, want requires error", w.Body.String())
}
}
func TestCreateSafetensorsRuntimeErrorHidesLoaderDetails(t *testing.T) {
err := fmt.Errorf("%w: searched /private/server/path", mlxrunner.ErrRuntimeUnavailable)
resp := createSafetensorsErrorResponse(err)
if got, want := resp["status"], http.StatusServiceUnavailable; got != want {
t.Fatalf("status = %v, want %v", got, want)
}
if got, want := resp["error"], mlxrunner.ErrRuntimeUnavailable.Error(); got != want {
t.Fatalf("error = %q, want %q", got, want)
}
}
func TestCreateSafetensorsRejectsMissingBlob(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
digest := "sha256:" + strings.Repeat("0", 64)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "missing-safetensors",
Files: map[string]string{"model.safetensors": digest},
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want %d: %s", w.Code, http.StatusBadRequest, w.Body.String())
}
if !strings.Contains(w.Body.String(), "blob not found") {
t.Fatalf("response = %s, want missing blob error", w.Body.String())
}
}
func TestWriteSafetensorsManifestPreservesRequestMetadata(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
r := api.CreateRequest{
Model: "uploaded-safetensors",
Capabilities: []string{"decision", "completion", "decision"},
Info: map[string]any{
"capabilities": []string{"completion", "thinking"},
},
Renderer: "test-renderer",
Parser: "test-parser",
Requires: "0.20.0",
System: "server-side import",
}
config := &model.ConfigV2{Renderer: r.Renderer, Parser: r.Parser, Requires: r.Requires}
if err := applyCreateInfo(config, r.Info); err != nil {
t.Fatal(err)
}
tensorData := []byte("tensor")
configData := []byte(`{"architectures":["TestModel"]}`)
tokenizerData := []byte(`{"version":"1.0"}`)
info := create.ManifestInfo{Layers: []create.LayerInfo{
createTestLayerInfo(t, "model.embed_tokens.weight", manifest.MediaTypeImageTensor, tensorData),
createTestLayerInfo(t, "config.json", "application/vnd.ollama.image.json", configData),
createTestLayerInfo(t, "tokenizer.json", "application/vnd.ollama.image.json", tokenizerData),
}}
info.ModelConfig = *config
if err := writeSafetensorsManifest(r, "", func(api.ProgressResponse) {})(context.Background(), r.Model, info); err != nil {
t.Fatal(err)
}
cfg := readCreatedModelConfig(t, "uploaded-safetensors")
if cfg.ModelFormat != "safetensors" {
t.Fatalf("ModelFormat = %q, want safetensors", cfg.ModelFormat)
}
if cfg.Parser != "test-parser" || cfg.Renderer != "test-renderer" {
t.Fatalf("parser/renderer = %q/%q, want test-parser/test-renderer", cfg.Parser, cfg.Renderer)
}
if cfg.Requires != "0.20.0" {
t.Fatalf("Requires = %q, want 0.20.0", cfg.Requires)
}
if want := []string{"completion", "thinking", "decision"}; !slices.Equal(cfg.Capabilities, want) {
t.Fatalf("Capabilities = %v, want %v", cfg.Capabilities, want)
}
mf, err := manifest.ParseNamedManifest(model.ParseName("uploaded-safetensors"))
if err != nil {
t.Fatalf("parse manifest: %v", err)
}
layerNames := map[string]string{}
for _, l := range mf.Layers {
layerNames[l.Name] = l.MediaType
}
if got := layerNames["model.embed_tokens.weight"]; got != manifest.MediaTypeImageTensor {
t.Fatalf("tensor layer media type = %q, want %q", got, manifest.MediaTypeImageTensor)
}
for _, name := range []string{"config.json", "tokenizer.json"} {
if layerNames[name] != "application/vnd.ollama.image.json" {
t.Fatalf("layer %q media type = %q, want image json", name, layerNames[name])
}
}
for _, l := range mf.Layers {
if l.MediaType == "application/vnd.ollama.image.system" {
return
}
}
t.Fatal("missing system layer")
}
func TestCreateSafetensorsRejectedReplacementPreservesOldModel(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
_, oldDigest := createBinFile(t, nil, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "replace-with-safetensors",
Files: map[string]string{"model.gguf": oldDigest},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("create GGUF status = %d, want %d: %s", w.Code, http.StatusOK, w.Body.String())
}
oldBlob, err := manifest.BlobsPath(oldDigest)
if err != nil {
t.Fatal(err)
}
if _, err := os.Stat(oldBlob); err != nil {
t.Fatalf("stat old GGUF blob: %v", err)
}
modelDigest := createTestSafetensorsBlob(t, []*st.TensorData{
st.NewTensorDataFromBytes("model.embed_tokens.weight", "BF16", []int32{8, 8}, make([]byte, 8*8*2)),
})
configDigest := createTestBlob(t, []byte(`{"architectures":["TestModel"],"model_type":"test"}`))
w = createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "replace-with-safetensors",
Files: map[string]string{
"model.safetensors": modelDigest,
"config.json": configDigest,
},
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("replace with unsupported Safetensors status = %d, want %d: %s", w.Code, http.StatusBadRequest, w.Body.String())
}
if _, err := os.Stat(oldBlob); err != nil {
t.Fatalf("old GGUF blob was removed after rejected replacement: %v", err)
}
mf, err := manifest.ParseNamedManifest(model.ParseName("replace-with-safetensors"))
if err != nil {
t.Fatal(err)
}
if len(mf.Layers) == 0 || mf.Layers[0].Digest != oldDigest {
t.Fatalf("manifest layers = %#v, want original GGUF %s", mf.Layers, oldDigest)
}
}
func TestWriteSafetensorsManifestIncludesDraft(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
draftDir := t.TempDir()
if err := os.WriteFile(filepath.Join(draftDir, "config.json"), []byte(`{"architectures":["TestDraftModel"],"model_type":"test_draft"}`), 0o600); err != nil {
t.Fatal(err)
}
mainData := []byte("main tensor")
draftData := []byte("draft tensor")
draftConfig := []byte(`{"architectures":["TestDraftModel"]}`)
info := create.ManifestInfo{Layers: []create.LayerInfo{
createTestLayerInfo(t, "model.embed_tokens.weight", manifest.MediaTypeImageTensor, mainData),
createTestLayerInfo(t, "draft.model.embed_tokens.weight", manifest.MediaTypeImageTensor, draftData),
createTestLayerInfo(t, "draft/config.json", "application/vnd.ollama.image.json", draftConfig),
}}
name := "uploaded-safetensors-with-draft"
if err := writeSafetensorsManifest(api.CreateRequest{Model: name}, draftDir, func(api.ProgressResponse) {})(context.Background(), name, info); err != nil {
t.Fatal(err)
}
cfg := readCreatedModelConfig(t, name)
if cfg.Draft == nil {
t.Fatal("created config is missing draft metadata")
}
if cfg.Draft.Architecture != "TestDraftModel" || cfg.Draft.TensorPrefix != "draft." || cfg.Draft.Config != "draft/config.json" {
t.Fatalf("draft metadata = %#v, want TestDraftModel with draft tensor/config prefixes", cfg.Draft)
}
mf, err := manifest.ParseNamedManifest(model.ParseName(name))
if err != nil {
t.Fatal(err)
}
gotLayers := make(map[string]bool)
for _, layer := range mf.Layers {
gotLayers[layer.Name] = true
}
for _, name := range []string{"model.embed_tokens.weight", "draft.model.embed_tokens.weight", "draft/config.json"} {
if !gotLayers[name] {
t.Fatalf("created manifest is missing layer %q", name)
}
}
}
func TestCreateSafetensorsWithDraft(t *testing.T) {
if err := mlxrunner.CheckRuntime(); err != nil {
t.Skipf("MLX not available: %v", err)
}
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
modelDigest := createTestSafetensorsBlob(t, []*st.TensorData{
st.NewTensorDataFromBytes("model.embed_tokens.weight", "BF16", []int32{8, 8}, make([]byte, 8*8*2)),
})
modelConfigDigest := createTestBlob(t, []byte(`{"architectures":["Qwen3ForCausalLM"]}`))
draftDigest := createTestSafetensorsBlob(t, []*st.TensorData{
st.NewTensorDataFromBytes("model.embed_tokens.weight", "BF16", []int32{8, 8}, make([]byte, 8*8*2)),
})
draftConfigDigest := createTestBlob(t, []byte(`{"architectures":["DFlashDraftModel"]}`))
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "uploaded-safetensors-with-draft",
Files: map[string]string{
"model.safetensors": modelDigest,
"config.json": modelConfigDigest,
},
DraftFiles: map[string]string{
"model.safetensors": draftDigest,
"config.json": draftConfigDigest,
},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("status = %d, want %d: %s", w.Code, http.StatusOK, w.Body.String())
}
cfg := readCreatedModelConfig(t, "uploaded-safetensors-with-draft")
if cfg.Draft == nil || cfg.Draft.Architecture != "DFlashDraftModel" {
t.Fatalf("draft config = %#v, want DFlashDraftModel", cfg.Draft)
}
mf, err := manifest.ParseNamedManifest(model.ParseName("uploaded-safetensors-with-draft"))
if err != nil {
t.Fatal(err)
}
wantLayers := map[string]bool{
"model.embed_tokens.weight": false,
"draft.model.embed_tokens.weight": false,
"draft/config.json": false,
}
for _, layer := range mf.Layers {
if _, ok := wantLayers[layer.Name]; ok {
wantLayers[layer.Name] = true
}
}
for name, found := range wantLayers {
if !found {
t.Errorf("created manifest is missing layer %q", name)
}
}
}
func TestCreateSafetensorsRejectsUnsupportedInputs(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
t.Run("from overlay", func(t *testing.T) {
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "uploaded-safetensors",
From: "llama3.2",
Files: map[string]string{"model.safetensors": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"},
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("expected status 400, got %d: %s", w.Code, w.Body.String())
}
if !strings.Contains(w.Body.String(), errSafetensorsFrom.Error()) {
t.Fatalf("expected FROM error, got %s", w.Body.String())
}
})
t.Run("adapters", func(t *testing.T) {
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "uploaded-safetensors",
Files: map[string]string{"model.safetensors": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"},
Adapters: map[string]string{"adapter.gguf": "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"},
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("expected status 400, got %d: %s", w.Code, w.Body.String())
}
if !strings.Contains(w.Body.String(), errAdaptersUnsupported.Error()) {
t.Fatalf("expected adapters error, got %s", w.Body.String())
}
})
}
func TestCreateRejectsInvalidLicense(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
_, digest := createBinFile(t, nil, nil)
for name, license := range map[string]any{
"number": 42,
"mixed list": []any{"MIT", 7},
} {
t.Run(name, func(t *testing.T) {
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "invalid-license",
Files: map[string]string{"test.gguf": digest},
License: license,
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want %d: %s", w.Code, http.StatusBadRequest, w.Body.String())
}
if !strings.Contains(w.Body.String(), create.ErrInvalidLicense.Error()) {
t.Fatalf("response = %s, want invalid license error", w.Body.String())
}
})
}
}
func TestCreateRejectsAdapterGGUF(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
_, digest := createBinFile(t, map[string]any{"general.type": "adapter"}, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "adapter-model",
Files: map[string]string{"adapter.gguf": digest},
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want %d: %s", w.Code, http.StatusBadRequest, w.Body.String())
}
if !strings.Contains(w.Body.String(), errAdaptersUnsupported.Error()) {
t.Fatalf("response = %s, want adapters unsupported error", w.Body.String())
}
}
func TestCreateDetectModelTypeErrors(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
t.Run("missing blob is a bad request", func(t *testing.T) {
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "missing-blob",
Files: map[string]string{"model": "sha256:" + strings.Repeat("0", 64)},
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want %d: %s", w.Code, http.StatusBadRequest, w.Body.String())
}
if !strings.Contains(w.Body.String(), "blob not found") {
t.Fatalf("response = %s, want missing blob error", w.Body.String())
}
})
t.Run("unreadable blob is a server error", func(t *testing.T) {
// A directory in the blob's place makes the magic-byte read fail with
// something other than "not found".
digest := "sha256:" + strings.Repeat("1", 64)
blobPath, err := manifest.BlobsPath(digest)
if err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(blobPath, 0o755); err != nil {
t.Fatal(err)
}
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "unreadable-blob",
Files: map[string]string{"model": digest},
Stream: &stream,
})
if w.Code != http.StatusInternalServerError {
t.Fatalf("status = %d, want %d: %s", w.Code, http.StatusInternalServerError, w.Body.String())
}
})
}
func TestConvertModelFromFilesHonorsContext(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
_, digest := createBinFile(t, nil, nil)
ctx, cancel := context.WithCancel(t.Context())
cancel()
_, err := convertModelFromFiles(ctx, map[string]string{"test.gguf": digest}, func(api.ProgressResponse) {})
if !errors.Is(err, context.Canceled) {
t.Fatalf("convertModelFromFiles() error = %v, want context.Canceled", err)
}
}
// createSafetensorsTestModel creates a minimal safetensors model manifest for testing.
func createSafetensorsTestModel(t *testing.T, modelName string, config model.ConfigV2, extraLayers []manifest.Layer) {
t.Helper()
// Create a fake tensor blob
tensorData := []byte("fake-tensor-data-for-testing")
tensorDigest := createTestBlob(t, tensorData)
layers := []manifest.Layer{
{
MediaType: manifest.MediaTypeImageTensor,
Digest: tensorDigest,
Size: int64(len(tensorData)),
Name: "model.embed_tokens.weight",
},
}
layers = append(layers, extraLayers...)
configLayer, err := createConfigLayer(config)
if err != nil {
t.Fatalf("failed to create config layer: %v", err)
}
name := model.ParseName(modelName)
if err := manifest.WriteManifest(name, *configLayer, layers); err != nil {
t.Fatalf("failed to write manifest: %v", err)
}
}
func TestCreateFromSafetensorsModel_PreservesConfig(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
sourceConfig := model.ConfigV2{
ModelFormat: "safetensors",
ModelFamily: "gemma3",
ModelFamilies: []string{"gemma3", "gemma"},
ModelType: "4B",
FileType: "nvfp4",
Renderer: "gemma3",
Parser: "gemma3",
Requires: "0.19.0",
Capabilities: []string{"completion", "vision"},
ContextLen: 131072,
EmbedLen: 2560,
BaseName: "gemma-3",
Draft: &model.Draft{
ModelFormat: "safetensors",
Architecture: "gemma3_mtp",
TensorPrefix: "draft.",
Config: "draft/config.json",
},
}
createSafetensorsTestModel(t, "source-model", sourceConfig, nil)
// Create a derived model FROM the source
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "derived-model",
From: "source-model",
System: "You are a pirate.",
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d: %s", w.Code, w.Body.String())
}
// Read the derived model's config
derivedName := model.ParseName("derived-model")
mf, err := manifest.ParseNamedManifest(derivedName)
if err != nil {
t.Fatalf("failed to parse derived manifest: %v", err)
}
configBlobPath, err := manifest.BlobsPath(mf.Config.Digest)
if err != nil {
t.Fatalf("failed to get config blob path: %v", err)
}
configBlob, err := os.ReadFile(configBlobPath)
if err != nil {
t.Fatalf("failed to read config blob: %v", err)
}
var cfg model.ConfigV2
if err := json.Unmarshal(configBlob, &cfg); err != nil {
t.Fatalf("failed to unmarshal config: %v", err)
}
if diff := gocmp.Diff(sourceConfig, cfg); diff != "" {
t.Fatalf("derived config mismatch (-want +got):\n%s", diff)
}
// Verify system prompt was added
var hasSystem bool
for _, l := range mf.Layers {
if l.MediaType == "application/vnd.ollama.image.system" {
hasSystem = true
break
}
}
if !hasSystem {
t.Error("expected system prompt layer in derived model")
}
// Verify tensor layers were copied with names preserved
var tensorNames []string
for _, l := range mf.Layers {
if l.MediaType == manifest.MediaTypeImageTensor {
tensorNames = append(tensorNames, l.Name)
}
}
if len(tensorNames) == 0 {
t.Error("expected tensor layers in derived model")
}
for _, name := range tensorNames {
if name == "" {
t.Error("tensor layer has empty name — names must be preserved from source")
}
}
}
func TestCreateFromSafetensorsModel_AppliesOnlyExplicitOverrides(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
sourceConfig := model.ConfigV2{
ModelFormat: "safetensors",
ModelFamily: "qwen35",
ModelFamilies: []string{"qwen35"},
ModelType: "2B",
FileType: "nvfp4",
Renderer: "source-renderer",
Parser: "source-parser",
Requires: "0.19.0",
Capabilities: []string{"completion", "vision", "thinking"},
ContextLen: 262144,
EmbedLen: 2048,
BaseName: "qwen3.5",
}
createSafetensorsTestModel(t, "source-overrides", sourceConfig, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "derived-overrides",
From: "source-overrides",
Renderer: "request-renderer",
Parser: "request-parser",
Requires: "0.20.0",
Info: map[string]any{
"capabilities": []string{"completion"},
},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("create status = %d, want %d: %s", w.Code, http.StatusOK, w.Body.String())
}
want := sourceConfig
want.Renderer = "request-renderer"
want.Parser = "request-parser"
want.Requires = "0.20.0"
want.Capabilities = []string{"completion"}
if diff := gocmp.Diff(want, readCreatedModelConfig(t, "derived-overrides")); diff != "" {
t.Fatalf("derived config mismatch (-want +got):\n%s", diff)
}
}
func TestCreateFromRemoteModelPreservesRoutingAndMetadata(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "remote-source",
From: "upstream-model",
RemoteHost: "https://ollama.com",
Info: map[string]any{
"capabilities": []string{"completion", "tools"},
"model_family": "gptoss",
"base_name": "gpt-oss",
"context_length": 131072,
"embedding_length": 2880,
"quantization_level": "MXFP4",
"parameter_size": "20.9B",
},
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("create remote source status = %d, want %d: %s", w.Code, http.StatusOK, w.Body.String())
}
sourceConfig := readCreatedModelConfig(t, "remote-source")
w = createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "remote-derived",
From: "remote-source",
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("create derived remote status = %d, want %d: %s", w.Code, http.StatusOK, w.Body.String())
}
if diff := gocmp.Diff(sourceConfig, readCreatedModelConfig(t, "remote-derived")); diff != "" {
t.Fatalf("derived remote config mismatch (-want +got):\n%s", diff)
}
}
func TestCreateFromModelRejectsCorruptConfig(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
configLayer, err := manifest.NewLayer(strings.NewReader("{"), "application/vnd.docker.container.image.v1+json")
if err != nil {
t.Fatal(err)
}
tensorDigest := createTestBlob(t, []byte("tensor"))
if err := manifest.WriteManifest(model.ParseName("corrupt-source"), configLayer, []manifest.Layer{{
MediaType: manifest.MediaTypeImageTensor,
Digest: tensorDigest,
Size: int64(len("tensor")),
Name: "model.weight",
}}); err != nil {
t.Fatal(err)
}
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "corrupt-derived",
From: "corrupt-source",
Stream: &stream,
})
if w.Code == http.StatusOK {
t.Fatalf("create status = %d, want failure: %s", w.Code, w.Body.String())
}
if !strings.Contains(w.Body.String(), "decode config") {
t.Fatalf("create error = %s, want config decode failure", w.Body.String())
}
if _, err := manifest.ParseNamedManifest(model.ParseName("corrupt-derived")); !errors.Is(err, os.ErrNotExist) {
t.Fatalf("derived manifest exists after rejected create: %v", err)
}
}
func TestCreateFromSafetensorsModel_OverrideSystem(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
systemLayer, err := manifest.NewLayer(strings.NewReader("Original system prompt"), "application/vnd.ollama.image.system")
if err != nil {
t.Fatal(err)
}
createSafetensorsTestModel(t, "source-with-system", model.ConfigV2{
ModelFormat: "safetensors",
Capabilities: []string{"completion"},
}, []manifest.Layer{systemLayer})
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "derived-new-system",
From: "source-with-system",
System: "New system prompt",
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d: %s", w.Code, w.Body.String())
}
derivedName := model.ParseName("derived-new-system")
mf, err := manifest.ParseNamedManifest(derivedName)
if err != nil {
t.Fatalf("failed to parse derived manifest: %v", err)
}
cfg := readCreatedModelConfig(t, "derived-new-system")
if cfg.ModelFormat != "safetensors" {
t.Errorf("ModelFormat = %q, want %q", cfg.ModelFormat, "safetensors")
}
var systems []string
for _, layer := range mf.Layers {
if layer.MediaType != "application/vnd.ollama.image.system" {
continue
}
f, err := layer.Open()
if err != nil {
t.Fatal(err)
}
b, readErr := io.ReadAll(f)
closeErr := f.Close()
if readErr != nil {
t.Fatal(readErr)
}
if closeErr != nil {
t.Fatal(closeErr)
}
systems = append(systems, string(b))
}
if diff := gocmp.Diff([]string{"New system prompt"}, systems); diff != "" {
t.Fatalf("system layers mismatch (-want +got):\n%s", diff)
}
}
func TestCreateFromModelRejectsInvalidTemplate(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
var s Server
createSafetensorsTestModel(t, "template-source", model.ConfigV2{
ModelFormat: "safetensors",
Capabilities: []string{"completion"},
}, nil)
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "invalid-template",
From: "template-source",
Template: "{{ if .Prompt }}",
Stream: &stream,
})
if w.Code != http.StatusBadRequest {
t.Fatalf("create status = %d, want %d: %s", w.Code, http.StatusBadRequest, w.Body.String())
}
if !strings.Contains(w.Body.String(), "template error") {
t.Fatalf("create error = %s, want template error", w.Body.String())
}
}
func TestCreateFromSafetensorsModel_PreservesLayerNames(t *testing.T) {
gin.SetMode(gin.TestMode)
p := t.TempDir()
t.Setenv("OLLAMA_MODELS", p)
var s Server
// Create JSON config blobs to include as layers
configJSON := []byte(`{"architectures": ["LlamaForCausalLM"], "model_type": "llama"}`)
configDigest := createTestBlob(t, configJSON)
tokenizerJSON := []byte(`{"version": "1.0"}`)
tokenizerDigest := createTestBlob(t, tokenizerJSON)
extraLayers := []manifest.Layer{
{
MediaType: "application/vnd.ollama.image.json",
Digest: configDigest,
Size: int64(len(configJSON)),
Name: "config.json",
},
{
MediaType: "application/vnd.ollama.image.json",
Digest: tokenizerDigest,
Size: int64(len(tokenizerJSON)),
Name: "tokenizer.json",
},
}
createSafetensorsTestModel(t, "source-named-layers", model.ConfigV2{
ModelFormat: "safetensors",
Capabilities: []string{"completion"},
}, extraLayers)
// Create derived model
w := createRequest(t, s.CreateHandler, api.CreateRequest{
Model: "derived-named-layers",
From: "source-named-layers",
Stream: &stream,
})
if w.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d: %s", w.Code, w.Body.String())
}
derivedName := model.ParseName("derived-named-layers")
mf, err := manifest.ParseNamedManifest(derivedName)
if err != nil {
t.Fatalf("failed to parse derived manifest: %v", err)
}
// Check tensor layer names are preserved
for _, l := range mf.Layers {
if l.MediaType == manifest.MediaTypeImageTensor && l.Name == "" {
t.Error("tensor layer has empty name — names must be preserved from source")
}
}
// Check JSON layer names are preserved
jsonNames := make(map[string]bool)
for _, l := range mf.Layers {
if l.MediaType == "application/vnd.ollama.image.json" && l.Name != "" {
jsonNames[l.Name] = true
}
}
if !jsonNames["config.json"] {
t.Error("config.json layer name not preserved in derived model")
}
if !jsonNames["tokenizer.json"] {
t.Error("tokenizer.json layer name not preserved in derived model")
}
}
func mustBlobsPath(t *testing.T, digest string) string {
t.Helper()
path, err := manifest.BlobsPath(digest)
if err != nil {
t.Fatal(err)
}
return path
}
func writeDriftVariant(t *testing.T, name, format string, config model.ConfigV2) {
t.Helper()
configData, err := json.Marshal(config)
if err != nil {
t.Fatal(err)
}
configLayer, err := manifest.NewLayer(bytes.NewReader(configData), "application/vnd.docker.container.image.v1+json")
if err != nil {
t.Fatal(err)
}
var layers []manifest.Layer
switch format {
case manifest.FormatGGUF:
_, digest := createBinFile(t, map[string]any{"general.architecture": "test"}, nil)
modelLayer, err := manifest.NewLayerFromLayer(digest, "application/vnd.ollama.image.model", name)
if err != nil {
t.Fatal(err)
}
layers = append(layers, modelLayer)
case manifest.FormatSafetensors:
layers = append(layers, createShowSafetensorsLayer(t, name+".weight", []int64{2, 2}))
}
if err := manifest.WriteManifest(model.ParseName(name), configLayer, layers); err != nil {
t.Fatal(err)
}
}
func driftWarnings(t *testing.T, name string, children []model.ConfigV2) []string {
t.Helper()
for i, child := range children {
writeDriftVariant(t, fmt.Sprintf("drift-%d", i), child.ModelFormat, child)
}
refs := make([]string, len(children))
for i := range children {
refs[i] = fmt.Sprintf("drift-%d", i)
}
var warnings []string
err := createManifestList(api.CreateRequest{Name: name, List: refs}, model.ParseName(name), func(resp api.ProgressResponse) {
if strings.HasPrefix(resp.Status, "warning:") {
warnings = append(warnings, resp.Status)
}
})
if err != nil {
t.Fatalf("createManifestList() error = %v", err)
}
return warnings
}
func TestCreateManifestListWarnsOnDrift(t *testing.T) {
gin.SetMode(gin.TestMode)
t.Setenv("OLLAMA_MODELS", t.TempDir())
baseConfig := func(format string) model.ConfigV2 {
return model.ConfigV2{
ModelFormat: format,
ModelFamily: "testfam",
ModelFamilies: []string{"testfam"},
ModelType: "1B",
FileType: "Q4_K_M",
ContextLen: 8192,
EmbedLen: 2048,
Parser: "test",
Renderer: "test",
Capabilities: []string{"completion"},
}
}
tests := []struct {
name string
mutate func(config *model.ConfigV2)
wantSubstring string
}{
{
name: "context length drift",
mutate: func(config *model.ConfigV2) {
config.ContextLen = 131072
},
wantSubstring: "context length: drift-0=8192, drift-1=131072",
},
{
name: "model family drift",
mutate: func(config *model.ConfigV2) {
config.ModelFamily = "otherfam"
config.ModelFamilies = []string{"otherfam"}
},
wantSubstring: "model family: drift-0=testfam, drift-1=otherfam",
},
{
name: "parameter size drift",
mutate: func(config *model.ConfigV2) {
config.ModelType = "7B"
},
wantSubstring: "parameter size: drift-0=1B, drift-1=7B",
},
{
name: "quantization class drift",
mutate: func(config *model.ConfigV2) {
config.FileType = "Q8_0"
},
wantSubstring: "quantization class: drift-0=Q4_K_M (4-bit), drift-1=Q8_0 (8-bit)",
},
{
name: "parser drift",
mutate: func(config *model.ConfigV2) {
config.Parser = "other"
},
wantSubstring: "parser: drift-0=test, drift-1=other",
},
{
name: "renderer drift",
mutate: func(config *model.ConfigV2) {
config.Renderer = "other"
},
wantSubstring: "renderer: drift-0=test, drift-1=other",
},
{
name: "capabilities drift",
mutate: func(config *model.ConfigV2) {
config.Capabilities = []string{"completion", "tools"}
},
wantSubstring: "capabilities: drift-0=[completion], drift-1=[completion tools]",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
first := baseConfig(manifest.FormatGGUF)
second := baseConfig(manifest.FormatSafetensors)
tt.mutate(&second)
warnings := driftWarnings(t, "drift-test", []model.ConfigV2{first, second})
found := slices.ContainsFunc(warnings, func(w string) bool {
return strings.Contains(w, tt.wantSubstring)
})
if !found {
t.Fatalf("warnings = %v, want one containing %q", warnings, tt.wantSubstring)
}
})
}
t.Run("unset fields are not drift", func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
first := baseConfig(manifest.FormatGGUF)
second := baseConfig(manifest.FormatSafetensors)
second.ModelFamily = ""
second.ModelFamilies = nil
second.ModelType = ""
second.ContextLen = 0
second.FileType = ""
warnings := driftWarnings(t, "drift-unset", []model.ConfigV2{first, second})
if len(warnings) != 0 {
t.Fatalf("warnings = %v, want none", warnings)
}
})
t.Run("same precision class is not drift", func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
first := baseConfig(manifest.FormatGGUF)
second := baseConfig(manifest.FormatSafetensors)
second.FileType = "nvfp4"
warnings := driftWarnings(t, "drift-class", []model.ConfigV2{first, second})
for _, warning := range warnings {
if strings.Contains(warning, "quantization") {
t.Fatalf("warnings = %v, want no quantization warning", warnings)
}
}
})
t.Run("no drift is silent", func(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
first := baseConfig(manifest.FormatGGUF)
second := baseConfig(manifest.FormatSafetensors)
warnings := driftWarnings(t, "drift-clean", []model.ConfigV2{first, second})
if len(warnings) != 0 {
t.Fatalf("warnings = %v, want none", warnings)
}
})
}
func TestCreateClefDecisionHead(t *testing.T) {
t.Setenv("OLLAMA_MODELS", t.TempDir())
_, digest := createBinFile(t, gguftest.KV{
"general.architecture": "qwen35",
"qwen35.decision.type": "clef",
}, nil)
s := &Server{}
for _, req := range []api.CreateRequest{
{Model: "custom-decision", Files: map[string]string{"model.gguf": digest}, Stream: &stream},
{Model: "copied-decision", From: "custom-decision", Stream: &stream},
} {
w := createRequest(t, s.CreateHandler, req)
if w.Code != http.StatusOK {
t.Fatalf("create: %d %s", w.Code, w.Body)
}
m, err := GetModel(req.Model)
if err != nil {
t.Fatal(err)
}
if m.metadata.String("decision.type") != "clef" || !slices.Contains(m.Capabilities(), model.CapabilityDecision) {
t.Fatalf("encoding/capability not preserved: %+v", m.Config)
}
}
}