Freeze v7

pkg/config/latest/parse.go

@@ -4,7 +4,7 @@ import (
 	"github.com/goccy/go-yaml"
 
 	"github.com/docker/docker-agent/pkg/config/types"
-	previous "github.com/docker/docker-agent/pkg/config/v6"
+	previous "github.com/docker/docker-agent/pkg/config/v7"
 )
 
 func Register(parsers map[string]func([]byte) (any, error), upgraders *[]func(any, []byte) (any, error)) {
@@ -26,34 +26,5 @@ func upgradeIfNeeded(c any, _ []byte) (any, error) {
 
 	var config Config
 	types.CloneThroughJSON(old, &config)
-
-	// Migrate AgentConfig.RAG []string → toolsets with type: rag + ref
-	for i, agent := range old.Agents {
-		if len(agent.RAG) == 0 {
-			continue
-		}
-		for _, ragName := range agent.RAG {
-			config.Agents[i].Toolsets = append(config.Agents[i].Toolsets, Toolset{
-				Type: "rag",
-				Ref:  ragName,
-			})
-		}
-	}
-
-	// Migrate top-level RAG map from RAGConfig to RAGToolset
-	if len(old.RAG) > 0 && config.RAG == nil {
-		config.RAG = make(map[string]RAGToolset)
-	}
-	for name, oldRAG := range old.RAG {
-		var ragCfg RAGConfig
-		types.CloneThroughJSON(oldRAG, &ragCfg)
-		config.RAG[name] = RAGToolset{
-			Toolset: Toolset{
-				Type:      "rag",
-				RAGConfig: &ragCfg,
-			},
-		}
-	}
-
 	return config, nil
 }

pkg/config/latest/types.go

@@ -16,7 +16,7 @@ import (
 	"github.com/docker/docker-agent/pkg/effort"
 )
 
-const Version = "7"
+const Version = "8"
 
 // Config represents the entire configuration file
 type Config struct {

pkg/config/v7/model_config_clone_test.go

@@ -0,0 +1,79 @@
+package latest
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestModelConfig_Clone_DeepCopiesPointerFields(t *testing.T) {
+	t.Parallel()
+
+	temp := 0.7
+	maxTokens := int64(4096)
+	topP := 0.9
+	parallel := true
+	trackUsage := true
+
+	original := &ModelConfig{
+		Provider:          "openai",
+		Model:             "gpt-4o",
+		Temperature:       &temp,
+		MaxTokens:         &maxTokens,
+		TopP:              &topP,
+		ParallelToolCalls: &parallel,
+		TrackUsage:        &trackUsage,
+		ThinkingBudget:    &ThinkingBudget{Effort: "high"},
+		ProviderOpts:      map[string]any{"key": "value"},
+		Routing: []RoutingRule{
+			{Model: "fast", Examples: []string{"quick question"}},
+		},
+	}
+
+	clone := original.Clone()
+
+	// Mutate every pointer/collection field in the original.
+	*original.Temperature = 0.1
+	*original.MaxTokens = 1
+	*original.TopP = 0.1
+	*original.ParallelToolCalls = false
+	*original.TrackUsage = false
+	original.ThinkingBudget.Effort = "low"
+	original.ProviderOpts["key"] = "mutated"
+	original.Routing[0].Examples[0] = "mutated"
+
+	// Clone must be unaffected.
+	assert.InDelta(t, 0.7, *clone.Temperature, 0.001)
+	assert.Equal(t, int64(4096), *clone.MaxTokens)
+	assert.InDelta(t, 0.9, *clone.TopP, 0.001)
+	assert.True(t, *clone.ParallelToolCalls)
+	assert.True(t, *clone.TrackUsage)
+	assert.Equal(t, "high", clone.ThinkingBudget.Effort)
+	assert.Equal(t, "value", clone.ProviderOpts["key"])
+	assert.Equal(t, "quick question", clone.Routing[0].Examples[0])
+}
+
+func TestModelConfig_Clone_Nil(t *testing.T) {
+	t.Parallel()
+
+	var m *ModelConfig
+	assert.Nil(t, m.Clone())
+}
+
+func TestModelConfig_Clone_MinimalFields(t *testing.T) {
+	t.Parallel()
+
+	original := &ModelConfig{
+		Provider: "anthropic",
+		Model:    "claude-sonnet-4-5",
+	}
+
+	clone := original.Clone()
+
+	assert.Equal(t, "anthropic", clone.Provider)
+	assert.Equal(t, "claude-sonnet-4-5", clone.Model)
+	assert.Nil(t, clone.Temperature)
+	assert.Nil(t, clone.MaxTokens)
+	assert.Nil(t, clone.ProviderOpts)
+	assert.Nil(t, clone.Routing)
+}

pkg/config/v7/model_ref.go

@@ -0,0 +1,20 @@
+package latest
+
+import (
+	"fmt"
+	"strings"
+)
+
+// ParseModelRef parses an inline "provider/model" reference into a
+// ModelConfig. It returns an error when the string does not contain
+// exactly one "/" separator or when either part is empty.
+//
+//	cfg, err := ParseModelRef("openai/gpt-4o")
+//	// cfg.Provider == "openai", cfg.Model == "gpt-4o"
+func ParseModelRef(ref string) (ModelConfig, error) {
+	providerName, model, ok := strings.Cut(ref, "/")
+	if !ok || providerName == "" || model == "" {
+		return ModelConfig{}, fmt.Errorf("invalid model reference %q: expected 'provider/model' format", ref)
+	}
+	return ModelConfig{Provider: providerName, Model: model}, nil
+}

pkg/config/v7/parse.go

@@ -0,0 +1,59 @@
+package latest
+
+import (
+	"github.com/goccy/go-yaml"
+
+	"github.com/docker/docker-agent/pkg/config/types"
+	previous "github.com/docker/docker-agent/pkg/config/v6"
+)
+
+func Register(parsers map[string]func([]byte) (any, error), upgraders *[]func(any, []byte) (any, error)) {
+	parsers[Version] = func(d []byte) (any, error) { return parse(d) }
+	*upgraders = append(*upgraders, upgradeIfNeeded)
+}
+
+func parse(data []byte) (Config, error) {
+	var cfg Config
+	err := yaml.UnmarshalWithOptions(data, &cfg, yaml.Strict())
+	return cfg, err
+}
+
+func upgradeIfNeeded(c any, _ []byte) (any, error) {
+	old, ok := c.(previous.Config)
+	if !ok {
+		return c, nil
+	}
+
+	var config Config
+	types.CloneThroughJSON(old, &config)
+
+	// Migrate AgentConfig.RAG []string → toolsets with type: rag + ref
+	for i, agent := range old.Agents {
+		if len(agent.RAG) == 0 {
+			continue
+		}
+		for _, ragName := range agent.RAG {
+			config.Agents[i].Toolsets = append(config.Agents[i].Toolsets, Toolset{
+				Type: "rag",
+				Ref:  ragName,
+			})
+		}
+	}
+
+	// Migrate top-level RAG map from RAGConfig to RAGToolset
+	if len(old.RAG) > 0 && config.RAG == nil {
+		config.RAG = make(map[string]RAGToolset)
+	}
+	for name, oldRAG := range old.RAG {
+		var ragCfg RAGConfig
+		types.CloneThroughJSON(oldRAG, &ragCfg)
+		config.RAG[name] = RAGToolset{
+			Toolset: Toolset{
+				Type:      "rag",
+				RAGConfig: &ragCfg,
+			},
+		}
+	}
+
+	return config, nil
+}