Cut over public engine construction to ConfigKit sources

internal/configuration/prompts.go

@@ -1,6 +1,7 @@
 package configuration
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"io"
@@ -310,3 +311,25 @@ func (state *loaded) prompt(id, version string) (*domain.PromptDefinition, domai
 	inspection.Inputs = append([]domain.PromptInput(nil), inspection.Inputs...)
 	return &definition, inspection, nil
 }
+
+// GetPromptSnapshot returns an independently owned captured definition and its
+// construction-time hash. Lookup retains literal ID and version keys.
+func (state *loaded) GetPromptSnapshot(ctx context.Context, id, version string) (*domain.PromptDefinition, string, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, "", err
+	}
+	definition, inspection, err := state.prompt(id, version)
+	if errors.Is(err, errPromptNotFound) {
+		return nil, "", promptdef.ErrPromptDefinitionNotFound
+	}
+	if err != nil {
+		return nil, "", err
+	}
+	return definition, inspection.PromptHash, nil
+}
+
+// GetPromptDefinition implements the runner's prompt lookup boundary.
+func (state *loaded) GetPromptDefinition(ctx context.Context, id, version string) (*domain.PromptDefinition, error) {
+	definition, _, err := state.GetPromptSnapshot(ctx, id, version)
+	return definition, err
+}

internal/configuration/targets.go

@@ -177,3 +177,14 @@ func (state *loaded) GetBackend(id string) (domain.Backend, error) {
 	}
 	return state.registry.GetBackend(id)
 }
+
+// CapacityPolicies returns the selected backend admission policies.
+func (state *loaded) CapacityPolicies() map[string]domain.BackendCapacityPolicy {
+	if state == nil {
+		return nil
+	}
+	return state.registry.CapacityPolicies()
+}
+
+// ExactIDs indicates that ConfigKit definition keys are literal identities.
+func (state *loaded) ExactIDs() bool { return true }

internal/engine/engine.go

@@ -11,49 +11,42 @@ import (
 	"strings"
 	"time"
 
-	openrouter "gitea.maximumdirect.net/eric/promptkit-backend-openrouter/v2"
-	rakestrawhome "gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/v2"
+	"gitea.maximumdirect.net/eric/ConfigKit"
 	"gitea.maximumdirect.net/eric/promptkit/internal/artifact"
-	"gitea.maximumdirect.net/eric/promptkit/internal/backend"
 	"gitea.maximumdirect.net/eric/promptkit/internal/capacity"
+	"gitea.maximumdirect.net/eric/promptkit/internal/catalog"
+	"gitea.maximumdirect.net/eric/promptkit/internal/configuration"
 	"gitea.maximumdirect.net/eric/promptkit/internal/defaults"
 	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
 	"gitea.maximumdirect.net/eric/promptkit/internal/generation"
-	"gitea.maximumdirect.net/eric/promptkit/internal/legacycatalog"
 	"gitea.maximumdirect.net/eric/promptkit/internal/llm"
-	"gitea.maximumdirect.net/eric/promptkit/internal/profile"
 	"gitea.maximumdirect.net/eric/promptkit/internal/prompt"
-	"gitea.maximumdirect.net/eric/promptkit/internal/promptdef"
 	"gitea.maximumdirect.net/eric/promptkit/internal/usecase"
 	"gitea.maximumdirect.net/eric/promptkit/internal/validate"
 )
 
 // Config carries construction settings selected by the public facade.
 type Config struct {
-	PromptDir        string
-	ProfileDir       string
+	Sources          ConfigurationSources
 	SchemaDir        string
 	Timeout          time.Duration
 	HTTPClient       *http.Client
 	TransientRetries *int
 }
 
+// ConfigurationSources identifies caller-selected ConfigKit layers.
+type ConfigurationSources struct {
+	Underlays []configkit.Underlay
+	Main      *configkit.Input
+}
+
 // Options collects construction choices from the public facade.
 type Options struct {
-	llmClient             llm.Client
-	artifactReader        artifact.Reader
-	promptDefinitions     promptdef.Repository
-	profiles              profile.Repository
-	fallbackProfiles      profile.Repository
-	memoryProfiles        profile.Repository
-	backends              []domain.Backend
-	validator             validate.Validator
-	promptSource          bool
-	profileSource         bool
-	fallbackProfileSource bool
-	memorySource          bool
-	validatorSource       bool
-	artifactSource        bool
+	llmClient       llm.Client
+	artifactReader  artifact.Reader
+	validator       validate.Validator
+	validatorSource bool
+	artifactSource  bool
 }
 
 // SetLLMClient selects the client collaborator for one engine.
@@ -65,72 +58,6 @@ func (o *Options) SetArtifactReader(reader artifact.Reader) {
 	o.artifactSource = true
 }
 
-// SetPromptFS selects a prompt source rooted in fsys.
-func (o *Options) SetPromptFS(fsys fs.FS, root string) error {
-	if err := validateSourceFS(fsys, root); err != nil {
-		return err
-	}
-	o.promptDefinitions = promptdef.NewFSRepository(fsys, root)
-	o.promptSource = true
-	return nil
-}
-
-// SetPromptFile selects a single prompt file.
-func (o *Options) SetPromptFile(path string) error {
-	fsys, root, directory, err := fileSource(path)
-	if err != nil {
-		return err
-	}
-	o.promptDefinitions = promptdef.NewFileRepository(fsys, root, directory)
-	o.promptSource = true
-	return nil
-}
-
-// SetProfileFS selects an ordinary profile source rooted in fsys.
-func (o *Options) SetProfileFS(fsys fs.FS, root string) error {
-	if err := validateSourceFS(fsys, root); err != nil {
-		return err
-	}
-	o.profiles = profile.NewFSRepository(fsys, root)
-	o.profileSource = true
-	return nil
-}
-
-// SetProfileFile selects a single ordinary profile file.
-func (o *Options) SetProfileFile(path string) error {
-	fsys, root, _, err := fileSource(path)
-	if err != nil {
-		return err
-	}
-	o.profiles = profile.NewFSRepository(fsys, root)
-	o.profileSource = true
-	return nil
-}
-
-// SetFallbackProfileFS selects a fallback profile source rooted in fsys.
-func (o *Options) SetFallbackProfileFS(fsys fs.FS, root string) error {
-	if err := validateSourceFS(fsys, root); err != nil {
-		return err
-	}
-	o.fallbackProfiles = profile.NewFSRepository(fsys, root)
-	o.fallbackProfileSource = true
-	return nil
-}
-
-// SetMemoryProfiles validates and stores application-owned profile definitions.
-func (o *Options) SetMemoryProfiles(definitions []domain.ExecutionProfile) error {
-	repository, err := profile.NewMemoryRepository(definitions)
-	if err != nil {
-		return err
-	}
-	o.memoryProfiles = repository
-	o.memorySource = true
-	return nil
-}
-
-// AddBackend appends one backend registration.
-func (o *Options) AddBackend(backend domain.Backend) { o.backends = append(o.backends, backend) }
-
 // SetSchemaFS selects a schema source rooted in fsys.
 func (o *Options) SetSchemaFS(fsys fs.FS, root string) error {
 	if err := validateSourceFS(fsys, root); err != nil {
@@ -163,33 +90,20 @@ func New(cfg Config, options Options) (*Engine, error) {
 	if err != nil {
 		return nil, err
 	}
-	promptDefinitions := options.promptDefinitions
-	if !options.promptSource {
-		if strings.TrimSpace(cfg.PromptDir) == "" {
-			return nil, fmt.Errorf("prompt directory is required")
-		}
-		promptDefinitions = promptdef.NewFilesystemRepository(cfg.PromptDir)
-	}
-
-	maintained, err := legacycatalog.Load(
-		legacycatalog.Source{Name: "OpenRouter", ExpectedBackendID: backend.OpenRouterID, FS: openrouter.FS(), Root: openrouter.Root},
-		legacycatalog.Source{Name: "Rakestrawhome", ExpectedBackendID: backend.RakestrawHomeID, FS: rakestrawhome.FS(), Root: rakestrawhome.Root},
-	)
+	underlays, err := catalog.Underlays()
 	if err != nil {
-		return nil, fmt.Errorf("failed to load maintained catalogs: %w", err)
+		return nil, fmt.Errorf("select maintained configuration: %w", err)
 	}
-
-	maintainedProfiles, err := newMaintainedProfileRepository(maintained.Profiles, maintained.Backends)
+	underlays = append(underlays, cfg.Sources.Underlays...)
+	main := configkit.Input{Source: configkit.NoSource()}
+	if cfg.Sources.Main != nil {
+		main = *cfg.Sources.Main
+	}
+	snapshot, err := configuration.Load(main, underlays)
 	if err != nil {
-		return nil, fmt.Errorf("failed to construct Promptkit-maintained profiles: %w", err)
+		return nil, err
 	}
-
-	profiles := newProfileRepository(cfg.ProfileDir, options, maintainedProfiles)
-	registry, err := backend.NewRegistry(maintained.Backends, options.backends)
-	if err != nil {
-		return nil, fmt.Errorf("failed to construct backend registry: %w", err)
-	}
-	manager, err := capacity.NewManager(registry.CapacityPolicies())
+	manager, err := capacity.NewManager(snapshot.CapacityPolicies())
 	if err != nil {
 		return nil, fmt.Errorf("failed to construct backend capacity manager: %w", err)
 	}
@@ -217,23 +131,7 @@ func New(cfg Config, options Options) (*Engine, error) {
 		reader = artifact.NewCompositeReader()
 	}
 
-	return &Engine{runner: usecase.NewRunnerWithRepairer(promptDefinitions, profiles, registry, reader, prompt.NewGoRenderer(), client, validator, usecase.NewDefaultOutputRepairer(client), manager, defaultRetries)}, nil
-}
-
-func newProfileRepository(profileDir string, options Options, maintained profile.Repository) profile.Repository {
-	repository := maintained
-	if options.fallbackProfileSource {
-		repository = profile.NewOverlayRepository(options.fallbackProfiles, repository)
-	}
-	if options.profileSource {
-		repository = profile.NewOverlayRepository(options.profiles, repository)
-	} else if strings.TrimSpace(profileDir) != "" {
-		repository = profile.NewOverlayRepository(profile.NewFilesystemRepository(profileDir), repository)
-	}
-	if options.memorySource {
-		repository = profile.NewOverlayRepository(options.memoryProfiles, repository)
-	}
-	return profile.NewResolvingRepository(repository)
+	return &Engine{runner: usecase.NewRunnerWithRepairer(snapshot, snapshot, snapshot, reader, prompt.NewGoRenderer(), client, validator, usecase.NewDefaultOutputRepairer(client), manager, defaultRetries)}, nil
 }
 
 func validateSourceFS(fsys fs.FS, root string) error {

internal/usecase/profile_inspection.go

@@ -19,15 +19,18 @@ func (r *Runner) resolveProfileSelection(
 	ctx context.Context,
 	profileID string,
 ) (*resolvedProfileSelection, error) {
-	normalizedID := strings.TrimSpace(profileID)
-	if normalizedID == "" {
+	lookupID := profileID
+	if strings.TrimSpace(lookupID) == "" {
 		return nil, fmt.Errorf("%w: profile id is required", ErrInvalidRequest)
 	}
 	if r == nil || r.profiles == nil {
 		return nil, fmt.Errorf("%w: profile repository is not configured", ErrProfileLoad)
 	}
+	if exact, ok := r.profiles.(interface{ ExactIDs() bool }); !ok || !exact.ExactIDs() {
+		lookupID = strings.TrimSpace(lookupID)
+	}
 
-	selectedProfile, err := r.profiles.GetProfile(ctx, normalizedID)
+	selectedProfile, err := r.profiles.GetProfile(ctx, lookupID)
 	if err != nil {
 		return nil, fmt.Errorf("%w: %w", ErrProfileLoad, err)
 	}
@@ -37,7 +40,7 @@ func (r *Runner) resolveProfileSelection(
 
 	profileValue := *selectedProfile
 	if profileValue.ResolvedTarget != nil {
-		return &resolvedProfileSelection{id: normalizedID, profile: &profileValue}, nil
+		return &resolvedProfileSelection{id: lookupID, profile: &profileValue}, nil
 	}
 	profileValue.BackendID = strings.TrimSpace(profileValue.BackendID)
 
@@ -54,7 +57,7 @@ func (r *Runner) resolveProfileSelection(
 	}
 
 	return &resolvedProfileSelection{
-		id:      normalizedID,
+		id:      lookupID,
 		profile: &profileValue,
 		backend: selectedBackend,
 	}, nil
@@ -80,8 +83,7 @@ func (r *Runner) InspectProfile(
 	ctx context.Context,
 	profileID string,
 ) (*domain.ProfileInspection, error) {
-	normalizedID := strings.TrimSpace(profileID)
-	if normalizedID == "" {
+	if strings.TrimSpace(profileID) == "" {
 		return nil, fmt.Errorf("%w: profile id is required", ErrInvalidRequest)
 	}
 	select {
@@ -90,7 +92,7 @@ func (r *Runner) InspectProfile(
 	default:
 	}
 
-	selection, err := r.resolveProfileSelection(ctx, normalizedID)
+	selection, err := r.resolveProfileSelection(ctx, profileID)
 	if err != nil {
 		return nil, err
 	}

internal/usecase/prompt_inspection.go

@@ -25,7 +25,16 @@ func (r *Runner) resolvePromptDefinition(
 		return nil, fmt.Errorf("%w: prompt repository is not configured", ErrPromptLoad)
 	}
 
-	definition, err := r.promptDefs.GetPromptDefinition(ctx, promptID, promptVersion)
+	var definition *domain.PromptDefinition
+	var hash string
+	var err error
+	if indexed, ok := r.promptDefs.(interface {
+		GetPromptSnapshot(context.Context, string, string) (*domain.PromptDefinition, string, error)
+	}); ok {
+		definition, hash, err = indexed.GetPromptSnapshot(ctx, promptID, promptVersion)
+	} else {
+		definition, err = r.promptDefs.GetPromptDefinition(ctx, promptID, promptVersion)
+	}
 	if err != nil {
 		return nil, fmt.Errorf("%w: %w", ErrPromptLoad, err)
 	}
@@ -33,9 +42,11 @@ func (r *Runner) resolvePromptDefinition(
 		return nil, fmt.Errorf("%w: prompt repository returned nil definition", ErrPromptLoad)
 	}
 
-	hash, err := hashPromptDefinition(definition)
-	if err != nil {
-		return nil, fmt.Errorf("%w: failed to hash prompt definition: %v", ErrPromptLoad, err)
+	if hash == "" {
+		hash, err = hashPromptDefinition(definition)
+		if err != nil {
+			return nil, fmt.Errorf("%w: failed to hash prompt definition: %v", ErrPromptLoad, err)
+		}
 	}
 	return &resolvedPromptDefinition{definition: definition, hash: hash}, nil
 }

internal/usecase/runner.go

@@ -339,9 +339,9 @@ func (r *Runner) resolvePreparation(
 		return nil, fmt.Errorf("%w: output contract: %v", ErrInvalidRequest, err)
 	}
 
-	selectedProfileID := strings.TrimSpace(req.ProfileID)
-	if selectedProfileID == "" {
-		selectedProfileID = strings.TrimSpace(def.DefaultProfile)
+	selectedProfileID := req.ProfileID
+	if strings.TrimSpace(selectedProfileID) == "" {
+		selectedProfileID = def.DefaultProfile
 	}
 	if selectedProfileID == "" {
 		return nil, fmt.Errorf("%w: %w: profile id is required either in request or prompt default_profile", ErrInvalidRequest, ErrProfileRequired)