feat(config): 运行时配置体系①——LLM 多厂商独立组落 models.json + 面板落盘 + 热更新
- runtimeconfig/models.go: models.json 承载 [{id,provider,baseUrl,apiKey,model,fallback?,multimodal?}] 多厂商独立组(首项=生效)
- LoadModels 优先文件/回退env(GroupFromEnv), SaveModels(0600+tmp原子写), Activate/Upsert/MaskedKey脱敏
- 面板 POST /admin/llm 落盘 models.json(取代temporary内存) + GET 列组(脱敏)
- runtime/model/runtime.go: RuntimeLLM(adapter+router) atomic快照可热替换, Reload 重建不中断进行中请求; per-role路由用接口
- wire 用 NewRuntimeLLM(adapter+router), 保留 a.modelAdapter(=runtime stack, 审查模型随热更新)
- .env 退兜底(.env.example注明); apiKey不打印/Config()脱敏/热更新不中断
- 全仓 go build/vet/test 绿(54包)+交叉编译+前端build绿(79模块); api-client v0.15已同步
- 遗留: vision ModelInfo 仍读静态env(后续纳入); 保存组=生效组(第一版语义)
This commit is contained in:
Aska committed
1 parent
8cde0162e6
commit
2d7151f979
16 files changed
+1079
-108
No files matched your search
@@ -0,0 +1,263 @@
|
||||
// Package runtimeconfig loads and persists the runtime-editable provider
|
||||
// configuration: the independent LLM vendor groups in models.json (design/04
|
||||
// §3.1). The .env LLM block is the final fallback; a present-and-valid
|
||||
// models.json takes precedence and is hot-reloaded at runtime without a restart.
|
||||
//
|
||||
// models.json is gitignored (local runtime config) and holds API keys, so this
|
||||
// package never logs a key and never exposes one un-masked in a Config().
|
||||
package runtimeconfig
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/internal/config"
|
||||
)
|
||||
|
||||
// Provider names recognized in models.json. They mirror the model adapter
|
||||
// factory's protocol names so a group maps directly to a wire protocol.
|
||||
const (
|
||||
ProviderOpenAI = "openai"
|
||||
ProviderAnthropic = "anthropic"
|
||||
|
||||
// modelsFileName is the models.json basename stored under the data dir.
|
||||
modelsFileName = "models.json"
|
||||
)
|
||||
|
||||
// Group is one independent multi-supplier LLM configuration. Each vendor's
|
||||
// base/key/model/fallback is a self-contained unit, so multiple vendors coexist
|
||||
// and Provider selects the active wire protocol.
|
||||
type Group struct {
|
||||
ID string `json:"id"`
|
||||
Provider string `json:"provider"`
|
||||
BaseURL string `json:"baseUrl"`
|
||||
APIKey string `json:"apiKey"`
|
||||
Model string `json:"model"`
|
||||
Fallback string `json:"fallback,omitempty"`
|
||||
Multimodal bool `json:"multimodal,omitempty"`
|
||||
}
|
||||
|
||||
// ErrInvalidGroup is returned when a group fails schema validation.
|
||||
var ErrInvalidGroup = errors.New("runtimeconfig: invalid model group")
|
||||
|
||||
// DefaultPath returns the models.json path under dataDir.
|
||||
func DefaultPath(dataDir string) string {
|
||||
return filepath.Join(dataDir, modelsFileName)
|
||||
}
|
||||
|
||||
// Validate checks the group's required fields. It fails loudly so a bad group
|
||||
// never silently produces a half-configured adapter.
|
||||
func (g Group) Validate() error {
|
||||
if strings.TrimSpace(g.ID) == "" {
|
||||
return fmt.Errorf("id is required")
|
||||
}
|
||||
if g.Provider != ProviderOpenAI && g.Provider != ProviderAnthropic {
|
||||
return fmt.Errorf("provider %q must be openai or anthropic", g.Provider)
|
||||
}
|
||||
if strings.TrimSpace(g.BaseURL) == "" {
|
||||
return fmt.Errorf("baseUrl is required")
|
||||
}
|
||||
if strings.TrimSpace(g.Model) == "" {
|
||||
return fmt.Errorf("model is required")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ToLLMConfig maps a group to the flat LLMConfig consumed by the adapter
|
||||
// factory. The group's provider selects which config block is populated.
|
||||
func (g Group) ToLLMConfig() config.LLMConfig {
|
||||
if g.Provider == ProviderAnthropic {
|
||||
return config.LLMConfig{
|
||||
Provider: ProviderAnthropic,
|
||||
AnthropicBaseURL: g.BaseURL,
|
||||
AnthropicAPIKey: g.APIKey,
|
||||
AnthropicModel: g.Model,
|
||||
AnthropicFallback: g.Fallback,
|
||||
}
|
||||
}
|
||||
return config.LLMConfig{
|
||||
Provider: ProviderOpenAI,
|
||||
BaseURL: g.BaseURL,
|
||||
APIKey: g.APIKey,
|
||||
Model: g.Model,
|
||||
Fallback: g.Fallback,
|
||||
}
|
||||
}
|
||||
|
||||
// MaskedKey returns a redacted form of the API key for display/logging. It never
|
||||
// reveals more than the trailing 4 characters, so a key never lands verbatim in
|
||||
// a log line or a wire response.
|
||||
func (g Group) MaskedKey() string {
|
||||
k := strings.TrimSpace(g.APIKey)
|
||||
if k == "" {
|
||||
return ""
|
||||
}
|
||||
if len(k) <= 4 {
|
||||
return "****"
|
||||
}
|
||||
return "****" + k[len(k)-4:]
|
||||
}
|
||||
|
||||
// LoadModels reads path and returns the effective LLM groups. When the file is
|
||||
// absent it synthesizes a single group from env (the .env fallback). A
|
||||
// present-but-invalid file falls back to env and returns a non-nil warning so
|
||||
// the caller can log it; the returned groups are always non-empty.
|
||||
func LoadModels(path string, env config.LLMConfig) ([]Group, error) {
|
||||
files, readErr := loadFile(path)
|
||||
if readErr == nil {
|
||||
return files, nil
|
||||
}
|
||||
// A missing file is the normal case (gitignored runtime config); only a
|
||||
// present-but-invalid file warrants a warning to the caller.
|
||||
var warn error
|
||||
if !os.IsNotExist(readErr) {
|
||||
warn = fmt.Errorf("runtimeconfig: %s: %w", path, readErr)
|
||||
}
|
||||
return GroupFromEnv(env), warn
|
||||
}
|
||||
|
||||
// loadFile decodes and validates the models.json array. A nil/blank file, a
|
||||
// JSON decode error or an empty array all return an error so the caller falls
|
||||
// back to env.
|
||||
func loadFile(path string) ([]Group, error) {
|
||||
raw, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(strings.TrimSpace(string(raw))) == 0 {
|
||||
return nil, fmt.Errorf("%w: empty file", ErrInvalidGroup)
|
||||
}
|
||||
var groups []Group
|
||||
dec := json.NewDecoder(strings.NewReader(string(raw)))
|
||||
if err := dec.Decode(&groups); err != nil {
|
||||
return nil, fmt.Errorf("%w: decode: %v", ErrInvalidGroup, err)
|
||||
}
|
||||
if len(groups) == 0 {
|
||||
return nil, fmt.Errorf("%w: no groups", ErrInvalidGroup)
|
||||
}
|
||||
for i, g := range groups {
|
||||
if err := g.Validate(); err != nil {
|
||||
return nil, fmt.Errorf("%w: group %d: %v", ErrInvalidGroup, i, err)
|
||||
}
|
||||
}
|
||||
return groups, nil
|
||||
}
|
||||
|
||||
// GroupFromEnv synthesizes a single group from the active env LLM block: the
|
||||
// anthropic block when LLM_PROVIDER=anthropic, otherwise the flat OpenAI-compatible
|
||||
// block. It is the .env fallback used when models.json is absent or invalid.
|
||||
func GroupFromEnv(env config.LLMConfig) []Group {
|
||||
if env.Provider == ProviderAnthropic {
|
||||
return []Group{{
|
||||
ID: ProviderAnthropic,
|
||||
Provider: ProviderAnthropic,
|
||||
BaseURL: env.AnthropicBaseURL,
|
||||
APIKey: env.AnthropicAPIKey,
|
||||
Model: env.AnthropicModel,
|
||||
Fallback: env.AnthropicFallback,
|
||||
Multimodal: env.VisionModel != "",
|
||||
}}
|
||||
}
|
||||
return []Group{{
|
||||
ID: ProviderOpenAI,
|
||||
Provider: ProviderOpenAI,
|
||||
BaseURL: env.BaseURL,
|
||||
APIKey: env.APIKey,
|
||||
Model: env.Model,
|
||||
Fallback: env.Fallback,
|
||||
Multimodal: env.VisionModel != "",
|
||||
}}
|
||||
}
|
||||
|
||||
// Upsert returns a copy of groups with g inserted or replaced in place by ID,
|
||||
// preserving order. A blank ID is assigned a generated id so a panel save
|
||||
// without an explicit id still produces a stable, addressable group.
|
||||
func Upsert(groups []Group, g Group) []Group {
|
||||
if strings.TrimSpace(g.ID) == "" {
|
||||
g.ID = NewID()
|
||||
}
|
||||
out := make([]Group, 0, len(groups)+1)
|
||||
replaced := false
|
||||
for _, cur := range groups {
|
||||
if cur.ID == g.ID {
|
||||
out = append(out, g)
|
||||
replaced = true
|
||||
continue
|
||||
}
|
||||
out = append(out, cur)
|
||||
}
|
||||
if !replaced {
|
||||
out = append(out, g)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// Activate returns groups with g promoted to the front (index 0 = the group a
|
||||
// new request uses by default). An existing group with the same id is replaced
|
||||
// and re-prepended, so a panel save both updates the group and makes it the live
|
||||
// provider. A blank ID is assigned a generated id.
|
||||
func Activate(groups []Group, g Group) []Group {
|
||||
if strings.TrimSpace(g.ID) == "" {
|
||||
g.ID = NewID()
|
||||
}
|
||||
out := make([]Group, 0, len(groups)+1)
|
||||
out = append(out, g)
|
||||
for _, cur := range groups {
|
||||
if cur.ID == g.ID {
|
||||
continue
|
||||
}
|
||||
out = append(out, cur)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// SaveModels writes groups as a pretty-printed JSON array to path with mode
|
||||
// 0600 (the file holds API keys). It writes to a temp file then renames so a
|
||||
// concurrent reader never sees a partial file. Every group is validated first.
|
||||
func SaveModels(path string, groups []Group) error {
|
||||
dir := filepath.Dir(path)
|
||||
if dir != "" && dir != "." {
|
||||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||||
return fmt.Errorf("runtimeconfig: mkdir: %w", err)
|
||||
}
|
||||
}
|
||||
for _, g := range groups {
|
||||
if err := g.Validate(); err != nil {
|
||||
return fmt.Errorf("runtimeconfig: save: %w", err)
|
||||
}
|
||||
}
|
||||
raw, err := json.MarshalIndent(groups, "", " ")
|
||||
if err != nil {
|
||||
return fmt.Errorf("runtimeconfig: marshal: %w", err)
|
||||
}
|
||||
tmp := path + ".tmp"
|
||||
if err := os.WriteFile(tmp, raw, 0o600); err != nil {
|
||||
return fmt.Errorf("runtimeconfig: write %s: %w", tmp, err)
|
||||
}
|
||||
if err := os.Rename(tmp, path); err != nil {
|
||||
return fmt.Errorf("runtimeconfig: rename: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// NewID returns a 16-byte hex id, used for a group saved without an explicit id.
|
||||
func NewID() string {
|
||||
b := make([]byte, 16)
|
||||
if _, err := rand.Read(b); err != nil {
|
||||
return fmt.Sprintf("id-%d", newTimeUnixNano())
|
||||
}
|
||||
return hex.EncodeToString(b)
|
||||
}
|
||||
|
||||
// newTimeUnixNano returns the current unix-nano as an integer, as a fallback id
|
||||
// source when the crypto RNG fails.
|
||||
func newTimeUnixNano() int64 {
|
||||
return time.Now().UnixNano()
|
||||
}
|
||||
@@ -0,0 +1,175 @@
|
||||
package runtimeconfig
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/internal/config"
|
||||
)
|
||||
|
||||
func envCfg() config.LLMConfig {
|
||||
return config.LLMConfig{
|
||||
Provider: ProviderOpenAI,
|
||||
BaseURL: "https://api.openai.com/v1",
|
||||
APIKey: "sk-env",
|
||||
Model: "gpt-4o",
|
||||
Fallback: "gpt-4o-mini",
|
||||
}
|
||||
}
|
||||
|
||||
func writeModelsFile(t *testing.T, content string) string {
|
||||
t.Helper()
|
||||
path := filepath.Join(t.TempDir(), "models.json")
|
||||
if err := os.WriteFile(path, []byte(content), 0o600); err != nil {
|
||||
t.Fatalf("write models.json: %v", err)
|
||||
}
|
||||
return path
|
||||
}
|
||||
|
||||
func TestLoadModels_FileValid(t *testing.T) {
|
||||
path := writeModelsFile(t, `[
|
||||
{"id":"openai","provider":"openai","baseUrl":"https://api.openai.com/v1","apiKey":"sk-1","model":"gpt-4o","fallback":"gpt-4o-mini","multimodal":true}
|
||||
]`)
|
||||
groups, warn := LoadModels(path, envCfg())
|
||||
if warn != nil {
|
||||
t.Fatalf("warn = %v, want nil", warn)
|
||||
}
|
||||
if len(groups) != 1 {
|
||||
t.Fatalf("len(groups) = %d, want 1", len(groups))
|
||||
}
|
||||
g := groups[0]
|
||||
if g.ID != "openai" || g.Provider != ProviderOpenAI || g.Model != "gpt-4o" || !g.Multimodal {
|
||||
t.Fatalf("group = %+v, want openai/gpt-4o/multimodal", g)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadModels_MissingFileFallsBackEnv(t *testing.T) {
|
||||
path := filepath.Join(t.TempDir(), "nonexistent.json")
|
||||
groups, warn := LoadModels(path, envCfg())
|
||||
if warn != nil {
|
||||
t.Fatalf("warn = %v, want nil (missing file is the normal case)", warn)
|
||||
}
|
||||
if len(groups) != 1 || groups[0].Model != "gpt-4o" || groups[0].APIKey != "sk-env" {
|
||||
t.Fatalf("groups = %+v, want env fallback gpt-4o/sk-env", groups)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadModels_InvalidFallsBackEnvWithWarn(t *testing.T) {
|
||||
path := writeModelsFile(t, `{ not json`)
|
||||
groups, warn := LoadModels(path, envCfg())
|
||||
if warn == nil {
|
||||
t.Fatal("warn = nil, want a warning for an invalid file")
|
||||
}
|
||||
if len(groups) != 1 || groups[0].APIKey != "sk-env" {
|
||||
t.Fatalf("groups = %+v, want env fallback", groups)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadModels_EmptyArrayFallsBackEnv(t *testing.T) {
|
||||
path := writeModelsFile(t, `[]`)
|
||||
groups, warn := LoadModels(path, envCfg())
|
||||
if warn == nil {
|
||||
t.Fatal("warn = nil, want a warning for an empty file")
|
||||
}
|
||||
if len(groups) != 1 {
|
||||
t.Fatalf("groups = %+v, want env fallback single group", groups)
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidate(t *testing.T) {
|
||||
valid := Group{ID: "a", Provider: ProviderOpenAI, BaseURL: "https://x", Model: "m"}
|
||||
if err := valid.Validate(); err != nil {
|
||||
t.Fatalf("valid group: %v", err)
|
||||
}
|
||||
cases := []Group{
|
||||
{ID: "", Provider: ProviderOpenAI, BaseURL: "https://x", Model: "m"},
|
||||
{ID: "a", Provider: "bogus", BaseURL: "https://x", Model: "m"},
|
||||
{ID: "a", Provider: ProviderOpenAI, BaseURL: "", Model: "m"},
|
||||
{ID: "a", Provider: ProviderOpenAI, BaseURL: "https://x", Model: ""},
|
||||
}
|
||||
for i, c := range cases {
|
||||
if err := c.Validate(); err == nil {
|
||||
t.Fatalf("case %d failed to validate: %+v", i, c)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestToLLMConfig(t *testing.T) {
|
||||
g := Group{ID: "a", Provider: ProviderOpenAI, BaseURL: "https://x", APIKey: "sk", Model: "m", Fallback: "f"}
|
||||
cfg := g.ToLLMConfig()
|
||||
if cfg.Provider != ProviderOpenAI || cfg.BaseURL != "https://x" || cfg.APIKey != "sk" || cfg.Model != "m" || cfg.Fallback != "f" {
|
||||
t.Fatalf("ToLLMConfig = %+v", cfg)
|
||||
}
|
||||
ag := Group{ID: "b", Provider: ProviderAnthropic, BaseURL: "https://y", APIKey: "sk2", Model: "claude"}
|
||||
acfg := ag.ToLLMConfig()
|
||||
if acfg.Provider != ProviderAnthropic || acfg.AnthropicBaseURL != "https://y" || acfg.AnthropicModel != "claude" {
|
||||
t.Fatalf("anthropic ToLLMConfig = %+v", acfg)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMaskedKey(t *testing.T) {
|
||||
empty := Group{APIKey: ""}.MaskedKey()
|
||||
if empty != "" {
|
||||
t.Fatalf("empty key masked = %q, want empty", empty)
|
||||
}
|
||||
short := Group{APIKey: "abc"}.MaskedKey()
|
||||
if short != "****" {
|
||||
t.Fatalf("short key masked = %q, want ****", short)
|
||||
}
|
||||
long := Group{APIKey: "sk-abcdef1234"}.MaskedKey()
|
||||
if long != "****1234" || strings.Contains(long, "sk-") {
|
||||
t.Fatalf("masked = %q, want ****1234 without the prefix", long)
|
||||
}
|
||||
}
|
||||
|
||||
func TestActivate(t *testing.T) {
|
||||
base := []Group{
|
||||
{ID: "openai", Provider: ProviderOpenAI, BaseURL: "https://a", Model: "gpt-4o"},
|
||||
{ID: "anthropic", Provider: ProviderAnthropic, BaseURL: "https://b", Model: "claude"},
|
||||
}
|
||||
// New group is prepended (becomes the active index 0).
|
||||
out := Activate(base, Group{ID: "deepseek", Provider: ProviderOpenAI, BaseURL: "https://c", Model: "ds"})
|
||||
if len(out) != 3 || out[0].ID != "deepseek" || out[1].ID != "openai" || out[2].ID != "anthropic" {
|
||||
t.Fatalf("Activate new = %+v", out)
|
||||
}
|
||||
// An existing group is replaced and promoted to the front.
|
||||
out2 := Activate(out, Group{ID: "openai", Provider: ProviderOpenAI, BaseURL: "https://a2", Model: "gpt-4o-new"})
|
||||
if len(out2) != 3 || out2[0].ID != "openai" || out2[0].Model != "gpt-4o-new" || out2[1].ID != "deepseek" {
|
||||
t.Fatalf("Activate existing = %+v", out2)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveLoadRoundTrip(t *testing.T) {
|
||||
path := filepath.Join(t.TempDir(), "models.json")
|
||||
in := []Group{
|
||||
{ID: "openai", Provider: ProviderOpenAI, BaseURL: "https://a", APIKey: "sk-secret", Model: "gpt-4o", Multimodal: true},
|
||||
{ID: "anthropic", Provider: ProviderAnthropic, BaseURL: "https://b", APIKey: "sk-ant", Model: "claude"},
|
||||
}
|
||||
if err := SaveModels(path, in); err != nil {
|
||||
t.Fatalf("SaveModels: %v", err)
|
||||
}
|
||||
groups, warn := LoadModels(path, envCfg())
|
||||
if warn != nil {
|
||||
t.Fatalf("warn = %v", warn)
|
||||
}
|
||||
if len(groups) != 2 || groups[0].APIKey != "sk-secret" || groups[1].APIKey != "sk-ant" {
|
||||
t.Fatalf("round trip = %+v", groups)
|
||||
}
|
||||
// The key stays in the file (it is the runtime config), but never leaks into
|
||||
// the masked view.
|
||||
if got := groups[0].MaskedKey(); got != "****cret" {
|
||||
t.Fatalf("masked key = %q, want ****cret", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveModels_RejectsInvalid(t *testing.T) {
|
||||
path := filepath.Join(t.TempDir(), "models.json")
|
||||
if err := SaveModels(path, []Group{{ID: "", Provider: "x", BaseURL: "https://a", Model: "m"}}); err == nil {
|
||||
t.Fatal("expected error saving an invalid group")
|
||||
}
|
||||
if _, statErr := os.Stat(path); !os.IsNotExist(statErr) {
|
||||
t.Fatalf("file should not be written when validation fails")
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user