128 lines
4.2 KiB
Go
128 lines
4.2 KiB
Go
package llm
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
ck "gitea.maximumdirect.net/eric/ConfigKit"
|
|
"gitea.maximumdirect.net/eric/audita/internal/core/config"
|
|
"gitea.maximumdirect.net/eric/audita/internal/core/redaction"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
type selectedProfileView struct {
|
|
ID string `yaml:"id"`
|
|
Backend string `yaml:"backend"`
|
|
Model string `yaml:"model"`
|
|
Temperature float64 `yaml:"temperature"`
|
|
MaxTokens int `yaml:"max_tokens"`
|
|
TopP float64 `yaml:"top_p"`
|
|
TimeoutSeconds int `yaml:"timeout_seconds"`
|
|
ServiceTier string `yaml:"service_tier,omitempty"`
|
|
ReasoningEffort string `yaml:"reasoning_effort,omitempty"`
|
|
}
|
|
|
|
// SelectedProfilesYAML exposes selected controls without endpoint, credential,
|
|
// or arbitrary extra provider parameters.
|
|
func (r *Runtime) SelectedProfilesYAML() ([]byte, error) {
|
|
if r == nil {
|
|
return nil, fmt.Errorf("LLM runtime is unavailable")
|
|
}
|
|
view := func(role string) (selectedProfileView, error) {
|
|
profile, ok := r.Profiles[role]
|
|
if !ok {
|
|
return selectedProfileView{}, fmt.Errorf("%s profile is unavailable", role)
|
|
}
|
|
target := profile.EffectiveModelParams
|
|
return selectedProfileView{ID: profile.ProfileID, Backend: target.BackendID, Model: target.Model,
|
|
Temperature: target.Temperature, MaxTokens: target.MaxTokens, TopP: target.TopP,
|
|
TimeoutSeconds: target.TimeoutSeconds, ServiceTier: target.ServiceTier, ReasoningEffort: target.ReasoningEffort}, nil
|
|
}
|
|
proposal, err := view("proposal")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
validation, err := view("validation")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
raw, err := yaml.Marshal(struct {
|
|
Proposal selectedProfileView `yaml:"proposal"`
|
|
Validation selectedProfileView `yaml:"validation"`
|
|
}{proposal, validation})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return redaction.New(ConfiguredSecrets(&r.Config)).YAML(raw)
|
|
}
|
|
|
|
type derivationView struct {
|
|
Operation ck.ChangeKind `yaml:"operation"`
|
|
Reason string `yaml:"reason"`
|
|
Dependencies []string `yaml:"dependencies,omitempty"`
|
|
}
|
|
type inheritanceStepView struct {
|
|
From string `yaml:"from"`
|
|
To string `yaml:"to"`
|
|
Reference string `yaml:"reference"`
|
|
}
|
|
type explanationView struct {
|
|
Path string `yaml:"path"`
|
|
Source string `yaml:"source"`
|
|
Layer ck.Layer `yaml:"layer"`
|
|
Derivations []derivationView `yaml:"derivations,omitempty"`
|
|
Inheritance []inheritanceStepView `yaml:"inheritance,omitempty"`
|
|
}
|
|
|
|
// ExplanationYAML reports only origins and recorded resolution operations.
|
|
// It intentionally excludes effective and historical values, including secrets.
|
|
func ExplanationYAML(result *ck.Result[config.Config]) ([]byte, error) {
|
|
if result == nil {
|
|
return nil, fmt.Errorf("configuration result is unavailable")
|
|
}
|
|
metadata := result.Metadata()
|
|
sources := make(map[string]string)
|
|
for _, source := range result.Sources() {
|
|
sources[source.ID] = source.Label
|
|
}
|
|
records := make([]explanationView, 0)
|
|
paths := metadata.HistoricalPaths()
|
|
for i, path := range paths {
|
|
if path.String() == "" {
|
|
continue
|
|
}
|
|
if i+1 < len(paths) && strings.HasPrefix(paths[i+1].String(), path.String()+"/") {
|
|
continue
|
|
}
|
|
info, ok := metadata.Lookup(path)
|
|
if !ok {
|
|
continue
|
|
}
|
|
record := explanationView{Path: path.String(), Layer: info.Origin.Layer, Source: string(info.Origin.Layer)}
|
|
for _, step := range info.Origin.Inheritance {
|
|
record.Inheritance = append(record.Inheritance, inheritanceStepView{
|
|
From: step.From.String(), To: step.To.String(), Reference: step.Reference.String(),
|
|
})
|
|
}
|
|
if len(info.Origin.Locations) > 0 {
|
|
if label := sources[info.Origin.Locations[0].SourceID]; label != "" {
|
|
record.Source = label
|
|
}
|
|
}
|
|
for _, change := range metadata.History(path) {
|
|
if change.Origin.Layer != ck.LayerResolution {
|
|
continue
|
|
}
|
|
for _, reason := range change.Reasons {
|
|
derivation := derivationView{Operation: change.Origin.Operation, Reason: reason}
|
|
for _, dependency := range change.Dependencies {
|
|
derivation.Dependencies = append(derivation.Dependencies, dependency.String())
|
|
}
|
|
record.Derivations = append(record.Derivations, derivation)
|
|
}
|
|
}
|
|
records = append(records, record)
|
|
}
|
|
return yaml.Marshal(records)
|
|
}
|