243 lines
8.7 KiB
Go
243 lines
8.7 KiB
Go
// 逻辑模型的前台目录与价格展示：把后台配置的逻辑模型投影成用户可见的列表和价格档。
|
|
|
|
package app
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
|
|
"infinite-canvas/backend/internal/model"
|
|
)
|
|
|
|
func (s *Service) PublicLogicalModels(intent *ModelRequestIntent) ([]PublicLogicalModel, error) {
|
|
snapshot, err := s.routeCatalogSnapshot()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
result := make([]PublicLogicalModel, 0, len(snapshot.Ordered))
|
|
for _, id := range snapshot.Ordered {
|
|
cached := snapshot.Models[id]
|
|
structuralSpecs := availableCachedRouteSpecs(cached.Routes)
|
|
coverageValid := logicalModelCapabilityCovered(cached.ProductSpec, structuralSpecs)
|
|
available := coverageValid && hasHealthyCachedRoute(s, cached.Routes)
|
|
if intent != nil {
|
|
resolvedIntent := *intent
|
|
resolvedIntent.Options = mergeIntentDefaults(intent.Options, cached.Defaults)
|
|
productMatch := MatchCapability(cached.ProductSpec, resolvedIntent)
|
|
if !productMatch.Matched {
|
|
continue
|
|
}
|
|
available = false
|
|
if coverageValid {
|
|
for _, route := range cached.Routes {
|
|
if route.Route.Enabled && route.Route.Weight > 0 && !s.logicalRouteBlocked(route) && MatchCapability(route.CapabilitySpec, resolvedIntent).Matched && (cached.Model.PricePolicy != "channel" || channelModelPriceTierForIntent(route.ChannelModel, resolvedIntent) != nil) {
|
|
available = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
result = append(result, publicLogicalModel(cached, available))
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func publicLogicalModel(cached cachedLogicalModel, available bool) PublicLogicalModel {
|
|
item := cached.Model
|
|
productSpec := capabilitySpecWithRoutePresets(cached.ProductSpec, enabledLogicalRouteSpecs(cached.Routes))
|
|
profiles := make([]CapabilitySpec, 0, len(cached.Routes))
|
|
seen := make(map[string]bool, len(cached.Routes))
|
|
for _, route := range cached.Routes {
|
|
if !route.Route.Enabled || route.Route.Weight <= 0 {
|
|
continue
|
|
}
|
|
key := capabilityFingerprint(route.CapabilitySpec)
|
|
if !seen[key] {
|
|
seen[key] = true
|
|
profiles = append(profiles, route.CapabilitySpec)
|
|
}
|
|
}
|
|
|
|
priceTiers := publicLogicalModelPriceTiers(cached)
|
|
pricingMode, displayPrice, priceLabel := computeModelPriceDisplay(item, priceTiers)
|
|
|
|
return PublicLogicalModel{
|
|
ID: item.ID, Code: item.Code, Name: item.Name, Icon: item.Icon,
|
|
Description: item.Description, Capability: item.Capability, SortOrder: item.SortOrder,
|
|
PricePolicy: item.PricePolicy, PricingMode: pricingMode, DisplayPrice: displayPrice,
|
|
PriceLabel: priceLabel, BillingMode: item.BillingMode,
|
|
UnitPriceMicrocredits: item.UnitPriceMicrocredits,
|
|
InputPriceMicrocredits: item.InputPriceMicrocredits,
|
|
OutputPriceMicrocredits: item.OutputPriceMicrocredits,
|
|
CachedPriceMicrocredits: item.CachedPriceMicrocredits,
|
|
PriceTiers: priceTiers, LegacyModelIDs: decodeLegacyModelIDs(item.LegacyModelIDsJSON),
|
|
CapabilitySpec: productSpec, CapabilityProfiles: profiles,
|
|
DefaultOptions: cached.Defaults, Available: available,
|
|
}
|
|
}
|
|
|
|
func publicLogicalModelPriceTiers(cached cachedLogicalModel) []PublicLogicalModelPriceTier {
|
|
if cached.Model.PricePolicy != "channel" {
|
|
return []PublicLogicalModelPriceTier{}
|
|
}
|
|
result := make([]PublicLogicalModelPriceTier, 0)
|
|
seen := make(map[string]bool)
|
|
for _, route := range cached.Routes {
|
|
if !route.Route.Enabled || route.Route.Weight <= 0 {
|
|
continue
|
|
}
|
|
for _, tier := range route.ChannelModel.PriceTiers {
|
|
if !tier.Enabled || !tier.PriceConfigured {
|
|
continue
|
|
}
|
|
selector := skuSelectorForTier(tier)
|
|
_, selectorKey, selectorErr := model.CanonicalSKUSelector(selector)
|
|
if selectorErr != nil {
|
|
continue
|
|
}
|
|
key := fmt.Sprintf("%s:%s:%d:%d:%d:%d", selectorKey, tier.BillingMode, tier.UnitPriceMicrocredits, tier.InputTokenPriceMicrocredits, tier.OutputTokenPriceMicrocredits, tier.CachedTokenPriceMicrocredits)
|
|
if seen[key] {
|
|
continue
|
|
}
|
|
seen[key] = true
|
|
result = append(result, PublicLogicalModelPriceTier{Selector: selector, Resolution: normalizeChannelModelTierResolution(tier.Resolution), VideoSeconds: tier.VideoSeconds, BillingMode: tier.BillingMode, UnitPriceMicrocredits: tier.UnitPriceMicrocredits, InputTokenPriceMicrocredits: tier.InputTokenPriceMicrocredits, OutputTokenPriceMicrocredits: tier.OutputTokenPriceMicrocredits, CachedTokenPriceMicrocredits: tier.CachedTokenPriceMicrocredits})
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func decodeLegacyModelIDs(raw string) []string {
|
|
var values []string
|
|
if err := json.Unmarshal([]byte(raw), &values); err != nil {
|
|
return []string{}
|
|
}
|
|
return normalizeLegacyModelIDs(values)
|
|
}
|
|
|
|
func normalizeLegacyModelIDs(values []string) []string {
|
|
result := make([]string, 0, len(values))
|
|
seen := make(map[string]bool, len(values))
|
|
for _, raw := range values {
|
|
value := strings.TrimSpace(raw)
|
|
if value == "" || seen[value] {
|
|
continue
|
|
}
|
|
seen[value] = true
|
|
result = append(result, value)
|
|
}
|
|
return result
|
|
}
|
|
|
|
func enabledLogicalRouteSpecs(routes []cachedLogicalRoute) []CapabilitySpec {
|
|
specs := make([]CapabilitySpec, 0, len(routes))
|
|
for _, route := range routes {
|
|
if !route.Route.Enabled || route.Route.Weight <= 0 {
|
|
continue
|
|
}
|
|
specs = append(specs, route.CapabilitySpec)
|
|
}
|
|
return specs
|
|
}
|
|
|
|
// capabilitySpecWithRoutePresets repairs old front-model snapshots that stored
|
|
// only `*` for a custom size. The wildcard remains for matching custom values,
|
|
// while route presets are restored for admin and creator-side selectors.
|
|
// Callers must pass only currently enabled routes; disabled or zero-weight
|
|
// routes would otherwise advertise size tiers the public catalog cannot route.
|
|
func capabilitySpecWithRoutePresets(spec CapabilitySpec, routes []CapabilitySpec) CapabilitySpec {
|
|
result := spec
|
|
result.Options = make(map[string]OptionConstraint, len(spec.Options))
|
|
for name, constraint := range spec.Options {
|
|
if !isWildcardOptionConstraint(constraint) {
|
|
result.Options[name] = constraint
|
|
continue
|
|
}
|
|
values := append([]any(nil), constraint.Values...)
|
|
seen := make(map[string]bool, len(values))
|
|
for _, value := range values {
|
|
seen[normalizedScalar(value)] = true
|
|
}
|
|
for _, route := range routes {
|
|
for _, value := range route.Options[name].Values {
|
|
key := normalizedScalar(value)
|
|
if key != "" && !seen[key] {
|
|
seen[key] = true
|
|
values = append(values, value)
|
|
}
|
|
}
|
|
}
|
|
result.Options[name] = OptionConstraint{Values: values}
|
|
}
|
|
// 前台规格里的预设可能只来自单条线路的快照（后续新增的供应线路还没同步进来），
|
|
// 因此不管自身是否已有预设都要与各线路取并集，否则多档会被压成单档。
|
|
if merged := mergeCapabilityImageSize(append([]CapabilitySpec{spec}, routes...)); merged != nil {
|
|
if result.ImageSize == nil {
|
|
result.ImageSize = merged
|
|
} else {
|
|
restored := *result.ImageSize
|
|
if restored.Parameter == "" {
|
|
restored.Parameter = merged.Parameter
|
|
}
|
|
if !restored.AllowCustom {
|
|
restored.AllowCustom = merged.AllowCustom
|
|
}
|
|
restored.Presets = merged.Presets
|
|
result.ImageSize = &restored
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func mergeCapabilityImageSize(specs []CapabilitySpec) *CapabilityImageSize {
|
|
var result *CapabilityImageSize
|
|
seen := map[string]bool{}
|
|
for _, spec := range specs {
|
|
part := spec.ImageSize
|
|
if part == nil {
|
|
continue
|
|
}
|
|
if result == nil {
|
|
result = &CapabilityImageSize{Parameter: part.Parameter, AllowCustom: part.AllowCustom}
|
|
} else {
|
|
if result.Parameter != "aspect_ratio" && part.Parameter == "aspect_ratio" {
|
|
result.Parameter = "aspect_ratio"
|
|
} else if result.Parameter == "" {
|
|
result.Parameter = part.Parameter
|
|
}
|
|
result.AllowCustom = result.AllowCustom || part.AllowCustom
|
|
}
|
|
for _, preset := range part.Presets {
|
|
key := preset.Tier + ":" + preset.Ratio + ":" + preset.Size
|
|
if key == "::" || seen[key] {
|
|
continue
|
|
}
|
|
seen[key] = true
|
|
result.Presets = append(result.Presets, preset)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
// capabilityFingerprint 用规范化后的结构去重能力画像；不能直接依赖原始 JSON，
|
|
// 因为同一组枚举能力的数组顺序不应造成重复展示。
|
|
func capabilityFingerprint(spec CapabilitySpec) string {
|
|
copySpec := spec
|
|
copySpec.Operations = append([]string(nil), spec.Operations...)
|
|
sort.Strings(copySpec.Operations)
|
|
copySpec.Inputs = make(map[string]InputConstraint, len(spec.Inputs))
|
|
for name, constraint := range spec.Inputs {
|
|
copySpec.Inputs[name] = constraint
|
|
}
|
|
copySpec.Options = make(map[string]OptionConstraint, len(spec.Options))
|
|
for name, constraint := range spec.Options {
|
|
values := append([]any(nil), constraint.Values...)
|
|
sort.SliceStable(values, func(i, j int) bool { return normalizedScalar(values[i]) < normalizedScalar(values[j]) })
|
|
constraint.Values = values
|
|
copySpec.Options[name] = constraint
|
|
}
|
|
encoded, _ := json.Marshal(copySpec)
|
|
return string(encoded)
|
|
}
|