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 Hiltgeneadb68a609eb
diff --cc server/create.goindex 8f7d30b13,7af92681d..fd538c903--- a/server/create.go+++ b/server/create.go@@@ -936,143 -886,6 +944,143 @@@ func createModel(ctx context.Context,return nil}+func createManifestList(r api.CreateRequest, name model.Name, fn func(resp api.ProgressResponse)) error {+ if err := validateCreateManifestListRequest(r); err != nil {+ return err+ }++ manifests := make([]manifest.Manifest, 0, len(r.List))+ signatures := make([]manifestListChildSignature, 0, len(r.List))+ seenDigests := make(map[string]string)+ seenRunners := make(map[string]string)+ var anchorChild *manifest.Manifest+ for _, ref := range r.List {+ ref = strings.TrimSpace(ref)+ if ref == "" {+ return newManifestListRequestError("manifest list contains an empty model")+ }++ fn(api.ProgressResponse{Status: fmt.Sprintf("reading manifest %s", ref)})++ modelRef, err := parseAndValidateModelRef(ref)+ if err != nil {+ return err+ }+ if modelRef.Source == modelSourceCloud {+ return newManifestListRequestError("manifest list entries must be local models: %s", ref)+ }++ childName, err := getExistingName(modelRef.Name)+ if err != nil {+ return err+ }++ data, err := manifest.ReadManifestData(childName)+ if err != nil {+ return fmt.Errorf("read manifest %s: %w", ref, err)+ }++ var child manifest.Manifest+ if err := json.Unmarshal(data, &child); err != nil {+ return err+ }+ if child.MediaType == manifest.MediaTypeManifestList {+ return newManifestListRequestError("manifest list entry %s is already a manifest list", ref)+ }++ if err := manifest.FillMetadata(&child); err != nil {+ return fmt.Errorf("manifest list entry %s: %w", ref, err)+ }+ if child.Format == manifest.FormatGGUF {+ // On failure the conservative ggml default stands: it flags the+ // model for inspection rather than failing the create.+ if runner, err := compatmigrate.RunnerForManifest(childName, &child); err != nil {+ slog.Warn("couldn't detect runner for manifest list entry", "entry", ref, "error", err)+ } else {+ child.Runner = runner+ }+ }++ signature, err := newManifestListChildSignature(ref, childName, &child)+ if err != nil {+ return err+ }+ signatures = append(signatures, signature)++ childData, err := json.Marshal(child)+ if err != nil {+ return err+ }+ childDigest, err := manifest.WriteManifestBlob(childData)+ if err != nil {+ return err+ }++ if previous, ok := seenDigests[childDigest]; ok {+ return newManifestListRequestError("manifest list entries %s and %s resolve to the same manifest", previous, ref)+ }+ runner := strings.ToLower(strings.TrimSpace(child.Runner))+ if previous, ok := seenRunners[runner]; ok {+ return newManifestListRequestError("manifest list entries %s and %s use the same runner %q", previous, ref, child.Runner)+ }+ seenDigests[childDigest] = ref+ seenRunners[runner] = ref++ childRef, err := manifest.NewManifestReference(childDigest, child.Runner, child.Format)+ if err != nil {+ return err+ }++ // The downgrade anchor describes the child a pre-manifest-list daemon+ // would load itself: the GGML child when one is listed, else the first.+ if anchorChild == nil || (anchorChild.Runner != manifest.RunnerGGML && child.Runner == manifest.RunnerGGML) {+ childCopy := child+ anchorChild = &childCopy+ }++ manifests = append(manifests, childRef)+ }++ warnManifestListDrift(signatures, fn)++ fn(api.ProgressResponse{Status: "writing manifest list"})+ parentDigest, err := manifest.WriteManifestList(name, manifests)+ if err != nil {+ return err+ }++ // Extra layers reference the manifest blobs so a downgrade's garbage+ // collector cannot delete them.+ manifestDigests := []string{parentDigest}+ for _, childRef := range manifests {+ digest, err := manifest.ChildManifestDigest(childRef)+ if err != nil {+ return err+ }+ manifestDigests = append(manifestDigests, digest)+ }+ return manifest.WriteLegacyAnchor(name, anchorChild, manifestDigests...)+}++func validateCreateManifestListRequest(r api.CreateRequest) error {+ if len(r.List) == 0 {+ return newManifestListRequestError("manifest list must contain at least one model")+ }++ switch {+ case r.From != "", r.RemoteHost != "", len(r.Files) > 0, len(r.DraftFiles) > 0:+ return newManifestListRequestError("manifest list creation cannot be combined with model creation options")+ case r.Template != "", r.System != "", r.License != nil, len(r.Parameters) > 0, len(r.Messages) > 0:+ return newManifestListRequestError("manifest list creation cannot be combined with model creation options")- case r.Renderer != "", r.Parser != "", r.Requires != "", len(r.Info) > 0:++ case r.Renderer != "", r.Parser != "", r.Requires != "", len(r.Info) > 0, len(r.Capabilities) > 0:+ return newManifestListRequestError("manifest list creation cannot be combined with model creation options")+ case r.Quantize != "", r.Quantization != "", r.DraftQuantize != "":+ return newManifestListRequestError("manifest list creation cannot be combined with model creation options")+ default:+ return nil+ }+}+func ggufLayersWithMediaType(digest, sourceName, mediaType string, fn func(resp api.ProgressResponse)) ([]*modelLayer, error) {var layers []*modelLayerdiff --cc server/routes.goindex b2d71ce7c,4347cf51a..adb6b89f9--- a/server/routes.go+++ b/server/routes.go@@@ -929,11 -878,11 +929,11 @@@ func (s *Server) SystemOneHandler(c *gihandleScheduleError(c, req.Model, err)return}- if !m.isGGUF() || m.Config.Renderer != "qwen3.5" && !(m.Config.Renderer == "" && m.Config.ModelFamily == "qwen35") {- c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("model %q is not supported by System One; use a local Nimble or Tev GGUF model", req.Model)})+ if !m.isGGUF() {+ c.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}, nil, req.KeepAlive, nil)- r, _, _, err := s.scheduleRunner(c.Request.Context(), m, []model.Capability{model.CapabilityCompletion, model.CapabilityDecision}, nil, req.KeepAlive, nil)++ r, _, _, err := s.scheduleRunner(c.Request.Context(), name.String(), "", []model.Capability{model.CapabilityCompletion, model.CapabilityDecision}, nil, req.KeepAlive, nil)if err != nil {handleScheduleError(c, req.Model, err)returndiff --cc server/routes_create_test.goindex e83bb38df,e280449b2..60d54f527--- a/server/routes_create_test.go+++ b/server/routes_create_test.go@@@ -1023,262 -1001,6 +1023,269 @@@ func TestCreateRemovesLayers(t *testing})}+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)