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 Hiltgen1c345795abf3
diff --cc server/images_test.go
index 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, "", &registryOptions{Insecure: true}, func(resp api.ProgressResponse) {
+ mu.Lock()
+ defer mu.Unlock()
+ progress = append(progress, resp)
+ }); err != nil {
+ t.Fatal(err)
+ }
+
+ payloadTotal := int64(len(configData) + len(layerData))
+ childManifestTotal := int64(len(childData))
+ if payloadTotal == childManifestTotal {
+ t.Fatalf("test fixture payload total equals child manifest size: %d", payloadTotal)
+ }
+ var sawPayloadProgress bool
+ for _, resp := range progress {
+ if resp.Digest != "sha256:model" {
+ continue
+ }
+ if resp.Total == childManifestTotal {
+ t.Fatalf("reported child manifest as model progress: %#v", resp)
+ }
+ if resp.Total == payloadTotal {
+ sawPayloadProgress = true
+ }
+ }
+ if !sawPayloadProgress {
+ t.Fatalf("missing selected payload progress with total %d in %#v", payloadTotal, progress)
+ }
+
+ n := model.ParseName(name)
+ gotParentData, err := manifest.ReadManifestData(n)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !bytes.Equal(gotParentData, parentData) {
+ t.Fatal("named manifest does not contain the parent manifest list")
+ }
+
+ m, err := manifest.ParseNamedManifest(n)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if m.Runner != manifest.RunnerLlamaCPP {
+ t.Fatalf("runner = %q, want %q", m.Runner, manifest.RunnerLlamaCPP)
+ }
+ if m.Config.Digest != configDigest {
+ t.Fatalf("config digest = %q, want %q", m.Config.Digest, configDigest)
+ }
+
+ for _, digest := range []string{childDigest, configDigest, layerDigest} {
+ path, err := manifest.BlobsPath(digest)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := os.Stat(path); err != nil {
+ t.Fatalf("expected blob %s to exist: %v", digest, err)
+ }
+ }
+ path, err := manifest.BlobsPath(unselectedDigest)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := os.Stat(path); !os.IsNotExist(err) {
+ t.Fatalf("unselected child manifest blob exists: %v", err)
+ }
+}
+
func TestModelCapabilities(t *testing.T) {
+ decisionModelPath, _ := createBinFile(t, gguftest.KV{
+ "general.architecture": "qwen35",
+ "qwen35.decision.type": "clef",
+ "tokenizer.chat_template": `{% if tools %}{{ tools }}{% endif %}<think>{{ messages }}</think>`,
+ }, []*gguftest.Tensor{})
+
// Create completion model (llama architecture without vision)
completionModelPath, _ := createBinFile(t, gguftest.KV{
"general.architecture": "llama",
diff --cc server/routes.go
index adb6b89f9,388bce0bb..e42236847
--- a/server/routes.go
+++ b/server/routes.go
@@@ -933,7 -889,16 +940,16 @@@ func (s *Server) SystemOneHandler(c *gi
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, 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.RemoteHost
resp.RemoteModel = m.Config.RemoteModel
diff --cc server/routes_create_test.go
index 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)
+ }
+ }
+ }