Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.
Merge remote-tracking branch 'upstream/main' into release_v0.40.0
Daniel Hiltgen1c345795abf3
diff --cc server/images_test.goindex 3abcec24d,0479bb81a..3c2ae88de--- a/server/images_test.go+++ b/server/images_test.go@@@ -412,342 -377,13 +412,348 @@@ func loadTestMetadata(t *testing.T, m *}}+func TestPushLayersForManifestListIncludesChildManifests(t *testing.T) {+ t.Setenv("OLLAMA_MODELS", t.TempDir())++ writeChild := func(name, runner, formatName, layerMediaType string) (manifest.Manifest, manifest.Layer, manifest.Layer) {+ t.Helper()++ config, err := manifest.NewLayer(strings.NewReader(name+" config"), "application/vnd.docker.container.image.v1+json")+ if err != nil {+ t.Fatal(err)+ }+ layer, err := manifest.NewLayer(strings.NewReader(name+" layer"), layerMediaType)+ if err != nil {+ t.Fatal(err)+ }+ if err := manifest.WriteManifestWithMetadata(model.ParseName(name), config, []manifest.Layer{layer}, runner, formatName); err != nil {+ t.Fatal(err)+ }+ mf, err := manifest.ParseNamedManifestForRunner(model.ParseName(name), runner)+ if err != nil {+ t.Fatal(err)+ }+ return *mf, config, layer+ }++ mlx, mlxConfig, mlxLayer := writeChild("library/push-mlx:latest", manifest.RunnerMLX, manifest.FormatSafetensors, manifest.MediaTypeImageTensor)+ ggml, ggmlConfig, ggmlLayer := writeChild("library/push-ggml:latest", manifest.RunnerGGML, manifest.FormatGGUF, "application/vnd.ollama.image.model")++ mlxRef, err := manifest.NewManifestReference(mlx.BlobDigest(), mlx.Runner, mlx.Format)+ if err != nil {+ t.Fatal(err)+ }+ ggmlRef, err := manifest.NewManifestReference(ggml.BlobDigest(), ggml.Runner, ggml.Format)+ if err != nil {+ t.Fatal(err)+ }++ layers, err := pushLayersForManifestList(manifest.Manifest{+ SchemaVersion: 2,+ MediaType: manifest.MediaTypeManifestList,+ Manifests: []manifest.Manifest{mlxRef, ggmlRef},+ })+ if err != nil {+ t.Fatal(err)+ }++ want := map[string]string{+ mlx.BlobDigest(): manifest.MediaTypeManifest,+ ggml.BlobDigest(): manifest.MediaTypeManifest,+ mlxConfig.Digest: mlxConfig.MediaType,+ mlxLayer.Digest: mlxLayer.MediaType,+ ggmlConfig.Digest: ggmlConfig.MediaType,+ ggmlLayer.Digest: ggmlLayer.MediaType,+ }+ if len(layers) != len(want) {+ t.Fatalf("layer count = %d, want %d: %#v", len(layers), len(want), layers)+ }+ for _, layer := range layers {+ if wantMediaType, ok := want[layer.Digest]; !ok {+ t.Fatalf("unexpected layer digest %q", layer.Digest)+ } else if layer.MediaType != wantMediaType {+ t.Fatalf("layer %q media type = %q, want %q", layer.Digest, layer.MediaType, wantMediaType)+ }+ if layer.Size == 0 {+ t.Fatalf("layer %q has zero size", layer.Digest)+ }+ }+ if !hasTensorLayers(layers) {+ t.Fatal("manifest list push layers did not preserve tensor media type")+ }+}++func TestCopyModelNarrowsManifestListToLocalChildren(t *testing.T) {+ t.Setenv("OLLAMA_MODELS", t.TempDir())++ writeChild := func(name, runner, formatName string) manifest.Manifest {+ t.Helper()++ config, err := manifest.NewLayer(strings.NewReader(name+" config"), "application/vnd.docker.container.image.v1+json")+ if err != nil {+ t.Fatal(err)+ }+ layer, err := manifest.NewLayer(strings.NewReader(name+" layer"), "application/vnd.ollama.image.model")+ if err != nil {+ t.Fatal(err)+ }+ if err := manifest.WriteManifestWithMetadata(model.ParseName(name), config, []manifest.Layer{layer}, runner, formatName); err != nil {+ t.Fatal(err)+ }+ mf, err := manifest.ParseNamedManifestForRunner(model.ParseName(name), runner)+ if err != nil {+ t.Fatal(err)+ }+ return *mf+ }++ local := writeChild("library/narrow-local:latest", manifest.RunnerGGML, manifest.FormatGGUF)+ localRef, err := manifest.NewManifestReference(local.BlobDigest(), local.Runner, local.Format)+ if err != nil {+ t.Fatal(err)+ }+ // A child the registry advertised but pull never materialized.+ absentRef, err := manifest.NewManifestReference(fmt.Sprintf("sha256:%064d", 1), manifest.RunnerMLX, manifest.FormatSafetensors)+ if err != nil {+ t.Fatal(err)+ }++ writeList := func(name string, refs []manifest.Manifest) model.Name {+ t.Helper()+ n := model.ParseName(name)+ if _, err := manifest.WriteManifestList(n, refs); err != nil {+ t.Fatal(err)+ }+ return n+ }++ t.Run("drops absent children and warns", func(t *testing.T) {+ src := writeList("library/narrow-src:latest", []manifest.Manifest{localRef, absentRef})+ dst := model.ParseName("library/narrow-dst:latest")++ warning, err := CopyModel(src, dst)+ if err != nil {+ t.Fatalf("CopyModel() = %v, want nil", err)+ }+ if !strings.Contains(warning, manifest.RunnerMLX) {+ t.Errorf("warning = %q, want it to name the dropped %s child", warning, manifest.RunnerMLX)+ }++ data, err := manifest.ReadManifestData(dst)+ if err != nil {+ t.Fatal(err)+ }+ var copied manifest.Manifest+ if err := json.Unmarshal(data, &copied); err != nil {+ t.Fatal(err)+ }+ if len(copied.Manifests) != 1 {+ t.Fatalf("copy has %d children, want 1: %#v", len(copied.Manifests), copied.Manifests)+ }+ if got := copied.Manifests[0].BlobDigest(); got != local.BlobDigest() {+ t.Errorf("copied child digest = %q, want %q", got, local.BlobDigest())+ }+ })++ t.Run("fully local list is copied verbatim", func(t *testing.T) {+ src := writeList("library/intact-src:latest", []manifest.Manifest{localRef})+ dst := model.ParseName("library/intact-dst:latest")++ warning, err := CopyModel(src, dst)+ if err != nil {+ t.Fatalf("CopyModel() = %v, want nil", err)+ }+ if warning != "" {+ t.Errorf("warning = %q, want none", warning)+ }++ srcData, err := manifest.ReadManifestData(src)+ if err != nil {+ t.Fatal(err)+ }+ dstData, err := manifest.ReadManifestData(dst)+ if err != nil {+ t.Fatal(err)+ }+ if !bytes.Equal(srcData, dstData) {+ t.Errorf("copy differs from source:\n got %s\nwant %s", dstData, srcData)+ }+ })++ t.Run("no local children is an error", func(t *testing.T) {+ src := writeList("library/empty-src:latest", []manifest.Manifest{absentRef})+ dst := model.ParseName("library/empty-dst:latest")++ if _, err := CopyModel(src, dst); !errors.Is(err, manifest.ErrNoCompatibleManifest) {+ t.Fatalf("CopyModel() = %v, want ErrNoCompatibleManifest", err)+ }+ if _, err := manifest.ReadManifestData(dst); err == nil {+ t.Error("destination manifest was written despite the error")+ }+ })+}++func TestPullModelManifestListDownloadsSelectedChildOnly(t *testing.T) {+ t.Setenv("OLLAMA_MODELS", t.TempDir())++ configData := []byte(`{"architecture":"test"}`)+ configDigest := fmt.Sprintf("sha256:%x", sha256.Sum256(configData))+ layerData := bytes.Repeat([]byte("selected tensor layer"), 64)+ layerDigest := fmt.Sprintf("sha256:%x", sha256.Sum256(layerData))++ child := manifest.Manifest{+ SchemaVersion: 2,+ MediaType: manifest.MediaTypeManifest,+ Runner: manifest.RunnerLlamaCPP,+ Format: manifest.FormatGGUF,+ Config: manifest.Layer{+ MediaType: "application/vnd.docker.container.image.v1+json",+ Digest: configDigest,+ Size: int64(len(configData)),+ },+ Layers: []manifest.Layer{+ {+ MediaType: manifest.MediaTypeImageTensor,+ Digest: layerDigest,+ Size: int64(len(layerData)),+ },+ },+ }+ childData, err := json.Marshal(child)+ if err != nil {+ t.Fatal(err)+ }+ childDigest := fmt.Sprintf("sha256:%x", sha256.Sum256(childData))+ childRef, err := manifest.NewManifestReference(childDigest, manifest.RunnerLlamaCPP, manifest.FormatGGUF)+ if err != nil {+ t.Fatal(err)+ }+ unselectedDigest := "sha256:" + strings.Repeat("f", 64)+ unselectedRef, err := manifest.NewManifestReference(unselectedDigest, manifest.RunnerGGML, manifest.FormatGGUF)+ if err != nil {+ t.Fatal(err)+ }+ parent := manifest.Manifest{+ SchemaVersion: 2,+ MediaType: manifest.MediaTypeManifestList,+ Manifests: []manifest.Manifest{childRef, unselectedRef},+ }+ parentData, err := json.Marshal(parent)+ if err != nil {+ t.Fatal(err)+ }++ blobs := map[string][]byte{+ childDigest: childData,+ configDigest: configData,+ layerDigest: layerData,+ }+ ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ switch {+ case r.Method == http.MethodGet && r.URL.Path == "/v2/library/test/manifests/latest":+ w.Header().Set("Content-Type", manifest.MediaTypeManifestList)+ w.Header().Set("Content-Length", strconv.Itoa(len(parentData)))+ _, _ = w.Write(parentData)+ case (r.Method == http.MethodHead || r.Method == http.MethodGet) && strings.HasPrefix(r.URL.Path, "/v2/library/test/blobs/"):+ digest := strings.TrimPrefix(r.URL.Path, "/v2/library/test/blobs/")+ if digest == unselectedDigest {+ t.Errorf("requested unselected child manifest %s", digest)+ http.Error(w, "unselected child requested", http.StatusNotFound)+ return+ }+ data, ok := blobs[digest]+ if !ok {+ http.NotFound(w, r)+ return+ }+ w.Header().Set("Content-Length", strconv.Itoa(len(data)))+ if r.Method == http.MethodGet {+ _, _ = w.Write(data)+ }+ default:+ http.NotFound(w, r)+ }+ }))+ defer ts.Close()++ name := strings.TrimPrefix(ts.URL, "http://") + "/library/test:latest"+ // Blobs download in parallel, so progress arrives from several goroutines.+ var mu sync.Mutex+ var progress []api.ProgressResponse+ if err := PullModel(t.Context(), name, "", ®istryOptions{Insecure: true}, func(resp api.ProgressResponse) {+ mu.Lock()+ defer mu.Unlock()+ progress = append(progress, resp)+ }); err != nil {+ t.Fatal(err)+ }++ payloadTotal := int64(len(configData) + len(layerData))+ childManifestTotal := int64(len(childData))+ if payloadTotal == childManifestTotal {+ t.Fatalf("test fixture payload total equals child manifest size: %d", payloadTotal)+ }+ var sawPayloadProgress bool+ for _, resp := range progress {+ if resp.Digest != "sha256:model" {+ continue+ }+ if resp.Total == childManifestTotal {+ t.Fatalf("reported child manifest as model progress: %#v", resp)+ }+ if resp.Total == payloadTotal {+ sawPayloadProgress = true+ }+ }+ if !sawPayloadProgress {+ t.Fatalf("missing selected payload progress with total %d in %#v", payloadTotal, progress)+ }++ n := model.ParseName(name)+ gotParentData, err := manifest.ReadManifestData(n)+ if err != nil {+ t.Fatal(err)+ }+ if !bytes.Equal(gotParentData, parentData) {+ t.Fatal("named manifest does not contain the parent manifest list")+ }++ m, err := manifest.ParseNamedManifest(n)+ if err != nil {+ t.Fatal(err)+ }+ if m.Runner != manifest.RunnerLlamaCPP {+ t.Fatalf("runner = %q, want %q", m.Runner, manifest.RunnerLlamaCPP)+ }+ if m.Config.Digest != configDigest {+ t.Fatalf("config digest = %q, want %q", m.Config.Digest, configDigest)+ }++ for _, digest := range []string{childDigest, configDigest, layerDigest} {+ path, err := manifest.BlobsPath(digest)+ if err != nil {+ t.Fatal(err)+ }+ if _, err := os.Stat(path); err != nil {+ t.Fatalf("expected blob %s to exist: %v", digest, err)+ }+ }+ path, err := manifest.BlobsPath(unselectedDigest)+ if err != nil {+ t.Fatal(err)+ }+ if _, err := os.Stat(path); !os.IsNotExist(err) {+ t.Fatalf("unselected child manifest blob exists: %v", err)+ }+}+func TestModelCapabilities(t *testing.T) {+ decisionModelPath, _ := createBinFile(t, gguftest.KV{+ "general.architecture": "qwen35",+ "qwen35.decision.type": "clef",+ "tokenizer.chat_template": `{% if tools %}{{ tools }}{% endif %}<think>{{ messages }}</think>`,+ }, []*gguftest.Tensor{})+// Create completion model (llama architecture without vision)completionModelPath, _ := createBinFile(t, gguftest.KV{"general.architecture": "llama",diff --cc server/routes.goindex adb6b89f9,388bce0bb..e42236847--- a/server/routes.go+++ b/server/routes.go@@@ -933,7 -889,16 +940,16 @@@ func (s *Server) SystemOneHandler(c *gic.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("model %q is not supported by System One; use a local GGUF model", req.Model)})return}- r, _, _, err := s.scheduleRunner(c.Request.Context(), name.String(), "", []model.Capability{model.CapabilityCompletion, model.CapabilityDecision}, nil, req.KeepAlive, nil)+ compiled, err := decision.CompileWithEncoder(req, m.metadata.String("decision.type"))+ if err != nil {+ c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})+ return+ }+ caps := []model.Capability{model.CapabilityDecision}+ if len(req.Images) > 0 {+ caps = append(caps, model.CapabilityVision)+ }- r, _, _, err := s.scheduleRunner(c.Request.Context(), m, caps, nil, req.KeepAlive, nil)++ r, _, _, err := s.scheduleRunner(c.Request.Context(), name.String(), "", caps, nil, req.KeepAlive, nil)if err != nil {handleScheduleError(c, req.Model, err)return@@@ -1710,13 -1645,10 +1725,16 @@@ func GetModelInfo(req api.ShowRequest)// default we return an empty map.ModelInfo: make(map[string]any),}+ if !slices.Contains(resp.Capabilities, model.CapabilityDecision) {+ resp.Thinking = m.Thinking()+ }+ if summaries, err := manifestSummariesForShow(name, mf.SelectedDigest()); err != nil {+ return nil, err+ } else {+ resp.Manifests = summaries+ }+if m.Config.RemoteHost != "" {resp.RemoteHost = m.Config.RemoteHostresp.RemoteModel = m.Config.RemoteModeldiff --cc server/routes_create_test.goindex 60d54f527,1cba1d0a0..2aea11b4a--- a/server/routes_create_test.go+++ b/server/routes_create_test.go@@@ -3242,205 -2959,27 +3242,230 @@@ func TestCreateFromSafetensorsModel_Pre}}+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)+ }+ }+ }