promptkit/bundled_composition_contract_test.go

package promptkit_test

import (
	"context"
	"reflect"
	"slices"
	"testing"

	"go.maximumdirect.net/configkit"
	"go.maximumdirect.net/promptkit"
)

func TestBundledCompositionReplacementAndInheritance(t *testing.T) {
	underlay := configkit.Input{Source: configkit.Mapping("caller underlay", map[string]any{
		"profiles": []any{map[string]any{"id": "gpt-sol-latest", "model": "underlay-model"}},
	})}
	underlayEngine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{Underlays: []configkit.Underlay{{Inputs: []configkit.Input{underlay}}}}})
	if err != nil {
		t.Fatal(err)
	}
	underlayProfile, err := underlayEngine.InspectProfile(context.Background(), "gpt-sol-latest")
	if err != nil || underlayProfile.Model == nil || *underlayProfile.Model != "underlay-model" || underlayProfile.Backend != nil {
		t.Fatalf("underlay replacement = %+v, %v", underlayProfile, err)
	}
	main := configkit.Input{Source: configkit.Mapping("caller main", map[string]any{
		"backends": []any{map[string]any{"id": "openrouter", "endpoint": "https://local.invalid/v1"}, map[string]any{"id": "other", "endpoint": "https://other.invalid/v1"}},
		"profiles": []any{
			map[string]any{"id": "gpt-sol-latest", "model": "main-model"},
			map[string]any{"id": "custom", "extends": map[string]any{"id": "gpt-luna-latest"}, "model": "custom-model"},
			map[string]any{"id": "auto", "backend": "other", "model": "other-model"},
		},
		"collections": map[string]any{"openrouter": map[string]any{
			"backends": []any{map[string]any{"id": "local", "endpoint": "https://collection.invalid/v1"}},
			"profiles": []any{map[string]any{"id": "profile", "backend": "openrouter/local", "model": "collection-model"}},
		}},
	})}
	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{Underlays: []configkit.Underlay{{Inputs: []configkit.Input{underlay}}}, Main: &main}})
	if err != nil {
		t.Fatal(err)
	}
	inspect := func(id string) *promptkit.ProfileInspection {
		t.Helper()
		profile, err := engine.InspectProfile(context.Background(), id)
		if err != nil {
			t.Fatal(err)
		}
		return profile
	}
	if target := inspect("gpt-sol-latest"); target.Model == nil || *target.Model != "main-model" || target.Backend != nil {
		t.Fatalf("replacement = %+v", target)
	}
	if target := inspect("custom"); target.Model == nil || *target.Model != "custom-model" || target.Backend == nil || *target.Backend != "openrouter" || target.Endpoint != nil {
		t.Fatalf("inherited = %+v", target)
	}
	if backend, err := engine.InspectBackend(context.Background(), "openrouter"); err != nil || backend.Endpoint != "https://local.invalid/v1" || backend.APIKeyEnv != nil {
		t.Fatalf("backend replacement = %+v, %v", backend, err)
	}
	if target := inspect("openrouter/profile"); target.Backend == nil || *target.Backend != "openrouter/local" || target.Model == nil || *target.Model != "collection-model" {
		t.Fatalf("collection = %+v", target)
	}
	target := inspect("auto-low")
	wantPlugins := map[string]any{"plugins": []any{map[string]any{"id": "auto-router", "cost_tier": "low"}}}
	if target.Backend == nil || *target.Backend != "other" || target.Model == nil || *target.Model != "other-model" || target.ExtraParams == nil || !reflect.DeepEqual(*target.ExtraParams, wantPlugins) {
		t.Errorf("inherited tier = %+v", target)
	}
}

func TestBundledCompositionSequenceModes(t *testing.T) {
	for _, test := range []struct {
		name, mode, id string
		wantErr        bool
		hasAuto        bool
	}{
		{"duplicate append", "append", "auto", true, false},
		{"distinct append", "append", "custom", false, true},
		{"replace", "replace", "custom", false, false},
	} {
		t.Run(test.name, func(t *testing.T) {
			input := configkit.Input{Source: configkit.Mapping("sequence", map[string]any{
				"config":   map[string]any{"sequences": []any{map[string]any{"destination": []any{"profiles"}, "mode": test.mode}}},
				"profiles": []any{map[string]any{"id": test.id, "model": "custom-model"}},
			})}
			engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{Main: &input}})
			if test.wantErr {
				if err == nil {
					t.Fatal("expected duplicate rejection")
				}
				return
			}
			if err != nil {
				t.Fatal(err)
			}
			profiles, err := engine.ListProfiles(context.Background())
			if err != nil || !slices.Contains(profiles, "custom") || slices.Contains(profiles, "auto") != test.hasAuto {
				t.Fatalf("profiles = %v, %v", profiles, err)
			}
		})
	}
}

func TestBundledCompositionRejectsStrictConflictsAndMissingBackends(t *testing.T) {
	profile := configkit.Input{Source: configkit.Mapping("profile", map[string]any{"profiles": []any{map[string]any{"id": "auto", "model": "caller"}}})}
	_, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{Underlays: []configkit.Underlay{{Inputs: []configkit.Input{profile, profile}}}}})
	if err == nil {
		t.Fatal("strict group accepted duplicate records")
	}
	input := configkit.Input{Source: configkit.Mapping("replace backends", map[string]any{
		"config":   map[string]any{"sequences": []any{map[string]any{"destination": []any{"backends"}, "mode": "replace"}}},
		"backends": []any{map[string]any{"id": "other", "endpoint": "https://other.invalid/v1"}},
	})}
	if _, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{Main: &input}}); err == nil {
		t.Fatal("missing bundled backend was accepted")
	}
}