feat(aa): persist full AA model data in kv_settings cache

Store AAModelInfo (score, coding/math index, speed, pricing) keyed by
normalized OR-compatible IDs in kv_settings under aa.models.cache.
Startup uses cache if < 24h old, skipping the live API call.
Manual Refresh always re-fetches and updates the cache.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Alexey Panfilov

cmd/agent/main.go

@@ -301,7 +301,8 @@ func main() {
 
 	if cfg.AdminAPI.Enabled {
 		capStore, _ := s.(llm.CapabilityStore)
-		adminSrv := adminapi.New(cfg.AdminAPI, router, capStore, cfg, logger)
+		settingsStore, _ := s.(llm.SettingsStore)
+		adminSrv := adminapi.New(cfg.AdminAPI, router, capStore, settingsStore, cfg, logger)
 		if err := adminSrv.Start(); err != nil {
 			logger.Error("admin API failed to start", "err", err)
 		} else {
@@ -427,36 +428,54 @@ func hydrateOpenRouterCapabilities(cfg *config.Config, providers map[string]llm.
 	}
 }
 
-// hydrateArtificialAnalysisScores fetches Intelligence Index scores from
-// Artificial Analysis and merges them into the CapabilityStore. Requires
-// AA_API_KEY in config or environment. Silently skips when not configured.
+// hydrateArtificialAnalysisScores loads AA model data (from cache or live API)
+// and merges Intelligence Index scores into the CapabilityStore.
+// Silently skips when not configured.
 func hydrateArtificialAnalysisScores(cfg *config.Config, s store.Store, logger *slog.Logger) {
 	apiKey := cfg.ArtificialAnalysisAPIKey
 	if apiKey == "" {
 		return
 	}
-
 	capStore, ok := s.(llm.CapabilityStore)
 	if !ok {
 		return
 	}
+	settings, ok := s.(llm.SettingsStore)
+	if !ok {
+		return
+	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
-	scores, err := llm.FetchArtificialAnalysisScores(ctx, apiKey)
+	// Try cache first; fetch from API if absent or expired.
+	var models map[string]llm.AAModelInfo
+	cache, err := llm.LoadAACache(ctx, settings)
 	if err != nil {
-		logger.Warn("artificialanalysis scores fetch failed", "err", err)
-		return
+		logger.Warn("aa cache load failed", "err", err)
+	}
+	if cache != nil {
+		models = cache.Models
+		logger.Info("aa cache loaded", "models", len(models), "age", time.Since(cache.FetchedAt).Round(time.Minute))
+	} else {
+		models, err = llm.FetchArtificialAnalysisData(ctx, apiKey)
+		if err != nil {
+			logger.Warn("artificialanalysis fetch failed", "err", err)
+			return
+		}
+		if storeErr := llm.StoreAACache(ctx, settings, models); storeErr != nil {
+			logger.Warn("aa cache store failed", "err", storeErr)
+		} else {
+			logger.Info("aa cache stored", "models", len(models))
+		}
 	}
 
-	// Load cached caps, overlay scores, write back.
 	caps, err := capStore.GetAllCapabilities(ctx, "openrouter")
 	if err != nil {
-		logger.Warn("failed to load cached capabilities for AA merge", "err", err)
+		logger.Warn("failed to load capabilities for AA merge", "err", err)
 		return
 	}
-	llm.MergeAAScores(caps, scores)
+	llm.MergeAAScores(caps, models)
 	updated := 0
 	for id, c := range caps {
 		if c.Score == 0 {
@@ -468,5 +487,5 @@ func hydrateArtificialAnalysisScores(cfg *config.Config, s store.Store, logger *
 			updated++
 		}
 	}
-	logger.Info("artificialanalysis scores merged", "total", len(scores), "updated", updated)
+	logger.Info("artificialanalysis scores merged", "models", len(models), "updated", updated)
 }

internal/adminapi/handlers.go

@@ -178,13 +178,19 @@ func (s *Server) handleRefresh(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// Overlay AA Intelligence Index scores if configured.
+	// Overlay AA Intelligence Index scores if configured — always re-fetch on
+	// manual Refresh (bypass cache) and update the stored cache.
 	if aaKey := s.cfgRef.ArtificialAnalysisAPIKey; aaKey != "" {
-		if scores, aaErr := llm.FetchArtificialAnalysisScores(ctx, aaKey); aaErr != nil {
-			s.logger.Warn("AA scores refresh failed", "err", aaErr)
+		if models, aaErr := llm.FetchArtificialAnalysisData(ctx, aaKey); aaErr != nil {
+			s.logger.Warn("AA data refresh failed", "err", aaErr)
 		} else {
-			llm.MergeAAScores(caps, scores)
-			s.logger.Info("AA scores refreshed", "count", len(scores))
+			llm.MergeAAScores(caps, models)
+			s.logger.Info("AA data refreshed", "models", len(models))
+			if s.settings != nil {
+				if storeErr := llm.StoreAACache(ctx, s.settings, models); storeErr != nil {
+					s.logger.Warn("AA cache store failed", "err", storeErr)
+				}
+			}
 		}
 	}
 

internal/adminapi/server.go

@@ -22,22 +22,24 @@ type Server struct {
 	cfg      config.AdminAPIConfig
 	router   *llm.Router
 	capStore llm.CapabilityStore
-	cfgRef   *config.Config // needed for enumerating OpenRouter slots
+	settings llm.SettingsStore // for AA cache persistence; may be nil
+	cfgRef   *config.Config    // needed for enumerating OpenRouter slots
 	logger   *slog.Logger
 
 	httpSrv *http.Server
 }
 
 // New constructs the admin API server but does not start it. Call Start to
 // bind the listener.
-func New(cfg config.AdminAPIConfig, router *llm.Router, capStore llm.CapabilityStore, cfgRef *config.Config, logger *slog.Logger) *Server {
+func New(cfg config.AdminAPIConfig, router *llm.Router, capStore llm.CapabilityStore, settings llm.SettingsStore, cfgRef *config.Config, logger *slog.Logger) *Server {
 	if cfg.ForwardAuthHeader == "" {
 		cfg.ForwardAuthHeader = "X-authentik-username"
 	}
 	return &Server{
 		cfg:      cfg,
 		router:   router,
 		capStore: capStore,
+		settings: settings,
 		cfgRef:   cfgRef,
 		logger:   logger,
 	}

internal/llm/artificialanalysis.go

@@ -10,16 +10,37 @@ import (
 	"time"
 )
 
+const aaSettingsKey = "aa.models.cache"
+const aaCacheTTL = 24 * time.Hour
+
 var aaHTTPClient = &http.Client{Timeout: 20 * time.Second}
 
-// FetchArtificialAnalysisScores fetches the Intelligence Index scores from the
-// Artificial Analysis API and returns a map[modelSlug]score. The slug format
-// used by AA differs from OpenRouter IDs, so callers should merge by AA slug
-// after mapping through the openrouter_slug field.
+// AAModelInfo holds normalized AA data for a single model, keyed by the
+// OR-compatible slug (dots replaced with dashes in version segments).
+type AAModelInfo struct {
+	AASlug      string  `json:"aa_slug"`
+	CreatorSlug string  `json:"creator_slug"`
+	Score       float64 `json:"score,omitempty"`       // Intelligence Index
+	CodingIndex float64 `json:"coding_index,omitempty"` // Coding Index
+	MathIndex   float64 `json:"math_index,omitempty"`   // Math Index
+	SpeedTPS    float64 `json:"speed_tps,omitempty"`    // median output tokens/sec
+	TTFT        float64 `json:"ttft_s,omitempty"`       // median time-to-first-token, seconds
+	PriceInput  float64 `json:"price_input_1m,omitempty"`
+	PriceOutput float64 `json:"price_output_1m,omitempty"`
+}
+
+// AACache is the kv_settings blob stored under aaSettingsKey.
+type AACache struct {
+	FetchedAt time.Time              `json:"fetched_at"`
+	Models    map[string]AAModelInfo `json:"models"` // key = normalized OR-compatible ID
+}
+
+// FetchArtificialAnalysisData fetches full model data from the AA API and
+// returns it as a normalized map keyed by OR-compatible IDs.
 //
 // API docs: https://artificialanalysis.ai/api-reference
 // Free tier: 1000 req/day, attribution required.
-func FetchArtificialAnalysisScores(ctx context.Context, apiKey string) (map[string]float64, error) {
+func FetchArtificialAnalysisData(ctx context.Context, apiKey string) (map[string]AAModelInfo, error) {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://artificialanalysis.ai/api/v2/data/llms/models", nil)
 	if err != nil {
 		return nil, err
@@ -39,7 +60,7 @@ func FetchArtificialAnalysisScores(ctx context.Context, apiKey string) (map[stri
 	if resp.StatusCode != 200 {
 		return nil, fmt.Errorf("artificialanalysis /api/v2/data/llms/models: HTTP %d: %s", resp.StatusCode, string(body))
 	}
-	return parseAAModels(body)
+	return parseAAData(body)
 }
 
 type aaModelsResponse struct {
@@ -50,53 +71,95 @@ type aaModelsResponse struct {
 			Slug string `json:"slug"`
 		} `json:"model_creator"`
 		Evaluations struct {
-			ArtificialAnalysisIntelligenceIndex *float64 `json:"artificial_analysis_intelligence_index"`
+			IntelligenceIndex *float64 `json:"artificial_analysis_intelligence_index"`
+			CodingIndex       *float64 `json:"artificial_analysis_coding_index"`
+			MathIndex         *float64 `json:"artificial_analysis_math_index"`
 		} `json:"evaluations"`
+		MedianOutputTPS  float64 `json:"median_output_tokens_per_second"`
+		MedianTTFT       float64 `json:"median_time_to_first_token_seconds"`
+		Pricing          struct {
+			Input  float64 `json:"price_1m_input_tokens"`
+			Output float64 `json:"price_1m_output_tokens"`
+		} `json:"pricing"`
 	} `json:"data"`
 }
 
-func parseAAModels(body []byte) (map[string]float64, error) {
+// normalizeAAKey converts an AA {creator}/{slug} into an OR-compatible key
+// by replacing dots with dashes (AA uses dashes, OR uses dots for versions).
+func normalizeAAKey(creator, slug string) string {
+	return strings.ReplaceAll(creator+"/"+slug, ".", "-")
+}
+
+func parseAAData(body []byte) (map[string]AAModelInfo, error) {
 	var resp aaModelsResponse
 	if err := json.Unmarshal(body, &resp); err != nil {
 		return nil, fmt.Errorf("artificialanalysis /data/llms/models: parse: %w", err)
 	}
-	out := make(map[string]float64, len(resp.Data))
+	out := make(map[string]AAModelInfo, len(resp.Data))
 	for _, m := range resp.Data {
-		score := m.Evaluations.ArtificialAnalysisIntelligenceIndex
-		if score == nil || *score == 0 {
+		if m.ModelCreator.Slug == "" || m.Slug == "" {
 			continue
 		}
-		// AA v2 uses {creator_slug}/{model_slug} format, which maps to OpenRouter IDs
-		// after normalizing dots↔dashes (done in MergeAAScores).
-		if m.ModelCreator.Slug != "" && m.Slug != "" {
-			out[m.ModelCreator.Slug+"/"+m.Slug] = *score
+		info := AAModelInfo{
+			AASlug:      m.Slug,
+			CreatorSlug: m.ModelCreator.Slug,
+			SpeedTPS:    m.MedianOutputTPS,
+			TTFT:        m.MedianTTFT,
+			PriceInput:  m.Pricing.Input,
+			PriceOutput: m.Pricing.Output,
 		}
+		if v := m.Evaluations.IntelligenceIndex; v != nil {
+			info.Score = *v
+		}
+		if v := m.Evaluations.CodingIndex; v != nil {
+			info.CodingIndex = *v
+		}
+		if v := m.Evaluations.MathIndex; v != nil {
+			info.MathIndex = *v
+		}
+		out[normalizeAAKey(m.ModelCreator.Slug, m.Slug)] = info
 	}
 	return out, nil
 }
 
-// MergeAAScores overlays AA Intelligence Index scores onto an existing
-// capabilities map (keyed by OpenRouter model ID). Models not found in scores
-// keep their existing Score value.
-//
-// AA slugs use dashes for version separators (gemini-2-5-pro) while OpenRouter
-// uses dots (gemini-2.5-pro), so we try both exact and dot→dash normalized match.
-func MergeAAScores(caps map[string]Capabilities, scores map[string]float64) {
-	// Build a dot→dash normalized lookup so OR IDs like "google/gemini-2.5-pro"
-	// match AA slugs like "google/gemini-2-5-pro".
-	normed := make(map[string]float64, len(scores))
-	for k, v := range scores {
-		normed[strings.ReplaceAll(k, ".", "-")] = v
+// StoreAACache persists the AA model map into kv_settings.
+func StoreAACache(ctx context.Context, settings SettingsStore, models map[string]AAModelInfo) error {
+	cache := AACache{FetchedAt: time.Now(), Models: models}
+	data, err := json.Marshal(cache)
+	if err != nil {
+		return fmt.Errorf("aa cache marshal: %w", err)
 	}
+	return settings.PutSetting(ctx, aaSettingsKey, string(data))
+}
+
+// LoadAACache reads the AA model cache from kv_settings.
+// Returns (nil, nil) when absent or expired.
+func LoadAACache(ctx context.Context, settings SettingsStore) (*AACache, error) {
+	raw, ok, err := settings.GetSetting(ctx, aaSettingsKey)
+	if err != nil || !ok {
+		return nil, err
+	}
+	var cache AACache
+	if err := json.Unmarshal([]byte(raw), &cache); err != nil {
+		return nil, fmt.Errorf("aa cache unmarshal: %w", err)
+	}
+	if time.Since(cache.FetchedAt) > aaCacheTTL {
+		return nil, nil
+	}
+	return &cache, nil
+}
 
+// MergeAAScores overlays AA Intelligence Index scores onto an existing
+// capabilities map (keyed by OpenRouter model ID). Models not found in the
+// AA cache keep their existing Score value.
+//
+// OR IDs use dots for version separators (gemini-2.5-pro) while AA keys use
+// dashes (gemini-2-5-pro), so we normalize both sides before matching.
+func MergeAAScores(caps map[string]Capabilities, models map[string]AAModelInfo) {
 	for id, c := range caps {
-		if s, ok := scores[id]; ok {
-			c.Score = s
-			caps[id] = c
-			continue
-		}
-		if s, ok := normed[strings.ReplaceAll(id, ".", "-")]; ok {
-			c.Score = s
+		key := strings.ReplaceAll(id, ".", "-")
+		if info, ok := models[key]; ok && info.Score > 0 {
+			c.Score = info.Score
 			caps[id] = c
 		}
 	}