Record backend and profile normalization

This commit is contained in:
2026-11-03 03:27:17 +00:00
parent e7ed315671
commit 626134e5e1
5 changed files with 171 additions and 106 deletions

View File

@@ -4,7 +4,6 @@ package configuration
import (
"fmt"
"net/http"
"regexp"
"sort"
"strings"
@@ -243,6 +242,10 @@ func configurationDefinition(state *loaded) configkit.Definition[document] {
captureFields(resources.profiles, func(v profileConfig) string { return v.ID }, resources.bases.profiles, resources.namespace, profileFields, resolution, state.profiles)
capturePromptMetadata(resources.prompts, resources.bases.prompts, resources.namespace, resolution, state.promptMetadata)
}
for _, resources := range resourceSets(config) {
resolveBackends(resources.backends, resources.bases.backends, resolution)
resolveProfiles(resources.profiles, resources.bases.profiles, resolution)
}
return nil
},
Validate: func(config *document, validation *configkit.Validation) {
@@ -372,6 +375,29 @@ func captureFields[T any](entries []T, identity func(T) string, basePath configk
}
}
// eligibleResourceList leaves invalid identities to the existing validation
// boundaries, without mutating a list that cannot be recorded by identity.
func eligibleResourceList[T any](entries []T, identity func(T) string) bool {
seen := make(map[string]struct{}, len(entries))
for _, entry := range entries {
id := identity(entry)
if !domain.IsValidLocalResourceKey(id) {
return false
}
if _, exists := seen[id]; exists {
return false
}
seen[id] = struct{}{}
}
return true
}
func recordStringNormalization(value **string, path configkit.Path, resolution *configkit.Resolution, normalized string) {
if *value != nil && **value != normalized {
configkit.Normalize(resolution, path, value, &normalized, "Normalize configured value")
}
}
func sortedKeys[T any](entries map[string]T) []string {
keys := make([]string, 0, len(entries))
for key := range entries {
@@ -383,16 +409,11 @@ func sortedKeys[T any](entries map[string]T) []string {
func interpretConfiguration(config *document, validation *configkit.Validation) document {
interpreted := *config
interpreted.Backends = interpretBackends(config.Backends, configkit.Keys("backends"), validation)
interpreted.Profiles = interpretProfiles(config.Profiles, configkit.Keys("profiles"), validation)
interpreted.Prompts = interpretPrompts(config.Prompts)
if config.Collections != nil {
interpreted.Collections = make(map[string]collectionConfig, len(config.Collections))
for namespace, original := range config.Collections {
collection := original
base := configkit.Keys("collections", namespace)
collection.Backends = interpretBackends(original.Backends, base.Key("backends"), validation)
collection.Profiles = interpretProfiles(original.Profiles, base.Key("profiles"), validation)
collection.Prompts = interpretPrompts(original.Prompts)
interpreted.Collections[namespace] = collection
}
@@ -400,94 +421,6 @@ func interpretConfiguration(config *document, validation *configkit.Validation)
return interpreted
}
func interpretBackends(source []backendConfig, basePath configkit.Path, validation *configkit.Validation) []backendConfig {
if source == nil {
return nil
}
backends := append([]backendConfig{}, source...)
for index := range backends {
backend := &backends[index]
base := basePath.Index(index)
if backend.Endpoint != nil {
endpoint, err := domain.NormalizeOpenAICompatibleBaseEndpoint(*backend.Endpoint)
if err != nil {
validation.Error(base.Key("endpoint"), err.Error())
} else {
backend.Endpoint = &endpoint
}
}
if backend.APIKeyEnv != nil {
value := strings.TrimSpace(*backend.APIKeyEnv)
backend.APIKeyEnv = &value
}
if backend.SmokeTests != nil {
smokeTests := *backend.SmokeTests
backend.SmokeTests = &smokeTests
smokePath := base.Key("smoke_tests")
if smokeTests.Reachability != nil {
reachability := *smokeTests.Reachability
smokeTests.Reachability = &reachability
normalizeDiagnosticEndpoint(&reachability.Endpoint, smokePath.Key("reachability").Key("endpoint"), validation)
}
if smokeTests.Authentication != nil {
authentication := *smokeTests.Authentication
smokeTests.Authentication = &authentication
if authentication.Kind != nil {
kind := strings.ToLower(strings.TrimSpace(*authentication.Kind))
authentication.Kind = &kind
}
normalizeDiagnosticEndpoint(&authentication.Endpoint, smokePath.Key("authentication").Key("endpoint"), validation)
}
}
if backend.ConcurrencyLimit != nil && *backend.ConcurrencyLimit > 0 && backend.QueueCapacity == nil {
capacity := 1024
backend.QueueCapacity = &capacity
}
}
return backends
}
func normalizeDiagnosticEndpoint(value **string, path configkit.Path, validation *configkit.Validation) {
if value == nil || *value == nil {
return
}
normalized := strings.TrimSpace(**value)
request, err := http.NewRequest(http.MethodGet, normalized, nil)
if normalized == "" || err != nil || request.URL == nil ||
(strings.ToLower(request.URL.Scheme) != "http" && strings.ToLower(request.URL.Scheme) != "https") ||
request.URL.Hostname() == "" {
validation.Error(path, "diagnostic endpoint must be an absolute HTTP(S) URL with a host")
return
}
*value = &normalized
}
func interpretProfiles(source []profileConfig, basePath configkit.Path, validation *configkit.Validation) []profileConfig {
if source == nil {
return nil
}
profiles := append([]profileConfig{}, source...)
for index := range profiles {
profile := &profiles[index]
base := basePath.Index(index)
if profile.Endpoint != nil && *profile.Endpoint != "" {
endpoint, err := domain.NormalizeOpenAICompatibleBaseEndpoint(*profile.Endpoint)
if err != nil {
validation.Error(base.Key("endpoint"), err.Error())
} else {
profile.Endpoint = &endpoint
}
}
for _, value := range []**string{&profile.ServiceTier, &profile.ReasoningEffort, &profile.APIKeyEnv} {
if *value != nil {
normalized := strings.TrimSpace(**value)
*value = &normalized
}
}
}
return profiles
}
func validateEffective(config *document, validation *configkit.Validation) {
sets := resourceSets(config)
backendIDs := make(map[string]struct{})
@@ -502,6 +435,7 @@ func validateEffective(config *document, validation *configkit.Validation) {
for _, resources := range sets {
for index, backend := range resources.backends {
base := resources.bases.backends.Index(index)
validateBackendEndpoints(backend, base, validation)
if !domain.IsValidLocalResourceKey(backend.ID) {
validation.Error(base.Key("id"), "backend ID must be a nonblank local key without a slash")
}
@@ -546,6 +480,11 @@ func validateEffective(config *document, validation *configkit.Validation) {
}
for index, profile := range resources.profiles {
base := resources.bases.profiles.Index(index)
if profile.Endpoint != nil && *profile.Endpoint != "" {
if _, err := domain.NormalizeOpenAICompatibleBaseEndpoint(*profile.Endpoint); err != nil {
validation.Error(base.Key("endpoint"), err.Error())
}
}
if !domain.IsValidLocalResourceKey(profile.ID) {
validation.Error(base.Key("id"), "profile ID must be a nonblank local key without a slash")
}