feat(channel): 渠道管理全链路集成 — 模型映射、定价、限制、用量统计

- 渠道模型映射：支持精确匹配和通配符映射，按平台隔离
- 渠道模型定价：支持 token/按次/图片三种计费模式，区间分层定价
- 模型限制：渠道可限制仅允许定价列表中的模型
- 计费模型来源：支持 requested/upstream 两种计费模型选择
- 用量统计：usage_logs 新增 channel_id/model_mapping_chain/billing_tier/billing_mode 字段
- Dashboard 支持 model_source 维度（requested/upstream/mapping）查看模型统计
- 全部 gateway handler 统一接入 ResolveChannelMappingAndRestrict
- 修复测试：同步 SoraGenerationRepository 接口、SQL INSERT 参数、scan 字段

backend/internal/service/gateway_service.go

@@ -7407,11 +7407,7 @@ type RecordUsageInput struct {
 	ForceCacheBilling  bool               // 强制缓存计费：将 input_tokens 转为 cache_read 计费（用于粘性会话切换）
 	APIKeyService      APIKeyQuotaUpdater // 可选：用于更新API Key配额
 
-	// 渠道映射信息（由 handler 在 Forward 前解析）
-	ChannelID          int64  // 渠道 ID（0 = 无渠道）
-	OriginalModel      string // 用户原始请求模型（渠道映射前）
-	BillingModelSource string // 计费模型来源："requested" / "upstream"
-	ModelMappingChain  string // 映射链描述，如 "a→b→c"
+	ChannelUsageFields // 渠道映射信息（由 handler 在 Forward 前解析）
 }
 
 // APIKeyQuotaUpdater defines the interface for updating API Key quota and rate limit usage
@@ -7940,11 +7936,7 @@ type RecordUsageLongContextInput struct {
 	ForceCacheBilling     bool               // 强制缓存计费：将 input_tokens 转为 cache_read 计费（用于粘性会话切换）
 	APIKeyService         APIKeyQuotaUpdater // API Key 配额服务（可选）
 
-	// 渠道映射信息（由 handler 在 Forward 前解析）
-	ChannelID          int64  // 渠道 ID（0 = 无渠道）
-	OriginalModel      string // 用户原始请求模型（渠道映射前）
-	BillingModelSource string // 计费模型来源："requested" / "upstream"
-	ModelMappingChain  string // 映射链描述，如 "a→b→c"
+	ChannelUsageFields // 渠道映射信息（由 handler 在 Forward 前解析）
 }
 
 // RecordUsageWithLongContext 记录使用量并扣费，支持长上下文双倍计费（用于 Gemini）

backend/internal/service/model_pricing_resolver_test.go

@@ -4,14 +4,12 @@ package service
 
 import (
 	"context"
+	"errors"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 )
 
-func resolverPtrFloat64(v float64) *float64 { return &v }
-func resolverPtrInt(v int) *int             { return &v }
-
 func newTestBillingServiceForResolver() *BillingService {
 	bs := &BillingService{
 		fallbackPrices: make(map[string]*ModelPricing),
@@ -83,8 +81,8 @@ func TestGetIntervalPricing_MatchesInterval(t *testing.T) {
 		BasePricing:            &ModelPricing{InputPricePerToken: 5e-6},
 		SupportsCacheBreakdown: true,
 		Intervals: []PricingInterval{
-			{MinTokens: 0, MaxTokens: resolverPtrInt(128000), InputPrice: resolverPtrFloat64(1e-6), OutputPrice: resolverPtrFloat64(2e-6)},
-			{MinTokens: 128000, MaxTokens: nil, InputPrice: resolverPtrFloat64(3e-6), OutputPrice: resolverPtrFloat64(6e-6)},
+			{MinTokens: 0, MaxTokens: testPtrInt(128000), InputPrice: testPtrFloat64(1e-6), OutputPrice: testPtrFloat64(2e-6)},
+			{MinTokens: 128000, MaxTokens: nil, InputPrice: testPtrFloat64(3e-6), OutputPrice: testPtrFloat64(6e-6)},
 		},
 	}
 
@@ -108,7 +106,7 @@ func TestGetIntervalPricing_NoMatch_FallsBackToBase(t *testing.T) {
 		Mode:        BillingModeToken,
 		BasePricing: basePricing,
 		Intervals: []PricingInterval{
-			{MinTokens: 10000, MaxTokens: resolverPtrInt(50000), InputPrice: resolverPtrFloat64(1e-6)},
+			{MinTokens: 10000, MaxTokens: testPtrInt(50000), InputPrice: testPtrFloat64(1e-6)},
 		},
 	}
 
@@ -123,8 +121,8 @@ func TestGetRequestTierPrice(t *testing.T) {
 	resolved := &ResolvedPricing{
 		Mode: BillingModePerRequest,
 		RequestTiers: []PricingInterval{
-			{TierLabel: "1K", PerRequestPrice: resolverPtrFloat64(0.04)},
-			{TierLabel: "2K", PerRequestPrice: resolverPtrFloat64(0.08)},
+			{TierLabel: "1K", PerRequestPrice: testPtrFloat64(0.04)},
+			{TierLabel: "2K", PerRequestPrice: testPtrFloat64(0.08)},
 		},
 	}
 
@@ -140,8 +138,8 @@ func TestGetRequestTierPriceByContext(t *testing.T) {
 	resolved := &ResolvedPricing{
 		Mode: BillingModePerRequest,
 		RequestTiers: []PricingInterval{
-			{MinTokens: 0, MaxTokens: resolverPtrInt(128000), PerRequestPrice: resolverPtrFloat64(0.05)},
-			{MinTokens: 128000, MaxTokens: nil, PerRequestPrice: resolverPtrFloat64(0.10)},
+			{MinTokens: 0, MaxTokens: testPtrInt(128000), PerRequestPrice: testPtrFloat64(0.05)},
+			{MinTokens: 128000, MaxTokens: nil, PerRequestPrice: testPtrFloat64(0.10)},
 		},
 	}
 
@@ -162,3 +160,428 @@ func TestGetRequestTierPrice_NilPerRequestPrice(t *testing.T) {
 
 	require.InDelta(t, 0.0, r.GetRequestTierPrice(resolved, "1K"), 1e-12)
 }
+
+// ===========================================================================
+// Channel override tests — exercises applyChannelOverrides via Resolve
+// ===========================================================================
+
+// helper: creates a resolver wired to a ChannelService that returns the given
+// channel (active, groupID=100, platform=anthropic) with the specified pricing.
+func newResolverWithChannel(t *testing.T, pricing []ChannelModelPricing) *ModelPricingResolver {
+	t.Helper()
+	const groupID = 100
+	repo := &mockChannelRepository{
+		listAllFn: func(_ context.Context) ([]Channel, error) {
+			return []Channel{{
+				ID:           1,
+				Name:         "test-channel",
+				Status:       StatusActive,
+				GroupIDs:     []int64{groupID},
+				ModelPricing: pricing,
+			}}, nil
+		},
+		getGroupPlatformsFn: func(_ context.Context, _ []int64) (map[int64]string, error) {
+			return map[int64]string{groupID: "anthropic"}, nil
+		},
+	}
+	cs := NewChannelService(repo, nil)
+	bs := newTestBillingServiceForResolver()
+	return NewModelPricingResolver(cs, bs)
+}
+
+// groupIDPtr returns a pointer to groupID 100 (the test constant).
+func groupIDPtr() *int64 { v := int64(100); return &v }
+
+// ---------------------------------------------------------------------------
+// 1. Token mode overrides
+// ---------------------------------------------------------------------------
+
+func TestResolve_WithChannelOverride_TokenFlat(t *testing.T) {
+	r := newResolverWithChannel(t, []ChannelModelPricing{{
+		Platform:    "anthropic",
+		Models:      []string{"claude-sonnet-4"},
+		BillingMode: BillingModeToken,
+		InputPrice:  testPtrFloat64(10e-6),
+		OutputPrice: testPtrFloat64(50e-6),
+	}})
+
+	resolved := r.Resolve(context.Background(), PricingInput{
+		Model:   "claude-sonnet-4",
+		GroupID: groupIDPtr(),
+	})
+
+	require.NotNil(t, resolved)
+	require.Equal(t, BillingModeToken, resolved.Mode)
+	require.Equal(t, "channel", resolved.Source)
+	require.NotNil(t, resolved.BasePricing)
+	require.InDelta(t, 10e-6, resolved.BasePricing.InputPricePerToken, 1e-12)
+	require.InDelta(t, 10e-6, resolved.BasePricing.InputPricePerTokenPriority, 1e-12)
+	require.InDelta(t, 50e-6, resolved.BasePricing.OutputPricePerToken, 1e-12)
+	require.InDelta(t, 50e-6, resolved.BasePricing.OutputPricePerTokenPriority, 1e-12)
+}
+
+func TestResolve_WithChannelOverride_TokenPartialOverride(t *testing.T) {
+	// Channel only sets InputPrice; OutputPrice should remain from the base (LiteLLM/fallback).
+	r := newResolverWithChannel(t, []ChannelModelPricing{{
+		Platform:    "anthropic",
+		Models:      []string{"claude-sonnet-4"},
+		BillingMode: BillingModeToken,
+		InputPrice:  testPtrFloat64(20e-6),
+		// OutputPrice intentionally nil
+	}})
+
+	resolved := r.Resolve(context.Background(), PricingInput{
+		Model:   "claude-sonnet-4",
+		GroupID: groupIDPtr(),
+	})
+
+	require.NotNil(t, resolved)
+	require.Equal(t, "channel", resolved.Source)
+	require.NotNil(t, resolved.BasePricing)
+	// InputPrice overridden by channel
+	require.InDelta(t, 20e-6, resolved.BasePricing.InputPricePerToken, 1e-12)
+	// OutputPrice kept from base (fallback: 15e-6)
+	require.InDelta(t, 15e-6, resolved.BasePricing.OutputPricePerToken, 1e-12)
+}
+
+func TestResolve_WithChannelOverride_TokenWithIntervals(t *testing.T) {
+	r := newResolverWithChannel(t, []ChannelModelPricing{{
+		Platform:    "anthropic",
+		Models:      []string{"claude-sonnet-4"},
+		BillingMode: BillingModeToken,
+		Intervals: []PricingInterval{
+			{MinTokens: 0, MaxTokens: testPtrInt(128000), InputPrice: testPtrFloat64(2e-6), OutputPrice: testPtrFloat64(8e-6)},
+			{MinTokens: 128000, MaxTokens: nil, InputPrice: testPtrFloat64(4e-6), OutputPrice: testPtrFloat64(16e-6)},
+		},
+	}})
+
+	resolved := r.Resolve(context.Background(), PricingInput{
+		Model:   "claude-sonnet-4",
+		GroupID: groupIDPtr(),
+	})
+
+	require.NotNil(t, resolved)
+	require.Equal(t, "channel", resolved.Source)
+	require.Len(t, resolved.Intervals, 2)
+
+	// GetIntervalPricing should use channel intervals
+	iv := r.GetIntervalPricing(resolved, 50000)
+	require.NotNil(t, iv)
+	require.InDelta(t, 2e-6, iv.InputPricePerToken, 1e-12)
+	require.InDelta(t, 8e-6, iv.OutputPricePerToken, 1e-12)
+
+	iv2 := r.GetIntervalPricing(resolved, 200000)
+	require.NotNil(t, iv2)
+	require.InDelta(t, 4e-6, iv2.InputPricePerToken, 1e-12)
+	require.InDelta(t, 16e-6, iv2.OutputPricePerToken, 1e-12)
+}
+
+func TestResolve_WithChannelOverride_TokenNilBasePricing(t *testing.T) {
+	// Base pricing is nil (unknown model), channel has flat prices → creates new BasePricing.
+	r := newResolverWithChannel(t, []ChannelModelPricing{{
+		Platform:    "anthropic",
+		Models:      []string{"unknown-model-xyz"},
+		BillingMode: BillingModeToken,
+		InputPrice:  testPtrFloat64(7e-6),
+		OutputPrice: testPtrFloat64(21e-6),
+	}})
+
+	resolved := r.Resolve(context.Background(), PricingInput{
+		Model:   "unknown-model-xyz",
+		GroupID: groupIDPtr(),
+	})
+
+	require.NotNil(t, resolved)
+	require.Equal(t, "channel", resolved.Source)
+	// BasePricing was nil from resolveBasePricing but applyTokenOverrides creates a new one
+	require.NotNil(t, resolved.BasePricing)
+	require.InDelta(t, 7e-6, resolved.BasePricing.InputPricePerToken, 1e-12)
+	require.InDelta(t, 21e-6, resolved.BasePricing.OutputPricePerToken, 1e-12)
+}
+
+// ---------------------------------------------------------------------------
+// 2. Per-request mode overrides
+// ---------------------------------------------------------------------------
+
+func TestResolve_WithChannelOverride_PerRequest(t *testing.T) {
+	r := newResolverWithChannel(t, []ChannelModelPricing{{
+		Platform:        "anthropic",
+		Models:          []string{"claude-sonnet-4"},
+		BillingMode:     BillingModePerRequest,
+		PerRequestPrice: testPtrFloat64(0.05),
+		Intervals: []PricingInterval{
+			{MinTokens: 0, MaxTokens: testPtrInt(128000), PerRequestPrice: testPtrFloat64(0.03)},
+			{MinTokens: 128000, MaxTokens: nil, PerRequestPrice: testPtrFloat64(0.10)},
+		},
+	}})
+
+	resolved := r.Resolve(context.Background(), PricingInput{
+		Model:   "claude-sonnet-4",
+		GroupID: groupIDPtr(),
+	})
+
+	require.NotNil(t, resolved)
+	require.Equal(t, BillingModePerRequest, resolved.Mode)
+	require.Equal(t, "channel", resolved.Source)
+	require.InDelta(t, 0.05, resolved.DefaultPerRequestPrice, 1e-12)
+	require.Len(t, resolved.RequestTiers, 2)
+
+	// Verify tier lookups
+	require.InDelta(t, 0.03, r.GetRequestTierPriceByContext(resolved, 50000), 1e-12)
+	require.InDelta(t, 0.10, r.GetRequestTierPriceByContext(resolved, 200000), 1e-12)
+}
+
+func TestResolve_WithChannelOverride_PerRequestNilPrice(t *testing.T) {
+	// PerRequestPrice nil → DefaultPerRequestPrice stays 0.
+	r := newResolverWithChannel(t, []ChannelModelPricing{{
+		Platform:    "anthropic",
+		Models:      []string{"claude-sonnet-4"},
+		BillingMode: BillingModePerRequest,
+		// PerRequestPrice intentionally nil
+		Intervals: []PricingInterval{
+			{MinTokens: 0, MaxTokens: testPtrInt(128000), PerRequestPrice: testPtrFloat64(0.02)},
+		},
+	}})
+
+	resolved := r.Resolve(context.Background(), PricingInput{
+		Model:   "claude-sonnet-4",
+		GroupID: groupIDPtr(),
+	})
+
+	require.NotNil(t, resolved)
+	require.Equal(t, BillingModePerRequest, resolved.Mode)
+	require.InDelta(t, 0.0, resolved.DefaultPerRequestPrice, 1e-12)
+	require.Len(t, resolved.RequestTiers, 1)
+}
+
+// ---------------------------------------------------------------------------
+// 3. Image mode overrides
+// ---------------------------------------------------------------------------
+
+func TestResolve_WithChannelOverride_Image(t *testing.T) {
+	r := newResolverWithChannel(t, []ChannelModelPricing{{
+		Platform:        "anthropic",
+		Models:          []string{"claude-sonnet-4"},
+		BillingMode:     BillingModeImage,
+		PerRequestPrice: testPtrFloat64(0.08),
+		Intervals: []PricingInterval{
+			{TierLabel: "1K", PerRequestPrice: testPtrFloat64(0.04)},
+			{TierLabel: "2K", PerRequestPrice: testPtrFloat64(0.08)},
+			{TierLabel: "4K", PerRequestPrice: testPtrFloat64(0.16)},
+		},
+	}})
+
+	resolved := r.Resolve(context.Background(), PricingInput{
+		Model:   "claude-sonnet-4",
+		GroupID: groupIDPtr(),
+	})
+
+	require.NotNil(t, resolved)
+	require.Equal(t, BillingModeImage, resolved.Mode)
+	require.Equal(t, "channel", resolved.Source)
+	require.InDelta(t, 0.08, resolved.DefaultPerRequestPrice, 1e-12)
+	require.Len(t, resolved.RequestTiers, 3)
+}
+
+func TestResolve_WithChannelOverride_ImageTierLabels(t *testing.T) {
+	r := newResolverWithChannel(t, []ChannelModelPricing{{
+		Platform:    "anthropic",
+		Models:      []string{"claude-sonnet-4"},
+		BillingMode: BillingModeImage,
+		Intervals: []PricingInterval{
+			{TierLabel: "1K", PerRequestPrice: testPtrFloat64(0.04)},
+			{TierLabel: "2K", PerRequestPrice: testPtrFloat64(0.08)},
+			{TierLabel: "4K", PerRequestPrice: testPtrFloat64(0.16)},
+		},
+	}})
+
+	resolved := r.Resolve(context.Background(), PricingInput{
+		Model:   "claude-sonnet-4",
+		GroupID: groupIDPtr(),
+	})
+
+	require.InDelta(t, 0.04, r.GetRequestTierPrice(resolved, "1K"), 1e-12)
+	require.InDelta(t, 0.08, r.GetRequestTierPrice(resolved, "2K"), 1e-12)
+	require.InDelta(t, 0.16, r.GetRequestTierPrice(resolved, "4K"), 1e-12)
+	require.InDelta(t, 0.0, r.GetRequestTierPrice(resolved, "8K"), 1e-12) // not found
+}
+
+// ---------------------------------------------------------------------------
+// 4. Source tracking & default mode
+// ---------------------------------------------------------------------------
+
+func TestResolve_WithChannelOverride_SourceIsChannel(t *testing.T) {
+	r := newResolverWithChannel(t, []ChannelModelPricing{{
+		Platform:    "anthropic",
+		Models:      []string{"claude-sonnet-4"},
+		BillingMode: BillingModeToken,
+		InputPrice:  testPtrFloat64(1e-6),
+	}})
+
+	resolved := r.Resolve(context.Background(), PricingInput{
+		Model:   "claude-sonnet-4",
+		GroupID: groupIDPtr(),
+	})
+
+	require.Equal(t, "channel", resolved.Source)
+}
+
+func TestResolve_WithChannelOverride_DefaultMode(t *testing.T) {
+	// Channel pricing with empty BillingMode → defaults to BillingModeToken.
+	r := newResolverWithChannel(t, []ChannelModelPricing{{
+		Platform:    "anthropic",
+		Models:      []string{"claude-sonnet-4"},
+		BillingMode: "", // intentionally empty
+		InputPrice:  testPtrFloat64(5e-6),
+	}})
+
+	resolved := r.Resolve(context.Background(), PricingInput{
+		Model:   "claude-sonnet-4",
+		GroupID: groupIDPtr(),
+	})
+
+	require.Equal(t, "channel", resolved.Source)
+	require.Equal(t, BillingModeToken, resolved.Mode)
+	require.NotNil(t, resolved.BasePricing)
+	require.InDelta(t, 5e-6, resolved.BasePricing.InputPricePerToken, 1e-12)
+}
+
+// ---------------------------------------------------------------------------
+// 5. GetIntervalPricing integration after channel override
+// ---------------------------------------------------------------------------
+
+func TestGetIntervalPricing_WithChannelIntervals(t *testing.T) {
+	// Channel provides intervals that override the base pricing path.
+	r := newResolverWithChannel(t, []ChannelModelPricing{{
+		Platform:    "anthropic",
+		Models:      []string{"claude-sonnet-4"},
+		BillingMode: BillingModeToken,
+		Intervals: []PricingInterval{
+			{MinTokens: 0, MaxTokens: testPtrInt(100000), InputPrice: testPtrFloat64(1e-6), OutputPrice: testPtrFloat64(5e-6)},
+			{MinTokens: 100000, MaxTokens: nil, InputPrice: testPtrFloat64(2e-6), OutputPrice: testPtrFloat64(10e-6)},
+		},
+	}})
+
+	resolved := r.Resolve(context.Background(), PricingInput{
+		Model:   "claude-sonnet-4",
+		GroupID: groupIDPtr(),
+	})
+
+	// Token count 50000 matches first interval
+	pricing := r.GetIntervalPricing(resolved, 50000)
+	require.NotNil(t, pricing)
+	require.InDelta(t, 1e-6, pricing.InputPricePerToken, 1e-12)
+	require.InDelta(t, 5e-6, pricing.OutputPricePerToken, 1e-12)
+
+	// Token count 150000 matches second interval
+	pricing2 := r.GetIntervalPricing(resolved, 150000)
+	require.NotNil(t, pricing2)
+	require.InDelta(t, 2e-6, pricing2.InputPricePerToken, 1e-12)
+	require.InDelta(t, 10e-6, pricing2.OutputPricePerToken, 1e-12)
+}
+
+func TestGetIntervalPricing_ChannelIntervalsNoMatch(t *testing.T) {
+	// Channel intervals don't match token count → falls back to BasePricing.
+	r := newResolverWithChannel(t, []ChannelModelPricing{{
+		Platform:    "anthropic",
+		Models:      []string{"claude-sonnet-4"},
+		BillingMode: BillingModeToken,
+		Intervals: []PricingInterval{
+			// Only covers tokens > 50000
+			{MinTokens: 50000, MaxTokens: testPtrInt(200000), InputPrice: testPtrFloat64(9e-6)},
+		},
+	}})
+
+	resolved := r.Resolve(context.Background(), PricingInput{
+		Model:   "claude-sonnet-4",
+		GroupID: groupIDPtr(),
+	})
+
+	// Token count 1000 doesn't match any interval (1000 <= 50000 minTokens)
+	pricing := r.GetIntervalPricing(resolved, 1000)
+	// Should fall back to BasePricing (from the billing service fallback)
+	require.NotNil(t, pricing)
+	require.Equal(t, resolved.BasePricing, pricing)
+	require.InDelta(t, 3e-6, pricing.InputPricePerToken, 1e-12) // original base price
+}
+
+// ===========================================================================
+// 6. Error path tests
+// ===========================================================================
+
+func TestResolve_WithChannelOverride_CacheError(t *testing.T) {
+	// When ListAll returns an error, the ChannelService cache build fails.
+	// Resolve should gracefully fall back to base pricing without panicking.
+	repo := &mockChannelRepository{
+		listAllFn: func(_ context.Context) ([]Channel, error) {
+			return nil, errors.New("database unavailable")
+		},
+	}
+	cs := NewChannelService(repo, nil)
+	bs := newTestBillingServiceForResolver()
+	r := NewModelPricingResolver(cs, bs)
+
+	gid := int64(100)
+	resolved := r.Resolve(context.Background(), PricingInput{
+		Model:   "claude-sonnet-4",
+		GroupID: &gid,
+	})
+
+	require.NotNil(t, resolved)
+	// Should NOT panic, should NOT have source "channel"
+	require.NotEqual(t, "channel", resolved.Source)
+	// Base pricing should still be present (from BillingService fallback)
+	require.NotNil(t, resolved.BasePricing)
+	require.InDelta(t, 3e-6, resolved.BasePricing.InputPricePerToken, 1e-12)
+}
+
+// ===========================================================================
+// 7. GetRequestTierPriceByContext boundary tests
+// ===========================================================================
+
+func TestGetRequestTierPriceByContext_EmptyTiers(t *testing.T) {
+	bs := newTestBillingServiceForResolver()
+	r := NewModelPricingResolver(&ChannelService{}, bs)
+
+	resolved := &ResolvedPricing{
+		Mode:         BillingModePerRequest,
+		RequestTiers: nil, // empty
+	}
+
+	price := r.GetRequestTierPriceByContext(resolved, 50000)
+	require.InDelta(t, 0.0, price, 1e-12)
+
+	// Also test with explicit empty slice
+	resolved2 := &ResolvedPricing{
+		Mode:         BillingModePerRequest,
+		RequestTiers: []PricingInterval{},
+	}
+
+	price2 := r.GetRequestTierPriceByContext(resolved2, 50000)
+	require.InDelta(t, 0.0, price2, 1e-12)
+}
+
+func TestGetRequestTierPriceByContext_ExactBoundary(t *testing.T) {
+	bs := newTestBillingServiceForResolver()
+	r := NewModelPricingResolver(&ChannelService{}, bs)
+
+	resolved := &ResolvedPricing{
+		Mode: BillingModePerRequest,
+		RequestTiers: []PricingInterval{
+			{MinTokens: 0, MaxTokens: testPtrInt(128000), PerRequestPrice: testPtrFloat64(0.05)},
+			{MinTokens: 128000, MaxTokens: nil, PerRequestPrice: testPtrFloat64(0.10)},
+		},
+	}
+
+	// totalContextTokens = 128000 exactly:
+	// FindMatchingInterval checks: totalTokens > MinTokens && totalTokens <= MaxTokens
+	// For first interval: 128000 > 0 (true) && 128000 <= 128000 (true) → matches first interval
+	price := r.GetRequestTierPriceByContext(resolved, 128000)
+	require.InDelta(t, 0.05, price, 1e-12)
+
+	// totalContextTokens = 128001 should match second interval
+	// For first interval: 128001 > 0 (true) && 128001 <= 128000 (false) → no match
+	// For second interval: 128001 > 128000 (true) && MaxTokens == nil → matches
+	price2 := r.GetRequestTierPriceByContext(resolved, 128001)
+	require.InDelta(t, 0.10, price2, 1e-12)
+}

backend/internal/service/openai_gateway_service.go

@@ -4146,10 +4146,7 @@ type OpenAIRecordUsageInput struct {
 	IPAddress          string // 请求的客户端 IP 地址
 	RequestPayloadHash string
 	APIKeyService      APIKeyQuotaUpdater
-	ChannelID          int64
-	OriginalModel      string
-	BillingModelSource string
-	ModelMappingChain  string
+	ChannelUsageFields
 }
 
 // RecordUsage records usage and deducts balance

backend/internal/service/testhelpers_test.go

+//go:build unit
+
+package service
+
+// testPtrFloat64 returns a pointer to the given float64 value.
+func testPtrFloat64(v float64) *float64 { return &v }
+
+// testPtrInt returns a pointer to the given int value.
+func testPtrInt(v int) *int { return &v }
+
+// testPtrString returns a pointer to the given string value.
+func testPtrString(v string) *string { return &v }
+
+// testPtrBool returns a pointer to the given bool value.
+func testPtrBool(v bool) *bool { return &v }

frontend/src/api/admin/dashboard.ts

@@ -167,6 +167,13 @@ export interface UserBreakdownParams {
   endpoint?: string
   endpoint_type?: 'inbound' | 'upstream' | 'path'
   limit?: number
+  // Additional filter conditions
+  user_id?: number
+  api_key_id?: number
+  account_id?: number
+  request_type?: number
+  stream?: boolean
+  billing_type?: number | null
 }
 
 export interface UserBreakdownResponse {

frontend/src/components/admin/channel/types.ts

@@ -73,6 +73,45 @@ export function formIntervalsToAPI(intervals: IntervalFormEntry[]): PricingInter
   }))
 }
 
+// ── 模型模式冲突检测 ──────────────────────────────────────
+
+interface ModelPattern {
+  pattern: string
+  prefix: string  // lowercase, 通配符去掉尾部 *
+  wildcard: boolean
+}
+
+function toModelPattern(model: string): ModelPattern {
+  const lower = model.toLowerCase()
+  const wildcard = lower.endsWith('*')
+  return {
+    pattern: model,
+    prefix: wildcard ? lower.slice(0, -1) : lower,
+    wildcard,
+  }
+}
+
+function patternsConflict(a: ModelPattern, b: ModelPattern): boolean {
+  if (!a.wildcard && !b.wildcard) return a.prefix === b.prefix
+  if (a.wildcard && !b.wildcard) return b.prefix.startsWith(a.prefix)
+  if (!a.wildcard && b.wildcard) return a.prefix.startsWith(b.prefix)
+  // 双通配符：任一前缀是另一前缀的前缀即冲突
+  return a.prefix.startsWith(b.prefix) || b.prefix.startsWith(a.prefix)
+}
+
+/** 检测模型模式列表中的冲突，返回冲突的两个模式名；无冲突返回 null */
+export function findModelConflict(models: string[]): [string, string] | null {
+  const patterns = models.map(toModelPattern)
+  for (let i = 0; i < patterns.length; i++) {
+    for (let j = i + 1; j < patterns.length; j++) {
+      if (patternsConflict(patterns[i], patterns[j])) {
+        return [patterns[i].pattern, patterns[j].pattern]
+      }
+    }
+  }
+  return null
+}
+
 /** 平台对应的模型 tag 样式（背景+文字） */
 export function getPlatformTagClass(platform: string): string {
   switch (platform) {

frontend/src/components/charts/EndpointDistributionChart.vue

@@ -161,6 +161,7 @@ const props = withDefaults(
     showSourceToggle?: boolean
     startDate?: string
     endDate?: string
+    filters?: Record<string, any>
   }>(),
   {
     upstreamEndpointStats: () => [],
@@ -193,6 +194,7 @@ const toggleBreakdown = async (endpoint: string) => {
   breakdownItems.value = []
   try {
     const res = await getUserBreakdown({
+      ...props.filters,
       start_date: props.startDate,
       end_date: props.endDate,
       endpoint,

frontend/src/components/charts/GroupDistributionChart.vue

@@ -125,6 +125,7 @@ const props = withDefaults(defineProps<{
   showMetricToggle?: boolean
   startDate?: string
   endDate?: string
+  filters?: Record<string, any>
 }>(), {
   loading: false,
   metric: 'tokens',
@@ -150,6 +151,7 @@ const toggleBreakdown = async (type: string, id: number | string) => {
   breakdownItems.value = []
   try {
     const res = await getUserBreakdown({
+      ...props.filters,
       start_date: props.startDate,
       end_date: props.endDate,
       group_id: Number(id),

frontend/src/components/charts/ModelDistributionChart.vue

@@ -270,6 +270,7 @@ const props = withDefaults(defineProps<{
   rankingError?: boolean
   startDate?: string
   endDate?: string
+  filters?: Record<string, any>
 }>(), {
   upstreamModelStats: () => [],
   mappingModelStats: () => [],
@@ -302,6 +303,7 @@ const toggleBreakdown = async (type: string, id: string) => {
   breakdownItems.value = []
   try {
     const res = await getUserBreakdown({
+      ...props.filters,
       start_date: props.startDate,
       end_date: props.endDate,
       model: id,

frontend/src/i18n/locales/en.ts

@@ -1744,6 +1744,8 @@ export default {
       deleteError: 'Failed to delete channel',
       nameRequired: 'Please enter a channel name',
       duplicateModels: 'Model "{0}" appears in multiple pricing entries',
+      modelConflict: "Model patterns '{model1}' and '{model2}' conflict: overlapping match range",
+      mappingConflict: "Mapping source patterns '{model1}' and '{model2}' conflict: overlapping match range",
       deleteConfirm: 'Are you sure you want to delete channel "{name}"? This cannot be undone.',
       columns: {
         name: 'Name',

frontend/src/i18n/locales/zh.ts

@@ -1824,6 +1824,8 @@ export default {
       deleteError: '删除渠道失败',
       nameRequired: '请输入渠道名称',
       duplicateModels: '模型「{0}」在多个定价条目中重复',
+      modelConflict: "模型模式 '{model1}' 和 '{model2}' 冲突：匹配范围重叠",
+      mappingConflict: "模型映射源 '{model1}' 和 '{model2}' 冲突：匹配范围重叠",
       deleteConfirm: '确定要删除渠道「{name}」吗？此操作不可撤销。',
       columns: {
         name: '名称',

frontend/src/views/admin/ChannelsView.vue

@@ -418,7 +418,7 @@ import { useAppStore } from '@/stores/app'
 import { adminAPI } from '@/api/admin'
 import type { Channel, ChannelModelPricing, CreateChannelRequest, UpdateChannelRequest } from '@/api/admin/channels'
 import type { PricingFormEntry } from '@/components/admin/channel/types'
-import { mTokToPerToken, perTokenToMTok, apiIntervalsToForm, formIntervalsToAPI } from '@/components/admin/channel/types'
+import { mTokToPerToken, perTokenToMTok, apiIntervalsToForm, formIntervalsToAPI, findModelConflict } from '@/components/admin/channel/types'
 import type { AdminGroup, GroupPlatform } from '@/types'
 import type { Column } from '@/components/common/types'
 import AppLayout from '@/components/layout/AppLayout.vue'
@@ -875,19 +875,35 @@ async function handleSubmit() {
     }
   }
 
-  // Check duplicate models per platform (same model in different platforms is allowed)
+  // Check model pattern conflicts per platform (duplicate / wildcard overlap)
   for (const section of form.platforms.filter(s => s.enabled)) {
-    const seen = new Set()
+    // Collect all pricing models for this platform
+    const allModels: string[] = []
     for (const entry of section.model_pricing) {
-      for (const m of entry.models) {
-        const key = m.toLowerCase()
-        if (seen.has(key)) {
-          const platformLabel = t('admin.groups.platforms.' + section.platform, section.platform)
-          appStore.showError(t('admin.channels.duplicateModels', `${platformLabel} 平台下模型 "${m}" 在多个定价条目中重复`))
-          activeTab.value = section.platform
-          return
-        }
-        seen.add(key)
+      allModels.push(...entry.models)
+    }
+    const pricingConflict = findModelConflict(allModels)
+    if (pricingConflict) {
+      appStore.showError(
+        t('admin.channels.modelConflict',
+          { model1: pricingConflict[0], model2: pricingConflict[1] },
+          `模型模式 '${pricingConflict[0]}' 和 '${pricingConflict[1]}' 冲突：匹配范围重叠`)
+      )
+      activeTab.value = section.platform
+      return
+    }
+    // Check model mapping source pattern conflicts
+    const mappingKeys = Object.keys(section.model_mapping)
+    if (mappingKeys.length > 0) {
+      const mappingConflict = findModelConflict(mappingKeys)
+      if (mappingConflict) {
+        appStore.showError(
+          t('admin.channels.mappingConflict',
+            { model1: mappingConflict[0], model2: mappingConflict[1] },
+            `模型映射源 '${mappingConflict[0]}' 和 '${mappingConflict[1]}' 冲突：匹配范围重叠`)
+        )
+        activeTab.value = section.platform
+        return
       }
     }
   }

frontend/src/views/admin/UsageView.vue

@@ -34,6 +34,7 @@
             :show-metric-toggle="true"
             :start-date="startDate"
             :end-date="endDate"
+            :filters="breakdownFilters"
           />
           <GroupDistributionChart
             v-model:metric="groupDistributionMetric"
@@ -42,6 +43,7 @@
             :show-metric-toggle="true"
             :start-date="startDate"
             :end-date="endDate"
+            :filters="breakdownFilters"
           />
         </div>
         <div class="grid grid-cols-1 gap-6 lg:grid-cols-2">
@@ -57,6 +59,7 @@
             :title="t('usage.endpointDistribution')"
             :start-date="startDate"
             :end-date="endDate"
+            :filters="breakdownFilters"
           />
           <TokenUsageTrend :trend-data="trendData" :loading="chartsLoading" />
         </div>
@@ -169,6 +172,17 @@ const cleanupDialogVisible = ref(false)
 const showBalanceHistoryModal = ref(false)
 const balanceHistoryUser = ref<AdminUser | null>(null)
 
+const breakdownFilters = computed(() => {
+  const f: Record<string, any> = {}
+  if (filters.value.user_id) f.user_id = filters.value.user_id
+  if (filters.value.api_key_id) f.api_key_id = filters.value.api_key_id
+  if (filters.value.account_id) f.account_id = filters.value.account_id
+  if (filters.value.group_id) f.group_id = filters.value.group_id
+  if (filters.value.request_type != null) f.request_type = filters.value.request_type
+  if (filters.value.billing_type != null) f.billing_type = filters.value.billing_type
+  return f
+})
+
 const handleUserClick = async (userId: number) => {
   try {
     const user = await adminAPI.users.getById(userId)