feat: add gateway billing estimate and rate limit details

2026-05-15 01:53:52 +08:00
parent bdc9be63d5
commit 37d0f919e5
14 changed files with 916 additions and 66 deletions
@@ -11,8 +11,10 @@ import (
 )

 type EstimateResult struct {
-	Items    []any  `json:"items"`
-	Resolver string `json:"resolver"`
+	Items       []any   `json:"items"`
+	Resolver    string  `json:"resolver"`
+	TotalAmount float64 `json:"totalAmount"`
+	Currency    string  `json:"currency"`
 }

 func (s *Service) Estimate(ctx context.Context, kind string, model string, body map[string]any, user *auth.User) (EstimateResult, error) {
@@ -23,9 +25,12 @@ func (s *Service) Estimate(ctx context.Context, kind string, model string, body
 	}
 	candidate := candidates[0]
 	body = preprocessRequest(kind, body, candidate)
+	items := s.estimatedBillings(ctx, user, kind, body, candidate)
 	return EstimateResult{
-		Items:    s.estimatedBillings(ctx, user, kind, body, candidate),
-		Resolver: "effective-pricing-v1",
+		Items:       items,
+		Resolver:    "effective-pricing-v1",
+		TotalAmount: totalBillingAmount(items),
+		Currency:    billingCurrency(items),
 	}, nil
 }

@@ -60,10 +65,7 @@ func (s *Service) billings(ctx context.Context, user *auth.User, kind string, bo
 			billingLine(candidate, "text_output", "1k_tokens", outputTokens, outputAmount, discount, simulated),
 		}
 	}
-	count := int(floatFromAny(body["n"]))
-	if count <= 0 {
-		count = 1
-	}
+	count := requestOutputCount(body)
 	resource := "image"
 	unit := "image"
 	baseKey := "imageBase"
@@ -73,8 +75,24 @@ func (s *Service) billings(ctx context.Context, user *auth.User, kind string, bo
 	}
 	if kind == "videos.generations" {
 		resource = "video"
-		unit = "video"
+		unit = "5s_video"
 		baseKey = "videoBase"
+		duration := requestDurationSeconds(body)
+		durationUnits := math.Max(1, math.Ceil(duration/5))
+		amount := float64(count) *
+			durationUnits *
+			resourcePrice(config, resource, baseKey, "basePrice") *
+			resourceWeight(config, resource, "resolutionWeights", firstNonEmptyString(stringFromMap(body, "resolution"), stringFromMap(body, "size"))) *
+			resourceWeight(config, resource, "audioWeights", boolWeightKey(boolishValue(body["audio"]))) *
+			resourceWeight(config, resource, "referenceVideoWeights", boolWeightKey(requestHasReferenceVideo(body))) *
+			resourceWeight(config, resource, "voiceSpecifiedWeights", boolWeightKey(requestHasVoiceID(body))) *
+			discount
+		return []any{billingLineWithDetails(candidate, resource, unit, count*int(durationUnits), roundPrice(amount), discount, simulated, map[string]any{
+			"count":             count,
+			"durationSeconds":   duration,
+			"durationUnit":      "5s",
+			"durationUnitCount": durationUnits,
+		})}
 	}
 	amount := float64(count) * resourcePrice(config, resource, baseKey, "basePrice") * resourceWeight(config, resource, "qualityWeights", stringFromMap(body, "quality")) * resourceWeight(config, resource, "sizeWeights", stringFromMap(body, "size")) * resourceWeight(config, resource, "resolutionWeights", firstNonEmptyString(stringFromMap(body, "resolution"), stringFromMap(body, "size"))) * discount
 	return []any{billingLine(candidate, resource, unit, count, roundPrice(amount), discount, simulated)}
@@ -109,17 +127,23 @@ func effectiveDiscount(ctx context.Context, db *store.Store, user *auth.User, ca
 	if discount <= 0 {
 		discount = 1
 	}
-	if group, err := db.ResolveUserGroupPolicy(ctx, user); err == nil {
-		groupDiscount := floatFromAny(group.BillingDiscountPolicy["discountFactor"])
-		if groupDiscount > 0 {
-			discount *= groupDiscount
+	if db != nil {
+		if group, err := db.ResolveUserGroupPolicy(ctx, user); err == nil {
+			groupDiscount := floatFromAny(group.BillingDiscountPolicy["discountFactor"])
+			if groupDiscount > 0 {
+				discount *= groupDiscount
+			}
 		}
 	}
 	return discount
 }

 func billingLine(candidate store.RuntimeModelCandidate, resourceType string, unit string, quantity any, amount float64, discount float64, simulated bool) map[string]any {
-	return map[string]any{
+	return billingLineWithDetails(candidate, resourceType, unit, quantity, amount, discount, simulated, nil)
+}
+
+func billingLineWithDetails(candidate store.RuntimeModelCandidate, resourceType string, unit string, quantity any, amount float64, discount float64, simulated bool, details map[string]any) map[string]any {
+	line := map[string]any{
 		"model":           candidate.ModelName,
 		"modelAlias":      candidate.ModelAlias,
 		"provider":        candidate.Provider,
@@ -133,6 +157,10 @@ func billingLine(candidate store.RuntimeModelCandidate, resourceType string, uni
 		"discountFactor":  discount,
 		"simulated":       simulated,
 	}
+	for key, value := range details {
+		line[key] = value
+	}
+	return line
 }

 func price(config map[string]any, key string) float64 {
@@ -177,7 +205,16 @@ func weighted(config map[string]any, key string, name string) float64 {
 }

 func resourceWeight(config map[string]any, resource string, key string, name string) float64 {
-	if value := weighted(config, key, name); value != 1 {
+	keys := weightKeyAliases(key)
+	names := weightValueAliases(key, name)
+	for _, candidateKey := range keys {
+		for _, candidateName := range names {
+			if value := weighted(config, candidateKey, candidateName); value != 1 {
+				return value
+			}
+		}
+	}
+	if value := dynamicWeight(config["dynamicWeight"], keys, names); value != 1 {
 		return value
 	}
 	if strings.TrimSpace(name) == "" {
@@ -187,19 +224,201 @@ func resourceWeight(config map[string]any, resource string, key string, name str
 	if len(resourceConfig) == 0 && resource == "image_edit" {
 		resourceConfig, _ = config["image"].(map[string]any)
 	}
-	if weights, ok := resourceConfig["dynamicWeight"].(map[string]any); ok {
-		if value := floatFromAny(weights[name]); value > 0 {
-			return value
+	if value := dynamicWeight(resourceConfig["dynamicWeight"], keys, names); value != 1 {
+		return value
+	}
+	for _, candidateKey := range keys {
+		if weights, ok := resourceConfig[candidateKey].(map[string]any); ok {
+			for _, candidateName := range names {
+				if value := floatFromAny(weights[candidateName]); value > 0 {
+					return value
+				}
+			}
 		}
 	}
-	if weights, ok := resourceConfig[key].(map[string]any); ok {
-		if value := floatFromAny(weights[name]); value > 0 {
+	return 1
+}
+
+func dynamicWeight(value any, keys []string, names []string) float64 {
+	if len(names) == 0 {
+		return 1
+	}
+	weights, _ := value.(map[string]any)
+	if len(weights) == 0 {
+		return 1
+	}
+	for _, name := range names {
+		if direct := floatFromAny(weights[name]); direct > 0 {
+			return direct
+		}
+	}
+	for _, key := range keys {
+		if nested, ok := weights[key].(map[string]any); ok {
+			for _, name := range names {
+				if nestedValue := floatFromAny(nested[name]); nestedValue > 0 {
+					return nestedValue
+				}
+			}
+		}
+	}
+	return 1
+}
+
+func weightKeyAliases(key string) []string {
+	switch key {
+	case "qualityWeights":
+		return []string{"qualityWeights", "qualityFactors"}
+	case "resolutionWeights":
+		return []string{"resolutionWeights", "resolutionFactors"}
+	case "audioWeights":
+		return []string{"audioWeights", "audioFactors"}
+	case "referenceVideoWeights":
+		return []string{"referenceVideoWeights", "referenceVideoFactors"}
+	case "voiceSpecifiedWeights":
+		return []string{"voiceSpecifiedWeights", "voiceSpecifiedFactors"}
+	default:
+		return []string{key}
+	}
+}
+
+func weightValueAliases(key string, name string) []string {
+	name = strings.TrimSpace(name)
+	if name == "" {
+		return nil
+	}
+	switch key {
+	case "audioWeights":
+		return []string{name, "audio-" + name}
+	case "referenceVideoWeights":
+		return []string{name, "reference-video-" + name}
+	case "voiceSpecifiedWeights":
+		return []string{name, "voice-specified-" + name}
+	default:
+		return []string{name}
+	}
+}
+
+func requestOutputCount(body map[string]any) int {
+	for _, key := range []string{"n", "count", "batch_size", "batchSize"} {
+		if value := int(math.Ceil(floatFromAny(body[key]))); value > 0 {
 			return value
 		}
 	}
 	return 1
 }

+func requestDurationSeconds(body map[string]any) float64 {
+	for _, key := range []string{"duration", "durationSeconds", "duration_seconds"} {
+		if value := floatFromAny(body[key]); value > 0 {
+			return value
+		}
+	}
+	for _, value := range body {
+		items, ok := value.([]any)
+		if !ok || len(items) == 0 {
+			continue
+		}
+		total := 0.0
+		allDurationItems := true
+		for _, item := range items {
+			record, ok := item.(map[string]any)
+			if !ok {
+				allDurationItems = false
+				break
+			}
+			duration := floatFromAny(record["duration"])
+			if duration <= 0 {
+				allDurationItems = false
+				break
+			}
+			total += duration
+		}
+		if allDurationItems && total > 0 {
+			return total
+		}
+	}
+	return 5
+}
+
+func requestHasReferenceVideo(body map[string]any) bool {
+	if hasNonEmptyArray(body["video_list"]) || hasNonEmptyArray(body["videoList"]) {
+		return true
+	}
+	if firstNonEmptyStringValue(body, "video", "video_url", "videoUrl", "reference_video", "referenceVideo") != "" {
+		return true
+	}
+	content, _ := body["content"].([]any)
+	for _, item := range content {
+		record, _ := item.(map[string]any)
+		if len(record) == 0 {
+			continue
+		}
+		itemType := strings.TrimSpace(stringFromAny(record["type"]))
+		role := strings.TrimSpace(stringFromAny(record["role"]))
+		if itemType == "video_url" || role == "video_feature" || role == "video_base" || role == "reference_video" {
+			return true
+		}
+	}
+	return false
+}
+
+func requestHasVoiceID(body map[string]any) bool {
+	return boolishValue(body["audio"]) && firstNonEmptyStringValue(body, "voice_id", "voiceId") != ""
+}
+
+func boolWeightKey(value bool) string {
+	if value {
+		return "true"
+	}
+	return "false"
+}
+
+func boolishValue(value any) bool {
+	switch typed := value.(type) {
+	case bool:
+		return typed
+	case string:
+		switch strings.ToLower(strings.TrimSpace(typed)) {
+		case "true", "1", "yes", "on":
+			return true
+		default:
+			return false
+		}
+	case int:
+		return typed != 0
+	case int64:
+		return typed != 0
+	case float64:
+		return typed != 0
+	default:
+		return false
+	}
+}
+
+func hasNonEmptyArray(value any) bool {
+	items, ok := value.([]any)
+	return ok && len(items) > 0
+}
+
+func totalBillingAmount(items []any) float64 {
+	total := 0.0
+	for _, raw := range items {
+		line, _ := raw.(map[string]any)
+		total += floatFromAny(line["amount"])
+	}
+	return roundPrice(total)
+}
+
+func billingCurrency(items []any) string {
+	for _, raw := range items {
+		line, _ := raw.(map[string]any)
+		if currency := stringFromAny(line["currency"]); currency != "" {
+			return currency
+		}
+	}
+	return "resource"
+}
+
 func firstNonEmptyString(values ...string) string {
 	for _, value := range values {
 		if strings.TrimSpace(value) != "" {