Merge pull request #792 from seakee/fix/515-runtime-model-price-sync

🐛 fix(pricing): sync currently exposed CPA runtime models before first use (#515)

Author: seakee

apps/manager-server/internal/service/cpa/client.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -193,3 +194,95 @@ func readStringField(raw map[string]any, keys ...string) string {
 	}
 	return ""
 }
+
+func FetchAPIKeys(ctx context.Context, baseURL string, managementKey string) ([]string, error) {
+	normalizedURL := NormalizeBaseURL(baseURL)
+	if normalizedURL == "" {
+		return nil, errors.New("CPA base URL cannot be empty")
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, normalizedURL+"/v0/management/api-keys", nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Authorization", "Bearer "+strings.TrimSpace(managementKey))
+	client := &http.Client{Timeout: 30 * time.Second}
+	res, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode < 200 || res.StatusCode >= 300 {
+		return nil, fmt.Errorf("management API api-keys request failed: %s", res.Status)
+	}
+
+	var payload struct {
+		APIKeys []string `json:"api-keys"`
+	}
+	if err := json.NewDecoder(res.Body).Decode(&payload); err != nil {
+		return nil, err
+	}
+
+	keys := make([]string, 0, len(payload.APIKeys))
+	seen := make(map[string]struct{}, len(payload.APIKeys))
+	for _, rawKey := range payload.APIKeys {
+		trimmed := strings.TrimSpace(rawKey)
+		if trimmed == "" {
+			continue
+		}
+		if _, exists := seen[trimmed]; exists {
+			continue
+		}
+		seen[trimmed] = struct{}{}
+		keys = append(keys, trimmed)
+	}
+	return keys, nil
+}
+
+func FetchModels(ctx context.Context, baseURL string, apiKey string) ([]string, error) {
+	normalizedURL := NormalizeBaseURL(baseURL)
+	if normalizedURL == "" {
+		return nil, errors.New("CPA base URL cannot be empty")
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, normalizedURL+"/v1/models", nil)
+	if err != nil {
+		return nil, err
+	}
+	trimmedKey := strings.TrimSpace(apiKey)
+	if trimmedKey != "" {
+		req.Header.Set("Authorization", "Bearer "+trimmedKey)
+	}
+	client := &http.Client{Timeout: 30 * time.Second}
+	res, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode < 200 || res.StatusCode >= 300 {
+		return nil, fmt.Errorf("runtime models request failed: %s", res.Status)
+	}
+
+	var payload struct {
+		Data []struct {
+			ID string `json:"id"`
+		} `json:"data"`
+	}
+	if err := json.NewDecoder(res.Body).Decode(&payload); err != nil {
+		return nil, err
+	}
+
+	seen := make(map[string]struct{}, len(payload.Data))
+	models := make([]string, 0, len(payload.Data))
+	for _, item := range payload.Data {
+		trimmedID := strings.TrimSpace(item.ID)
+		if trimmedID == "" {
+			continue
+		}
+		if _, exists := seen[trimmedID]; exists {
+			continue
+		}
+		seen[trimmedID] = struct{}{}
+		models = append(models, trimmedID)
+	}
+	sort.Strings(models)
+	return models, nil
+}

apps/manager-server/internal/service/cpa/client_test.go

@@ -0,0 +1,122 @@
+package cpa
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+)
+
+func TestFetchAPIKeys(t *testing.T) {
+	expectedToken := "test-mgmt-key"
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/v0/management/api-keys" {
+			t.Errorf("unexpected path: %s", r.URL.Path)
+			http.NotFound(w, r)
+			return
+		}
+		auth := r.Header.Get("Authorization")
+		if auth != "Bearer "+expectedToken {
+			t.Errorf("unexpected auth header: %s", auth)
+			http.Error(w, "unauthorized", http.StatusUnauthorized)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"api-keys": []string{
+				"  key-1  ",
+				"",
+				"key-2",
+				"key-1",
+				"   ",
+				"key-3",
+			},
+		})
+	}))
+	defer server.Close()
+
+	ctx := context.Background()
+	keys, err := FetchAPIKeys(ctx, server.URL, expectedToken)
+	if err != nil {
+		t.Fatalf("FetchAPIKeys failed: %v", err)
+	}
+
+	expected := []string{"key-1", "key-2", "key-3"}
+	if !reflect.DeepEqual(keys, expected) {
+		t.Errorf("expected keys %v, got %v", expected, keys)
+	}
+}
+
+func TestFetchModelsWithAPIKey(t *testing.T) {
+	expectedToken := "client-key"
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/v1/models" {
+			t.Errorf("unexpected path: %s", r.URL.Path)
+			http.NotFound(w, r)
+			return
+		}
+		auth := r.Header.Get("Authorization")
+		if auth != "Bearer "+expectedToken {
+			t.Errorf("unexpected auth header: %s", auth)
+			http.Error(w, "unauthorized", http.StatusUnauthorized)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"object": "list",
+			"data": []map[string]any{
+				{"id": "gpt-b"},
+				{"id": " gpt-a "},
+				{"id": "gpt-a"},
+				{"id": ""},
+			},
+		})
+	}))
+	defer server.Close()
+
+	ctx := context.Background()
+	models, err := FetchModels(ctx, server.URL, expectedToken)
+	if err != nil {
+		t.Fatalf("FetchModels failed: %v", err)
+	}
+
+	expected := []string{"gpt-a", "gpt-b"}
+	if !reflect.DeepEqual(models, expected) {
+		t.Errorf("expected models %v, got %v", expected, models)
+	}
+}
+
+func TestFetchModelsAnonymous(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/v1/models" {
+			t.Errorf("unexpected path: %s", r.URL.Path)
+			http.NotFound(w, r)
+			return
+		}
+		if auth := r.Header.Get("Authorization"); auth != "" {
+			t.Errorf("expected no authorization header, got: %s", auth)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"object": "list",
+			"data": []map[string]any{
+				{"id": "anon-model-2"},
+				{"id": "anon-model-1"},
+			},
+		})
+	}))
+	defer server.Close()
+
+	ctx := context.Background()
+	models, err := FetchModels(ctx, server.URL, "")
+	if err != nil {
+		t.Fatalf("FetchModels failed: %v", err)
+	}
+
+	expected := []string{"anon-model-1", "anon-model-2"}
+	if !reflect.DeepEqual(models, expected) {
+		t.Errorf("expected models %v, got %v", expected, models)
+	}
+}