feat(channel): 通配符定价匹配 + OpenAI BillingModelSource + 按次价格校验 + 用户端计费模式展示

- 定价查找支持通配符(suffix *)，最长前缀优先匹配
- 模型限制(restrict_models)同样支持通配符匹配
- OpenAI 网关接入渠道映射/BillingModelSource/模型限制
- 按次/图片计费模式创建时强制要求价格或层级(前后端)
- 用户使用记录列表增加计费模式 badge 列

backend/cmd/server/wire_gen.go

@@ -180,7 +180,7 @@ func initializeApplication(buildInfo handler.BuildInfo) (*Application, error) {
 	modelPricingResolver := service.NewModelPricingResolver(channelService, billingService)
 	gatewayService := service.NewGatewayService(accountRepository, groupRepository, usageLogRepository, usageBillingRepository, userRepository, userSubscriptionRepository, userGroupRateRepository, gatewayCache, configConfig, schedulerSnapshotService, concurrencyService, billingService, rateLimitService, billingCacheService, identityService, httpUpstream, deferredService, claudeTokenProvider, sessionLimitCache, rpmCache, digestSessionStore, settingService, tlsFingerprintProfileService, channelService, modelPricingResolver)
 	openAITokenProvider := service.ProvideOpenAITokenProvider(accountRepository, geminiTokenCache, openAIOAuthService, oauthRefreshAPI)
-	openAIGatewayService := service.NewOpenAIGatewayService(accountRepository, usageLogRepository, usageBillingRepository, userRepository, userSubscriptionRepository, userGroupRateRepository, gatewayCache, configConfig, schedulerSnapshotService, concurrencyService, billingService, rateLimitService, billingCacheService, httpUpstream, deferredService, openAITokenProvider, modelPricingResolver)
+	openAIGatewayService := service.NewOpenAIGatewayService(accountRepository, usageLogRepository, usageBillingRepository, userRepository, userSubscriptionRepository, userGroupRateRepository, gatewayCache, configConfig, schedulerSnapshotService, concurrencyService, billingService, rateLimitService, billingCacheService, httpUpstream, deferredService, openAITokenProvider, modelPricingResolver, channelService)
 	geminiMessagesCompatService := service.NewGeminiMessagesCompatService(accountRepository, groupRepository, gatewayCache, schedulerSnapshotService, geminiTokenProvider, rateLimitService, httpUpstream, antigravityGatewayService, configConfig)
 	opsSystemLogSink := service.ProvideOpsSystemLogSink(opsRepository)
 	opsService := service.NewOpsService(opsRepository, settingRepository, configConfig, accountRepository, userRepository, concurrencyService, gatewayService, openAIGatewayService, geminiMessagesCompatService, antigravityGatewayService, opsSystemLogSink)

backend/internal/handler/admin/channel_handler.go

@@ -276,11 +276,21 @@ func (h *ChannelHandler) Create(c *gin.Context) {
 		return
 	}
 
+	pricing := pricingRequestToService(req.ModelPricing)
+	for _, p := range pricing {
+		if p.BillingMode == service.BillingModePerRequest || p.BillingMode == service.BillingModeImage {
+			if p.PerRequestPrice == nil && len(p.Intervals) == 0 {
+				response.BadRequest(c, "Per-request price or intervals required for per_request/image billing mode")
+				return
+			}
+		}
+	}
+
 	channel, err := h.channelService.Create(c.Request.Context(), &service.CreateChannelInput{
 		Name:               req.Name,
 		Description:        req.Description,
 		GroupIDs:            req.GroupIDs,
-		ModelPricing:        pricingRequestToService(req.ModelPricing),
+		ModelPricing:        pricing,
 		ModelMapping:        req.ModelMapping,
 		BillingModelSource: req.BillingModelSource,
 		RestrictModels:     req.RestrictModels,
@@ -319,6 +329,14 @@ func (h *ChannelHandler) Update(c *gin.Context) {
 	}
 	if req.ModelPricing != nil {
 		pricing := pricingRequestToService(*req.ModelPricing)
+		for _, p := range pricing {
+			if p.BillingMode == service.BillingModePerRequest || p.BillingMode == service.BillingModeImage {
+				if p.PerRequestPrice == nil && len(p.Intervals) == 0 {
+					response.BadRequest(c, "Per-request price or intervals required for per_request/image billing mode")
+					return
+				}
+			}
+		}
 		input.ModelPricing = &pricing
 	}
 

backend/internal/handler/openai_gateway_handler.go

@@ -185,6 +185,20 @@ func (h *OpenAIGatewayHandler) Responses(c *gin.Context) {
 	setOpsRequestContext(c, reqModel, reqStream, body)
 	setOpsEndpointContext(c, "", int16(service.RequestTypeFromLegacy(reqStream, false)))
 
+	// 解析渠道级模型映射
+	var channelMapping service.ChannelMappingResult
+	if apiKey.GroupID != nil {
+		channelMapping = h.gatewayService.ResolveChannelMapping(c.Request.Context(), *apiKey.GroupID, reqModel)
+	}
+
+	// 渠道模型限制检查
+	if apiKey.GroupID != nil {
+		if h.gatewayService.IsModelRestricted(c.Request.Context(), *apiKey.GroupID, reqModel) {
+			h.errorResponse(c, http.StatusServiceUnavailable, "api_error", "No available accounts")
+			return
+		}
+	}
+
 	// 提前校验 function_call_output 是否具备可关联上下文，避免上游 400。
 	if !h.validateFunctionCallOutputRequest(c, body, reqLog) {
 		return
@@ -379,6 +393,21 @@ func (h *OpenAIGatewayHandler) Responses(c *gin.Context) {
 				IPAddress:          clientIP,
 				RequestPayloadHash: requestPayloadHash,
 				APIKeyService:      h.apiKeyService,
+				ChannelID:          channelMapping.ChannelID,
+				OriginalModel:      reqModel,
+				BillingModelSource: channelMapping.BillingModelSource,
+				ModelMappingChain: func() string {
+					if !channelMapping.Mapped {
+						if result.UpstreamModel != "" && result.UpstreamModel != result.Model {
+							return reqModel + "→" + result.UpstreamModel
+						}
+						return ""
+					}
+					if result.UpstreamModel != "" && result.UpstreamModel != channelMapping.MappedModel {
+						return reqModel + "→" + channelMapping.MappedModel + "→" + result.UpstreamModel
+					}
+					return reqModel + "→" + channelMapping.MappedModel
+				}(),
 			}); err != nil {
 				logger.L().With(
 					zap.String("component", "handler.openai_gateway.responses"),
@@ -549,6 +578,20 @@ func (h *OpenAIGatewayHandler) Messages(c *gin.Context) {
 	setOpsRequestContext(c, reqModel, reqStream, body)
 	setOpsEndpointContext(c, "", int16(service.RequestTypeFromLegacy(reqStream, false)))
 
+	// 解析渠道级模型映射
+	var channelMappingMsg service.ChannelMappingResult
+	if apiKey.GroupID != nil {
+		channelMappingMsg = h.gatewayService.ResolveChannelMapping(c.Request.Context(), *apiKey.GroupID, reqModel)
+	}
+
+	// 渠道模型限制检查
+	if apiKey.GroupID != nil {
+		if h.gatewayService.IsModelRestricted(c.Request.Context(), *apiKey.GroupID, reqModel) {
+			h.anthropicErrorResponse(c, http.StatusServiceUnavailable, "api_error", "No available accounts")
+			return
+		}
+	}
+
 	// 绑定错误透传服务，允许 service 层在非 failover 错误场景复用规则。
 	if h.errorPassthroughService != nil {
 		service.BindErrorPassthroughService(c, h.errorPassthroughService)
@@ -759,6 +802,21 @@ func (h *OpenAIGatewayHandler) Messages(c *gin.Context) {
 				IPAddress:          clientIP,
 				RequestPayloadHash: requestPayloadHash,
 				APIKeyService:      h.apiKeyService,
+				ChannelID:          channelMappingMsg.ChannelID,
+				OriginalModel:      reqModel,
+				BillingModelSource: channelMappingMsg.BillingModelSource,
+				ModelMappingChain: func() string {
+					if !channelMappingMsg.Mapped {
+						if result.UpstreamModel != "" && result.UpstreamModel != result.Model {
+							return reqModel + "→" + result.UpstreamModel
+						}
+						return ""
+					}
+					if result.UpstreamModel != "" && result.UpstreamModel != channelMappingMsg.MappedModel {
+						return reqModel + "→" + channelMappingMsg.MappedModel + "→" + result.UpstreamModel
+					}
+					return reqModel + "→" + channelMappingMsg.MappedModel
+				}(),
 			}); err != nil {
 				logger.L().With(
 					zap.String("component", "handler.openai_gateway.messages"),
@@ -1101,6 +1159,20 @@ func (h *OpenAIGatewayHandler) ResponsesWebSocket(c *gin.Context) {
 	setOpsRequestContext(c, reqModel, true, firstMessage)
 	setOpsEndpointContext(c, "", int16(service.RequestTypeWSV2))
 
+	// 解析渠道级模型映射
+	var channelMappingWS service.ChannelMappingResult
+	if apiKey.GroupID != nil {
+		channelMappingWS = h.gatewayService.ResolveChannelMapping(ctx, *apiKey.GroupID, reqModel)
+	}
+
+	// 渠道模型限制检查
+	if apiKey.GroupID != nil {
+		if h.gatewayService.IsModelRestricted(ctx, *apiKey.GroupID, reqModel) {
+			closeOpenAIClientWS(wsConn, coderws.StatusPolicyViolation, "model not allowed")
+			return
+		}
+	}
+
 	var currentUserRelease func()
 	var currentAccountRelease func()
 	releaseTurnSlots := func() {
@@ -1259,6 +1331,21 @@ func (h *OpenAIGatewayHandler) ResponsesWebSocket(c *gin.Context) {
 					IPAddress:          clientIP,
 					RequestPayloadHash: service.HashUsageRequestPayload(firstMessage),
 					APIKeyService:      h.apiKeyService,
+					ChannelID:          channelMappingWS.ChannelID,
+					OriginalModel:      reqModel,
+					BillingModelSource: channelMappingWS.BillingModelSource,
+					ModelMappingChain: func() string {
+						if !channelMappingWS.Mapped {
+							if result.UpstreamModel != "" && result.UpstreamModel != result.Model {
+								return reqModel + "→" + result.UpstreamModel
+							}
+							return ""
+						}
+						if result.UpstreamModel != "" && result.UpstreamModel != channelMappingWS.MappedModel {
+							return reqModel + "→" + channelMappingWS.MappedModel + "→" + result.UpstreamModel
+						}
+						return reqModel + "→" + channelMappingWS.MappedModel
+					}(),
 				}); err != nil {
 					reqLog.Error("openai.websocket_record_usage_failed",
 						zap.Int64("account_id", account.ID),

backend/internal/service/channel_service.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
+	"sort"
 	"strings"
 	"sync/atomic"
 	"time"
@@ -57,10 +58,23 @@ type channelModelKey struct {
 	model    string // lowercase
 }
 
+// channelGroupPlatformKey 通配符定价缓存键
+type channelGroupPlatformKey struct {
+	groupID  int64
+	platform string
+}
+
+// wildcardPricingEntry 通配符定价条目
+type wildcardPricingEntry struct {
+	prefix  string
+	pricing *ChannelModelPricing
+}
+
 // channelCache 渠道缓存快照（扁平化哈希结构，热路径 O(1) 查找）
 type channelCache struct {
 	// 热路径查找
 	pricingByGroupModel    map[channelModelKey]*ChannelModelPricing // (groupID, platform, model) → 定价
+	wildcardByGroupPlatform map[channelGroupPlatformKey][]*wildcardPricingEntry // (groupID, platform) → 通配符定价（前缀长度降序）
 	mappingByGroupModel    map[channelModelKey]string                // (groupID, platform, model) → 映射目标
 	channelByGroupID       map[int64]*Channel                        // groupID → 渠道
 	groupPlatform          map[int64]string                          // groupID → platform
@@ -138,6 +152,7 @@ func (s *ChannelService) buildCache(ctx context.Context) (*channelCache, error)
 		slog.Warn("failed to build channel cache", "error", err)
 		errorCache := &channelCache{
 			pricingByGroupModel:    make(map[channelModelKey]*ChannelModelPricing),
+			wildcardByGroupPlatform: make(map[channelGroupPlatformKey][]*wildcardPricingEntry),
 			mappingByGroupModel:    make(map[channelModelKey]string),
 			channelByGroupID:       make(map[int64]*Channel),
 			groupPlatform:          make(map[int64]string),
@@ -164,6 +179,7 @@ func (s *ChannelService) buildCache(ctx context.Context) (*channelCache, error)
 
 	cache := &channelCache{
 		pricingByGroupModel:    make(map[channelModelKey]*ChannelModelPricing),
+		wildcardByGroupPlatform: make(map[channelGroupPlatformKey][]*wildcardPricingEntry),
 		mappingByGroupModel:    make(map[channelModelKey]string),
 		channelByGroupID:       make(map[int64]*Channel),
 		groupPlatform:          groupPlatforms,
@@ -187,10 +203,20 @@ func (s *ChannelService) buildCache(ctx context.Context) (*channelCache, error)
 					continue // 跳过非本平台的定价
 				}
 				for _, model := range pricing.Models {
+					if strings.HasSuffix(model, "*") {
+						// 通配符模型 → 存入 wildcardByGroupPlatform
+						prefix := strings.ToLower(strings.TrimSuffix(model, "*"))
+						gpKey := channelGroupPlatformKey{groupID: gid, platform: platform}
+						cache.wildcardByGroupPlatform[gpKey] = append(cache.wildcardByGroupPlatform[gpKey], &wildcardPricingEntry{
+							prefix:  prefix,
+							pricing: pricing,
+						})
+					} else {
 						key := channelModelKey{groupID: gid, platform: platform, model: strings.ToLower(model)}
 						cache.pricingByGroupModel[key] = pricing
 					}
 				}
+			}
 
 			// 只展开该平台的模型映射到 (groupID, platform, model) → target
 			if platformMapping, ok := ch.ModelMapping[platform]; ok {
@@ -202,6 +228,14 @@ func (s *ChannelService) buildCache(ctx context.Context) (*channelCache, error)
 		}
 	}
 
+	// 通配符条目按前缀长度降序排列（最长前缀优先匹配）
+	for gpKey, entries := range cache.wildcardByGroupPlatform {
+		sort.Slice(entries, func(i, j int) bool {
+			return len(entries[i].prefix) > len(entries[j].prefix)
+		})
+		cache.wildcardByGroupPlatform[gpKey] = entries
+	}
+
 	s.cache.Store(cache)
 	return cache, nil
 }
@@ -212,6 +246,18 @@ func (s *ChannelService) invalidateCache() {
 	s.cacheSF.Forget("channel_cache")
 }
 
+// matchWildcard 在通配符定价中查找匹配项（最长前缀优先）
+func (c *channelCache) matchWildcard(groupID int64, platform, modelLower string) *ChannelModelPricing {
+	gpKey := channelGroupPlatformKey{groupID: groupID, platform: platform}
+	wildcards := c.wildcardByGroupPlatform[gpKey]
+	for _, wc := range wildcards {
+		if strings.HasPrefix(modelLower, wc.prefix) {
+			return wc.pricing
+		}
+	}
+	return nil
+}
+
 // GetChannelForGroup 获取分组关联的渠道（热路径 O(1)）
 func (s *ChannelService) GetChannelForGroup(ctx context.Context, groupID int64) (*Channel, error) {
 	cache, err := s.loadCache(ctx)
@@ -245,8 +291,12 @@ func (s *ChannelService) GetChannelModelPricing(ctx context.Context, groupID int
 	key := channelModelKey{groupID: groupID, platform: platform, model: strings.ToLower(model)}
 	pricing, ok := cache.pricingByGroupModel[key]
 	if !ok {
+		// 精确查找失败，尝试通配符匹配
+		pricing = cache.matchWildcard(groupID, platform, strings.ToLower(model))
+		if pricing == nil {
 			return nil
 		}
+	}
 
 	cp := pricing.Clone()
 	return &cp
@@ -302,7 +352,14 @@ func (s *ChannelService) IsModelRestricted(ctx context.Context, groupID int64, m
 	platform := cache.groupPlatform[groupID]
 	key := channelModelKey{groupID: groupID, platform: platform, model: strings.ToLower(model)}
 	_, exists := cache.pricingByGroupModel[key]
-	return !exists
+	if exists {
+		return false
+	}
+	// 精确查找失败，尝试通配符匹配
+	if cache.matchWildcard(groupID, platform, strings.ToLower(model)) != nil {
+		return false
+	}
+	return true
 }
 
 // --- CRUD ---

backend/internal/service/openai_gateway_record_usage_test.go

@@ -146,6 +146,7 @@ func newOpenAIRecordUsageServiceForTest(usageRepo UsageLogRepository, userRepo U
 		&DeferredService{},
 		nil,
 		nil,
+		nil,
 	)
 	svc.userGroupRateResolver = newUserGroupRateResolver(
 		rateRepo,

backend/internal/service/openai_gateway_service.go

@@ -323,6 +323,7 @@ type OpenAIGatewayService struct {
 	toolCorrector         *CodexToolCorrector
 	openaiWSResolver      OpenAIWSProtocolResolver
 	resolver              *ModelPricingResolver
+	channelService        *ChannelService
 
 	openaiWSPoolOnce              sync.Once
 	openaiWSStateStoreOnce        sync.Once
@@ -359,6 +360,7 @@ func NewOpenAIGatewayService(
 	deferredService *DeferredService,
 	openAITokenProvider *OpenAITokenProvider,
 	resolver *ModelPricingResolver,
+	channelService *ChannelService,
 ) *OpenAIGatewayService {
 	svc := &OpenAIGatewayService{
 		accountRepo:         accountRepo,
@@ -387,6 +389,7 @@ func NewOpenAIGatewayService(
 		toolCorrector:         NewCodexToolCorrector(),
 		openaiWSResolver:      NewOpenAIWSProtocolResolver(cfg),
 		resolver:              resolver,
+		channelService:        channelService,
 		responseHeaderFilter:  compileResponseHeaderFilter(cfg),
 		codexSnapshotThrottle: newAccountWriteThrottle(openAICodexSnapshotPersistMinInterval),
 	}
@@ -394,6 +397,22 @@ func NewOpenAIGatewayService(
 	return svc
 }
 
+// ResolveChannelMapping 解析渠道级模型映射（代理到 ChannelService）
+func (s *OpenAIGatewayService) ResolveChannelMapping(ctx context.Context, groupID int64, model string) ChannelMappingResult {
+	if s.channelService == nil {
+		return ChannelMappingResult{MappedModel: model}
+	}
+	return s.channelService.ResolveChannelMapping(ctx, groupID, model)
+}
+
+// IsModelRestricted 检查模型是否被渠道限制（代理到 ChannelService）
+func (s *OpenAIGatewayService) IsModelRestricted(ctx context.Context, groupID int64, model string) bool {
+	if s.channelService == nil {
+		return false
+	}
+	return s.channelService.IsModelRestricted(ctx, groupID, model)
+}
+
 func (s *OpenAIGatewayService) getCodexSnapshotThrottle() *accountWriteThrottle {
 	if s != nil && s.codexSnapshotThrottle != nil {
 		return s.codexSnapshotThrottle
@@ -4113,6 +4132,10 @@ type OpenAIRecordUsageInput struct {
 	IPAddress          string // 请求的客户端 IP 地址
 	RequestPayloadHash string
 	APIKeyService      APIKeyQuotaUpdater
+	ChannelID          int64
+	OriginalModel      string
+	BillingModelSource string
+	ModelMappingChain  string
 }
 
 // RecordUsage records usage and deducts balance
@@ -4158,6 +4181,12 @@ func (s *OpenAIGatewayService) RecordUsage(ctx context.Context, input *OpenAIRec
 	var cost *CostBreakdown
 	var err error
 	billingModel := forwardResultBillingModel(result.Model, result.UpstreamModel)
+	if result.BillingModel != "" {
+		billingModel = strings.TrimSpace(result.BillingModel)
+	}
+	if input.BillingModelSource == "requested" && input.OriginalModel != "" {
+		billingModel = input.OriginalModel
+	}
 	serviceTier := ""
 	if result.ServiceTier != nil {
 		serviceTier = strings.TrimSpace(*result.ServiceTier)
@@ -4223,6 +4252,9 @@ func (s *OpenAIGatewayService) RecordUsage(ctx context.Context, input *OpenAIRec
 		FirstTokenMs:          result.FirstTokenMs,
 		CreatedAt:             time.Now(),
 	}
+	// 设置渠道信息
+	usageLog.ChannelID = optionalInt64Ptr(input.ChannelID)
+	usageLog.ModelMappingChain = optionalTrimmedStringPtr(input.ModelMappingChain)
 	// 设置计费模式
 	if cost != nil && cost.BillingMode != "" {
 		billingMode := cost.BillingMode

backend/internal/service/openai_ws_protocol_forward_test.go

@@ -616,6 +616,7 @@ func TestNewOpenAIGatewayService_InitializesOpenAIWSResolver(t *testing.T) {
 		nil,
 		nil,
 		nil,
+		nil,
 	)
 
 	decision := svc.getOpenAIWSProtocolResolver().Resolve(nil)

frontend/src/i18n/locales/en.ts

@@ -1789,6 +1789,7 @@ export default {
         noTiersYet: 'No tiers yet. Click add to configure per-request pricing.',
         noPricingRules: 'No pricing rules yet. Click "Add" to create one.',
         perRequestPrice: 'Price per Request',
+        perRequestPriceRequired: 'Per-request price or billing tiers required for per-request/image billing mode',
         tierLabel: 'Tier',
         resolution: 'Resolution',
         modelMapping: 'Model Mapping',

frontend/src/i18n/locales/zh.ts

@@ -1869,6 +1869,7 @@ export default {
         noTiersYet: '暂无层级，点击添加配置按次计费价格',
         noPricingRules: '暂无定价规则，点击"添加"创建',
         perRequestPrice: '单次价格',
+        perRequestPriceRequired: '按次/图片计费模式必须设置默认价格或至少一个计费层级',
         tierLabel: '层级',
         resolution: '分辨率',
         modelMapping: '模型映射',

frontend/src/views/admin/ChannelsView.vue

@@ -876,6 +876,19 @@ async function handleSubmit() {
     return
   }
 
+  // 校验 per_request/image 模式必须有价格
+  for (const section of form.platforms) {
+    for (const entry of section.model_pricing) {
+      if (entry.models.length === 0) continue
+      if ((entry.billing_mode === 'per_request' || entry.billing_mode === 'image') &&
+          (entry.per_request_price == null || entry.per_request_price === '') &&
+          (!entry.intervals || entry.intervals.length === 0)) {
+        appStore.showError(t('admin.channels.perRequestPriceRequired', '按次/图片计费模式必须设置默认价格或至少一个计费层级'))
+        return
+      }
+    }
+  }
+
   const { group_ids, model_pricing, model_mapping } = formToAPI()
   console.log('[handleSubmit] model_pricing to send:', JSON.stringify(model_pricing))
 

frontend/src/views/user/UsageView.vue

@@ -181,6 +181,13 @@
             </span>
           </template>
 
+          <template #cell-billing_mode="{ row }">
+            <span class="inline-flex items-center rounded px-1.5 py-0.5 text-xs font-medium"
+                  :class="getBillingModeBadgeClass(row.billing_mode)">
+              {{ getBillingModeLabel(row.billing_mode) }}
+            </span>
+          </template>
+
           <template #cell-tokens="{ row }">
             <!-- 图片生成请求 -->
             <div v-if="row.image_count > 0" class="flex items-center gap-1.5">
@@ -525,6 +532,7 @@ const columns = computed<Column[]>(() => [
   { key: 'reasoning_effort', label: t('usage.reasoningEffort'), sortable: false },
   { key: 'endpoint', label: t('usage.endpoint'), sortable: false },
   { key: 'stream', label: t('usage.type'), sortable: false },
+  { key: 'billing_mode', label: t('admin.usage.billingMode'), sortable: false },
   { key: 'tokens', label: t('usage.tokens'), sortable: false },
   { key: 'cost', label: t('usage.cost'), sortable: false },
   { key: 'first_token', label: t('usage.firstToken'), sortable: false },
@@ -615,6 +623,18 @@ const getRequestTypeBadgeClass = (log: UsageLog): string => {
   return 'bg-amber-100 text-amber-800 dark:bg-amber-900 dark:text-amber-200'
 }
 
+const getBillingModeLabel = (mode: string | null | undefined): string => {
+  if (mode === 'per_request') return t('admin.usage.billingModePerRequest')
+  if (mode === 'image') return t('admin.usage.billingModeImage')
+  return t('admin.usage.billingModeToken')
+}
+
+const getBillingModeBadgeClass = (mode: string | null | undefined): string => {
+  if (mode === 'per_request') return 'bg-blue-100 text-blue-800 dark:bg-blue-900/30 dark:text-blue-200'
+  if (mode === 'image') return 'bg-green-100 text-green-800 dark:bg-green-900/30 dark:text-green-200'
+  return 'bg-gray-100 text-gray-800 dark:bg-gray-700 dark:text-gray-300'
+}
+
 const getRequestTypeExportText = (log: UsageLog): string => {
   const requestType = resolveUsageRequestType(log)
   if (requestType === 'ws_v2') return 'WS'
@@ -804,6 +824,7 @@ const exportToCSV = async () => {
       'Reasoning Effort',
       'Inbound Endpoint',
       'Type',
+      'Billing Mode',
       'Input Tokens',
       'Output Tokens',
       'Cache Read Tokens',
@@ -822,6 +843,7 @@ const exportToCSV = async () => {
         formatReasoningEffort(log.reasoning_effort),
         log.inbound_endpoint || '',
         getRequestTypeExportText(log),
+        getBillingModeLabel(log.billing_mode),
         log.input_tokens,
         log.output_tokens,
         log.cache_read_tokens,