123 lines
4.6 KiB
Go
123 lines
4.6 KiB
Go
package llm
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync/atomic"
|
|
|
|
ck "gitea.maximumdirect.net/eric/ConfigKit"
|
|
"gitea.maximumdirect.net/eric/audita/internal/core/config"
|
|
"gitea.maximumdirect.net/eric/audita/internal/core/redaction"
|
|
"gitea.maximumdirect.net/eric/audita/internal/framework/responseschema"
|
|
"gitea.maximumdirect.net/eric/audita/internal/prompts"
|
|
pk "gitea.maximumdirect.net/eric/promptkit"
|
|
)
|
|
|
|
// Runtime owns one PromptKit engine and the validated selections for both roles.
|
|
// The same engine is shared by the role-bound clients during processing.
|
|
type Runtime struct {
|
|
Config config.Config
|
|
Engine *pk.Engine
|
|
Profiles map[string]pk.ProfileInspection
|
|
// ProfilePaths contains filesystem sources actually read by PromptKit.
|
|
ProfilePaths []string
|
|
nextCallID atomic.Uint64
|
|
}
|
|
|
|
// AssetError indicates a broken embedded prompt or schema rather than an
|
|
// operator-provided setting or profile.
|
|
type AssetError struct{ Err error }
|
|
|
|
func (e *AssetError) Error() string { return e.Err.Error() }
|
|
func (e *AssetError) Unwrap() error { return e.Err }
|
|
|
|
func NewRuntime(ctx context.Context, c config.Config, mainPath string, client *http.Client) (*Runtime, error) {
|
|
profileDir := c.ProfilesDir
|
|
if !filepath.IsAbs(profileDir) {
|
|
profileDir = filepath.Join(filepath.Dir(mainPath), profileDir)
|
|
}
|
|
promptInputs, err := pk.FilesystemInputs("Audita embedded prompts", prompts.Filesystem(), prompts.AssetRoot)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("discover embedded prompts: %w", err)
|
|
}
|
|
profileInputs, err := pk.DirectoryInputs(profileDir)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("discover operator definitions: %w", err)
|
|
}
|
|
applicationBackends := make(map[string]any, len(c.Backends))
|
|
for id := range c.Backends {
|
|
backend := c.Backends[id]
|
|
applicationBackends[id] = map[string]any{
|
|
"endpoint": backend.Endpoint,
|
|
"concurrency_limit": backend.Concurrency,
|
|
"queue_capacity": backend.QueueCapacity,
|
|
"api_key_env": nil,
|
|
}
|
|
}
|
|
sources := pk.ConfigurationSources{
|
|
Underlays: []ck.Underlay{
|
|
{Inputs: promptInputs},
|
|
{Inputs: profileInputs},
|
|
},
|
|
Main: &ck.Input{Source: ck.Mapping("application backends", map[string]any{"backends": applicationBackends})},
|
|
}
|
|
engine, err := pk.NewEngine(pk.Config{
|
|
Sources: sources,
|
|
HTTPClient: client,
|
|
TransientRetries: &c.LLM.TransientRetries,
|
|
}, pk.WithSchemaFS(responseschema.Filesystem(), responseschema.AssetRoot))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("assemble LLM runtime: %w", err)
|
|
}
|
|
for _, meta := range prompts.RegisteredMetadata() {
|
|
if _, err := engine.InspectPrompt(ctx, meta.PromptID, meta.PromptVersion); err != nil {
|
|
return nil, &AssetError{Err: fmt.Errorf("inspect embedded prompt %s: %w", meta.PromptID, err)}
|
|
}
|
|
}
|
|
runtime := &Runtime{Config: c, Engine: engine, Profiles: make(map[string]pk.ProfileInspection, 2)}
|
|
for _, selection := range []struct{ role, id string }{{"proposal", c.LLM.ProposalProfile}, {"validation", c.LLM.ValidationProfile}} {
|
|
profile, err := engine.InspectProfile(ctx, selection.id)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("inspect %s profile: %w", selection.role, err)
|
|
}
|
|
target := profile.EffectiveModelParams
|
|
backend, ok := c.Backends[target.BackendID]
|
|
if !ok {
|
|
return nil, fmt.Errorf("%s profile must select a registered application backend", selection.role)
|
|
}
|
|
if strings.TrimSpace(target.Model) == "" {
|
|
return nil, fmt.Errorf("%s profile must select a nonblank model", selection.role)
|
|
}
|
|
if strings.TrimSpace(target.Endpoint) == "" {
|
|
return nil, fmt.Errorf("%s profile must resolve to a nonblank endpoint", selection.role)
|
|
}
|
|
endpoint := func(value string) string { return strings.TrimRight(strings.TrimSpace(value), "/") }
|
|
if endpoint(target.Endpoint) != endpoint(backend.Endpoint) {
|
|
return nil, fmt.Errorf("%s profile endpoint must match its registered backend", selection.role)
|
|
}
|
|
if target.APIKeyEnv != "" {
|
|
return nil, fmt.Errorf("%s profile must use the backend credential, not its own environment lookup", selection.role)
|
|
}
|
|
if profile.APIKeyRequired && backend.Credential == nil {
|
|
return nil, fmt.Errorf("%s profile requires a backend credential", selection.role)
|
|
}
|
|
runtime.Profiles[selection.role] = *profile
|
|
}
|
|
return runtime, nil
|
|
}
|
|
|
|
func IsAssetError(err error) bool { var target *AssetError; return errors.As(err, &target) }
|
|
|
|
// RedactError replaces every configured resolved backend secret before a
|
|
// library error is surfaced in CLI output or an artifact.
|
|
func RedactError(err error, c config.Config) string {
|
|
if err == nil {
|
|
return ""
|
|
}
|
|
return redaction.New(ConfiguredSecrets(&c)).String(err.Error())
|
|
}
|