Skip to content

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.go
index 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 []*modelLayer
diff --cc server/routes.go
index b2d71ce7c,4347cf51a..adb6b89f9
--- a/server/routes.go
+++ b/server/routes.go
@@@ -929,11 -878,11 +929,11 @@@ func (s *Server) SystemOneHandler(c *gi
handleScheduleError(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)
return
diff --cc server/routes_create_test.go
index 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)