anpin.ai のご支援に感謝します！anpin.ai は AI の普及推進に取り組むハイエンド AI 中継サービスプラットフォームです。先進的な技術アーキテクチャとグローバル分散デプロイメントにより、国際トップクラスの大規模モデルへの高速直通ルートを提供します。 IDs still get their
+// turn; before the fix the same lowest IDs monopolized every cycle.
+func TestListDueUpstreamBillingProbeAccountsSelectsEarliestDueAcrossIDs(t *testing.T) {
+ ctx := context.Background()
+ tx := testEntTx(t)
+ repo := newAccountRepositoryWithSQL(tx.Client(), tx, nil)
+ now := time.Date(2026, time.July, 25, 17, 30, 0, 0, time.UTC)
+ _, err := tx.ExecContext(ctx, `
+ UPDATE accounts
+ SET extra = extra - 'upstream_billing_probe_enabled' - 'upstream_billing_probe'
+ `)
+ require.NoError(t, err)
+
+ // 25 due accounts; the LOWEST IDs carry the LATEST due times, so a
+ // correct query must pick the 20 highest-ID rows here.
+ ids := make([]int64, 0, 25)
+ for i := 0; i < 25; i++ {
+ due := now.Add(-time.Duration(i+1) * time.Minute)
+ ids = append(ids, insertUpstreamBillingProbeAccount(ctx, t, tx,
+ fmt.Sprintf("probe-nano-order-%02d", i),
+ rfc3339WithFraction(due, "123456789")))
+ }
+
+ accounts, err := repo.ListDueUpstreamBillingProbeAccounts(ctx, now, 20)
+ require.NoError(t, err)
+ require.Len(t, accounts, 20)
+ got := make([]int64, 0, len(accounts))
+ for _, account := range accounts {
+ got = append(got, account.ID)
+ }
+ // Earliest due first == highest index first; the five most recently due
+ // (lowest index / lowest IDs) fall outside the limit this cycle.
+ want := make([]int64, 0, 20)
+ for i := 24; i >= 5; i-- {
+ want = append(want, ids[i])
+ }
+ require.Equal(t, want, got)
+}
diff --git a/backend/internal/repository/account_repo_upstream_billing_probe_due_test.go b/backend/internal/repository/account_repo_upstream_billing_probe_due_test.go
index 350b95d4a..aa1fcb430 100644
--- a/backend/internal/repository/account_repo_upstream_billing_probe_due_test.go
+++ b/backend/internal/repository/account_repo_upstream_billing_probe_due_test.go
@@ -32,6 +32,7 @@ func TestAccountRepositoryListDueUpstreamBillingProbeAccountsBoundsQuery(t *test
require.Contains(t, normalized, "type = 'apikey'")
require.Contains(t, normalized, `extra @> '{"upstream_billing_probe_enabled": true}'::jsonb`)
require.Contains(t, normalized, "jsonb_path_query_first_tz")
+ require.Contains(t, normalized, `'(\.[0-9]{6})[0-9]+(Z|[+-][0-9]{2}:[0-9]{2})$'`)
require.Contains(t, normalized, "parsed AS MATERIALIZED")
require.Contains(t, normalized, "parsed_next_probe_at::timestamptz <= $1")
require.Contains(t, normalized, "LIMIT $2")
diff --git a/backend/internal/repository/usage_log_repo_breakdown_test.go b/backend/internal/repository/usage_log_repo_breakdown_test.go
index 1fb99b0d6..69f50bbad 100644
--- a/backend/internal/repository/usage_log_repo_breakdown_test.go
+++ b/backend/internal/repository/usage_log_repo_breakdown_test.go
@@ -40,8 +40,8 @@ func TestResolveModelDimensionExpression(t *testing.T) {
want string
}{
{usagestats.ModelSourceRequested, "COALESCE(NULLIF(TRIM(requested_model), ''), model)"},
- {usagestats.ModelSourceUpstream, "COALESCE(NULLIF(TRIM(upstream_model), ''), COALESCE(NULLIF(TRIM(requested_model), ''), model))"},
- {usagestats.ModelSourceMapping, "(COALESCE(NULLIF(TRIM(requested_model), ''), model) || ' -> ' || COALESCE(NULLIF(TRIM(upstream_model), ''), COALESCE(NULLIF(TRIM(requested_model), ''), model)))"},
+ {usagestats.ModelSourceUpstream, "COALESCE(NULLIF(TRIM(upstream_model), ''), model)"},
+ {usagestats.ModelSourceMapping, "(COALESCE(NULLIF(TRIM(requested_model), ''), model) || ' -> ' || COALESCE(NULLIF(TRIM(upstream_model), ''), model))"},
{"", "COALESCE(NULLIF(TRIM(requested_model), ''), model)"},
{"invalid", "COALESCE(NULLIF(TRIM(requested_model), ''), model)"},
}
diff --git a/backend/internal/repository/usage_log_repo_query.go b/backend/internal/repository/usage_log_repo_query.go
index 88b7eeaf3..084b79ad9 100644
--- a/backend/internal/repository/usage_log_repo_query.go
+++ b/backend/internal/repository/usage_log_repo_query.go
@@ -116,6 +116,10 @@ func (r *usageLogRepository) ListWithFilters(ctx context.Context, params paginat
conditions = append(conditions, fmt.Sprintf("group_id = $%d", len(args)+1))
args = append(args, filters.GroupID)
}
+ if requestID := strings.TrimSpace(filters.RequestID); requestID != "" {
+ conditions = append(conditions, fmt.Sprintf("request_id = $%d", len(args)+1))
+ args = append(args, requestID)
+ }
conditions, args = appendUsageLogModelWhereCondition(conditions, args, filters.Model, filters.ModelFilterSource)
conditions, args = appendRequestTypeOrStreamWhereCondition(conditions, args, filters.RequestType, filters.Stream)
if filters.BillingType != nil {
diff --git a/backend/internal/repository/usage_log_repo_request_type_test.go b/backend/internal/repository/usage_log_repo_request_type_test.go
index aff472b0c..9c59b38e5 100644
--- a/backend/internal/repository/usage_log_repo_request_type_test.go
+++ b/backend/internal/repository/usage_log_repo_request_type_test.go
@@ -374,6 +374,23 @@ func TestUsageLogRepositoryListWithFiltersRequestTypePriority(t *testing.T) {
require.NoError(t, mock.ExpectationsWereMet())
}
+func TestUsageLogRepositoryListWithFiltersRequestID(t *testing.T) {
+ db, mock := newSQLMock(t)
+ repo := &usageLogRepository{sql: db}
+
+ filters := usagestats.UsageLogFilters{RequestID: " req-0123 "}
+
+ mock.ExpectQuery("SELECT .* FROM usage_logs WHERE request_id = \\$1 ORDER BY id DESC LIMIT \\$2 OFFSET \\$3").
+ WithArgs("req-0123", 21, 0).
+ WillReturnRows(sqlmock.NewRows([]string{"id"}))
+
+ logs, page, err := repo.ListWithFilters(context.Background(), pagination.PaginationParams{Page: 1, PageSize: 20}, filters)
+ require.NoError(t, err)
+ require.Empty(t, logs)
+ require.NotNil(t, page)
+ require.NoError(t, mock.ExpectationsWereMet())
+}
+
func TestUsageLogRepositoryListWithFiltersRequestedModelSource(t *testing.T) {
db, mock := newSQLMock(t)
repo := &usageLogRepository{sql: db}
diff --git a/backend/internal/repository/usage_log_repo_trend.go b/backend/internal/repository/usage_log_repo_trend.go
index f2e0045ff..ae431c706 100644
--- a/backend/internal/repository/usage_log_repo_trend.go
+++ b/backend/internal/repository/usage_log_repo_trend.go
@@ -750,11 +750,12 @@ func resolveModelDimensionExpressionWithAlias(modelType, alias string) string {
return alias + "." + name
}
requestedExpr := fmt.Sprintf("COALESCE(NULLIF(TRIM(%s), ''), %s)", column("requested_model"), column("model"))
+ upstreamExpr := fmt.Sprintf("COALESCE(NULLIF(TRIM(%s), ''), %s)", column("upstream_model"), column("model"))
switch usagestats.NormalizeModelSource(modelType) {
case usagestats.ModelSourceUpstream:
- return fmt.Sprintf("COALESCE(NULLIF(TRIM(%s), ''), %s)", column("upstream_model"), requestedExpr)
+ return upstreamExpr
case usagestats.ModelSourceMapping:
- return fmt.Sprintf("(%s || ' -> ' || COALESCE(NULLIF(TRIM(%s), ''), %s))", requestedExpr, column("upstream_model"), requestedExpr)
+ return fmt.Sprintf("(%s || ' -> ' || %s)", requestedExpr, upstreamExpr)
default:
return requestedExpr
}
diff --git a/backend/internal/securityaudit/prompt_config.go b/backend/internal/securityaudit/prompt_config.go
index 3ad690d4d..e7238b517 100644
--- a/backend/internal/securityaudit/prompt_config.go
+++ b/backend/internal/securityaudit/prompt_config.go
@@ -44,7 +44,7 @@ type ConfigStore interface {
// It must stay false when blocking is not intended, even if config is
// untrusted—otherwise default-off deployments fail closed for all traffic.
BlockingActivationDegraded() bool
- Public() PublicConfig
+ Public() (PublicConfig, error)
Save(ctx context.Context, req UpdateConfigRequest, actorID int64) (PublicConfig, error)
RuntimeState() (expected int64, active int64, loadedAt *time.Time, loadError string)
Encrypt(value string) (string, error)
diff --git a/backend/internal/securityaudit/prompt_config_store.go b/backend/internal/securityaudit/prompt_config_store.go
index 7bc70f4c0..70d17da94 100644
--- a/backend/internal/securityaudit/prompt_config_store.go
+++ b/backend/internal/securityaudit/prompt_config_store.go
@@ -194,15 +194,15 @@ func (m *ConfigManager) markUntrustedIfNoActiveSnapshot() {
}
}
-func (m *ConfigManager) Public() PublicConfig {
+func (m *ConfigManager) Public() (PublicConfig, error) {
if m == nil {
- return PublicFromStorage(DefaultStorageConfig(), false)
+ return PublicConfig{}, infraerrors.ServiceUnavailable(ErrorCodeConfigUnavailable, "提示词审计配置暂不可用")
}
snapshot := m.snapshot.Load()
if snapshot == nil {
- return PublicFromStorage(DefaultStorageConfig(), false)
+ return PublicConfig{}, infraerrors.ServiceUnavailable(ErrorCodeConfigUnavailable, "提示词审计配置暂不可用")
}
- return PublicFromStorage(cloneStorageConfig(snapshot.storage), snapshot.active.RiskControlEnabled)
+ return PublicFromStorage(cloneStorageConfig(snapshot.storage), snapshot.active.RiskControlEnabled), nil
}
func (m *ConfigManager) Save(ctx context.Context, req UpdateConfigRequest, actorID int64) (PublicConfig, error) {
diff --git a/backend/internal/securityaudit/prompt_config_test.go b/backend/internal/securityaudit/prompt_config_test.go
index 22ea50a35..b71fca1d5 100644
--- a/backend/internal/securityaudit/prompt_config_test.go
+++ b/backend/internal/securityaudit/prompt_config_test.go
@@ -56,6 +56,57 @@ func TestConfigRuntimeLoadErrorIsStableBoundedAndSecretFree(t *testing.T) {
require.LessOrEqual(t, len([]rune(message)), 160)
}
+func TestConfigManagerPublicRequiresSuccessfullyLoadedSnapshot(t *testing.T) {
+ t.Run("absent persisted setting is legitimate default", func(t *testing.T) {
+ manager := NewConfigManager(nil, staticSettingRepository{values: map[string]string{
+ SettingKeyPromptAuditConfig: "",
+ SettingKeyRiskControl: "false",
+ }}, nil, prefixEncryptor{})
+ require.NoError(t, manager.Reload(context.Background()))
+
+ public, err := manager.Public()
+ require.NoError(t, err)
+ require.Equal(t, int64(1), public.ConfigVersion)
+ require.False(t, public.Enabled)
+ })
+
+ t.Run("persisted config activation failure is unavailable", func(t *testing.T) {
+ const canary = "persisted-token-canary"
+ manager := NewConfigManager(nil, staticSettingRepository{values: map[string]string{
+ SettingKeyPromptAuditConfig: `{"enabled":true,"config_version":9,"endpoints":[{"token_ciphertext":"` + canary + `"}]}`,
+ SettingKeyRiskControl: "true",
+ }}, nil, prefixEncryptor{})
+ require.Error(t, manager.Reload(context.Background()))
+
+ public, err := manager.Public()
+ require.Error(t, err)
+ require.Empty(t, public)
+ require.Equal(t, ErrorCodeConfigUnavailable, infraerrors.Reason(err))
+ require.NotContains(t, err.Error(), canary)
+ })
+
+ t.Run("reload failure preserves last successfully loaded snapshot", func(t *testing.T) {
+ storage := DefaultStorageConfig()
+ storage.ConfigVersion = 4
+ storage.ChangeSummary = "trusted snapshot"
+ raw, err := json.Marshal(storage)
+ require.NoError(t, err)
+ repository := &switchableSettingRepository{staticSettingRepository: staticSettingRepository{values: map[string]string{
+ SettingKeyPromptAuditConfig: string(raw),
+ SettingKeyRiskControl: "false",
+ }}}
+ manager := NewConfigManager(nil, repository, nil, prefixEncryptor{})
+ require.NoError(t, manager.Reload(context.Background()))
+ repository.loadErr = errors.New("settings unavailable")
+ require.Error(t, manager.Reload(context.Background()))
+
+ public, err := manager.Public()
+ require.NoError(t, err)
+ require.Equal(t, int64(4), public.ConfigVersion)
+ require.Equal(t, "trusted snapshot", public.ChangeSummary)
+ })
+}
+
func TestBuildNextStoragePreserveReplaceAndClearToken(t *testing.T) {
manager := &ConfigManager{encryptor: prefixEncryptor{}}
current := DefaultStorageConfig()
@@ -137,6 +188,18 @@ func (errorSettingRepository) GetMultiple(context.Context, []string) (map[string
return nil, errors.New("settings unavailable")
}
+type switchableSettingRepository struct {
+ staticSettingRepository
+ loadErr error
+}
+
+func (r *switchableSettingRepository) GetMultiple(ctx context.Context, keys []string) (map[string]string, error) {
+ if r.loadErr != nil {
+ return nil, r.loadErr
+ }
+ return r.staticSettingRepository.GetMultiple(ctx, keys)
+}
+
func TestConfigManagerStartupLoadFailureDoesNotBlockWhenBlockingNotIntended(t *testing.T) {
// Settings unavailable and no prior blocking intent: stay ModeOff so the
// gateway remains usable and admins can still disable/configure Prompt Audit.
diff --git a/backend/internal/securityaudit/prompt_guard_test.go b/backend/internal/securityaudit/prompt_guard_test.go
index 76e9dea05..2346857ea 100644
--- a/backend/internal/securityaudit/prompt_guard_test.go
+++ b/backend/internal/securityaudit/prompt_guard_test.go
@@ -222,7 +222,12 @@ func TestGuardEvaluatorFlagSharedDeadlineFailClosedAndContextCancel(t *testing.T
elapsed := time.Since(started)
require.Error(t, err)
require.Equal(t, 2, calls)
- require.Less(t, elapsed, 180*time.Millisecond)
+ // The bound only has to prove the failover shared the first endpoint's
+ // 70ms deadline instead of taking the second endpoint's own 500ms one.
+ // An unshared deadline lands at ~535ms, so 350ms still fails loudly
+ // while leaving room for scheduler delay on a busy CI machine. A
+ // tighter bound made this test flaky, not stricter.
+ require.Less(t, elapsed, 350*time.Millisecond)
require.GreaterOrEqual(t, elapsed, 50*time.Millisecond)
require.Equal(t, int64(1), metrics.Snapshot().Failovers)
require.Equal(t, int64(1), metrics.Snapshot().Timeouts)
diff --git a/backend/internal/securityaudit/prompt_handler.go b/backend/internal/securityaudit/prompt_handler.go
index b2d5a51a6..24284aa54 100644
--- a/backend/internal/securityaudit/prompt_handler.go
+++ b/backend/internal/securityaudit/prompt_handler.go
@@ -13,7 +13,7 @@ import (
)
type PromptAdminService interface {
- GetConfig() PublicConfig
+ GetConfig() (PublicConfig, error)
SaveConfig(context.Context, UpdateConfigRequest, int64) (PublicConfig, error)
Probe(context.Context, ProbeRequest) ProbeResult
Runtime(context.Context) RuntimeSnapshot
@@ -31,7 +31,14 @@ func NewPromptAdminHandler(service PromptAdminService) *PromptAdminHandler {
return &PromptAdminHandler{service: service}
}
-func (h *PromptAdminHandler) GetConfig(c *gin.Context) { response.Success(c, h.service.GetConfig()) }
+func (h *PromptAdminHandler) GetConfig(c *gin.Context) {
+ config, err := h.service.GetConfig()
+ if err != nil {
+ response.ErrorFrom(c, err)
+ return
+ }
+ response.Success(c, config)
+}
func (h *PromptAdminHandler) UpdateConfig(c *gin.Context) {
var request UpdateConfigRequest
diff --git a/backend/internal/securityaudit/prompt_handler_test.go b/backend/internal/securityaudit/prompt_handler_test.go
index 51a4305f3..8561ad93e 100644
--- a/backend/internal/securityaudit/prompt_handler_test.go
+++ b/backend/internal/securityaudit/prompt_handler_test.go
@@ -29,7 +29,9 @@ type fakePromptAdminService struct {
deleteFilter func(context.Context, DeleteByFilterRequest, int64) (*DeleteResult, error)
}
-func (s *fakePromptAdminService) GetConfig() PublicConfig { return s.config }
+func (s *fakePromptAdminService) GetConfig() (PublicConfig, error) {
+ return s.config, nil
+}
func (s *fakePromptAdminService) SaveConfig(ctx context.Context, req UpdateConfigRequest, actorID int64) (PublicConfig, error) {
if s.save == nil {
return PublicConfig{}, errors.New("unexpected SaveConfig call")
@@ -156,6 +158,21 @@ func TestPromptAdminConfigRequiresVersionMapsConflictAndNeverEchoesToken(t *test
})
}
+func TestPromptAdminGetConfigReturnsSecretFreeUnavailableError(t *testing.T) {
+ const canary = "persisted-config-secret-canary"
+ repository := &switchableSettingRepository{loadErr: errors.New("failed to load token " + canary)}
+ manager := NewConfigManager(nil, repository, nil, prefixEncryptor{})
+ require.Error(t, manager.Reload(context.Background()))
+ service := &PromptService{config: manager}
+
+ response := promptAdminRequest(t, promptAdminRouter(service), http.MethodGet, "/admin/prompt-audit/config", nil)
+ require.Equal(t, http.StatusServiceUnavailable, response.Code)
+ require.Contains(t, response.Body.String(), ErrorCodeConfigUnavailable)
+ require.NotContains(t, response.Body.String(), canary)
+ require.NotContains(t, response.Body.String(), `"config_version"`)
+ require.NotContains(t, response.Body.String(), `"token"`)
+}
+
func TestPromptAdminProbeSupportsTemporaryOrSavedTokenWithoutEcho(t *testing.T) {
const canary = "probe-token-canary"
for _, tc := range []struct {
diff --git a/backend/internal/securityaudit/prompt_service.go b/backend/internal/securityaudit/prompt_service.go
index 71d0fadbe..2d9d6605e 100644
--- a/backend/internal/securityaudit/prompt_service.go
+++ b/backend/internal/securityaudit/prompt_service.go
@@ -166,7 +166,7 @@ func (s *PromptService) Evaluate(ctx context.Context, req Request) (*PromptDecis
return s.evaluator.Evaluate(ctx, cfg, snapshot)
}
-func (s *PromptService) GetConfig() PublicConfig { return s.config.Public() }
+func (s *PromptService) GetConfig() (PublicConfig, error) { return s.config.Public() }
func (s *PromptService) SaveConfig(ctx context.Context, req UpdateConfigRequest, actorID int64) (PublicConfig, error) {
return s.config.Save(ctx, req, actorID)
diff --git a/backend/internal/securityaudit/prompt_types.go b/backend/internal/securityaudit/prompt_types.go
index 34611444e..7b25c33bd 100644
--- a/backend/internal/securityaudit/prompt_types.go
+++ b/backend/internal/securityaudit/prompt_types.go
@@ -12,11 +12,12 @@ const (
ConfigInvalidationChannel = "sub2api:prompt_guard:config:invalidate"
PayloadKeyPrefix = "sub2api:prompt_audit:payload:"
- ErrorCodeBlocked = "prompt_guard_blocked"
- ErrorCodeUnavailable = "prompt_guard_unavailable"
- ErrorCodeInvalidResponse = "prompt_guard_invalid_response"
- ErrorCodeConfigConflict = "prompt_audit_config_conflict"
- ErrorCodeRequiresEnabled = "prompt_guard_requires_audit_enabled"
+ ErrorCodeBlocked = "prompt_guard_blocked"
+ ErrorCodeUnavailable = "prompt_guard_unavailable"
+ ErrorCodeInvalidResponse = "prompt_guard_invalid_response"
+ ErrorCodeConfigConflict = "prompt_audit_config_conflict"
+ ErrorCodeConfigUnavailable = "prompt_audit_config_unavailable"
+ ErrorCodeRequiresEnabled = "prompt_guard_requires_audit_enabled"
DefaultGuardModel = "sileader/qwen3guard:0.6b"
)
diff --git a/backend/internal/securityaudit/prompt_worker_test.go b/backend/internal/securityaudit/prompt_worker_test.go
index 5c39be8e4..a91569c2c 100644
--- a/backend/internal/securityaudit/prompt_worker_test.go
+++ b/backend/internal/securityaudit/prompt_worker_test.go
@@ -48,7 +48,7 @@ func (s *fakeConfigStore) EffectiveMode() Mode {
return s.cfg.EffectiveMode()
}
func (s *fakeConfigStore) BlockingActivationDegraded() bool { return false }
-func (s *fakeConfigStore) Public() PublicConfig { return PublicConfig{} }
+func (s *fakeConfigStore) Public() (PublicConfig, error) { return PublicConfig{}, nil }
func (s *fakeConfigStore) Save(context.Context, UpdateConfigRequest, int64) (PublicConfig, error) {
return PublicConfig{}, nil
}
diff --git a/backend/internal/service/account_stats_pricing_test.go b/backend/internal/service/account_stats_pricing_test.go
index 57ace01c2..a934a5621 100644
--- a/backend/internal/service/account_stats_pricing_test.go
+++ b/backend/internal/service/account_stats_pricing_test.go
@@ -7,6 +7,7 @@ import (
"testing"
"time"
+ "github.com/Wei-Shaw/sub2api/internal/config"
"github.com/stretchr/testify/require"
)
@@ -698,6 +699,25 @@ func TestResolveAccountStatsCost_FallsBackToLiteLLM(t *testing.T) {
require.InDelta(t, 0.2, *result, 1e-12)
}
+func TestResolveAccountStatsCost_Gemini36FlashTierUsesFallbackPricing(t *testing.T) {
+ channel := &Channel{
+ ID: 1,
+ Status: StatusActive,
+ ApplyPricingToAccountStats: false,
+ }
+ cs := newTestChannelServiceForStats(t, channel, 10, "antigravity")
+ bs := NewBillingService(&config.Config{}, nil)
+
+ result := resolveAccountStatsCost(
+ context.Background(),
+ cs, bs,
+ 1, 10, "gemini-3.6-flash-low",
+ UsageTokens{InputTokens: 1_000_000, OutputTokens: 1_000_000, CacheReadTokens: 1_000_000}, 1, 0,
+ )
+ require.NotNil(t, result)
+ require.InDelta(t, 9.15, *result, 1e-12)
+}
+
func TestResolveAccountStatsCost_AllMiss_ReturnsNil(t *testing.T) {
channel := &Channel{
ID: 1,
diff --git a/backend/internal/service/account_test_service.go b/backend/internal/service/account_test_service.go
index 29f611450..3200174b2 100644
--- a/backend/internal/service/account_test_service.go
+++ b/backend/internal/service/account_test_service.go
@@ -794,6 +794,16 @@ func (s *AccountTestService) testGrokAccountConnection(c *gin.Context, account *
if resp.StatusCode != http.StatusOK {
body, _ := io.ReadAll(resp.Body)
+ if resp.StatusCode == http.StatusPaymentRequired && s.accountRepo != nil {
+ stateCtx, cancel := openAIAccountStateContext(ctx)
+ defer cancel()
+ _ = s.accountRepo.SetTempUnschedulable(
+ stateCtx,
+ account.ID,
+ time.Now().Add(30*time.Minute),
+ "grok payment required",
+ )
+ }
return s.sendErrorAndEnd(c, fmt.Sprintf("Grok Responses API returned %d: %s", resp.StatusCode, string(body)))
}
diff --git a/backend/internal/service/admin_service_group_test.go b/backend/internal/service/admin_service_group_test.go
index 98e63899b..c0b4faef5 100644
--- a/backend/internal/service/admin_service_group_test.go
+++ b/backend/internal/service/admin_service_group_test.go
@@ -1588,7 +1588,8 @@ func TestAdminService_CreateCompositeRoute_NormalizesAndPersists(t *testing.T) {
require.Equal(t, "router/gpt-", route.PublicModel)
require.Equal(t, CompositeRouteMatchPrefix, route.MatchType)
require.Equal(t, PlatformOpenAI, route.TargetPlatform)
- require.Equal(t, "router/gpt-", route.UpstreamModel)
+ // prefix 路由留空 upstream_model 不再回填 public_model：留空表示透传原始请求模型。
+ require.Equal(t, "", route.UpstreamModel)
require.Equal(t, CompositeRouteEndpointResponses, route.Endpoint)
require.Equal(t, 100, route.Priority)
require.True(t, route.Enabled)
@@ -1596,6 +1597,29 @@ func TestAdminService_CreateCompositeRoute_NormalizesAndPersists(t *testing.T) {
require.Equal(t, route, routeRepo.created)
}
+// TestAdminService_CreateCompositeRoute_ExactEmptyUpstreamBackfillsPublicModel 锁定
+// 保守行为：exact 路由留空 upstream_model 仍回填 public_model（持久化/展示契约不变）。
+func TestAdminService_CreateCompositeRoute_ExactEmptyUpstreamBackfillsPublicModel(t *testing.T) {
+ groupRepo := &groupRepoStubForAdmin{
+ getByID: &Group{ID: 7, Platform: PlatformComposite},
+ }
+ routeRepo := &compositeRouteRepoStubForAdmin{nextID: 99}
+ svc := &adminServiceImpl{groupRepo: groupRepo, compositeRouteRepo: routeRepo}
+
+ route, err := svc.CreateCompositeRoute(context.Background(), 7, CompositeRouteInput{
+ PublicModel: "openrouter/gpt-5",
+ MatchType: CompositeRouteMatchExact,
+ TargetPlatform: PlatformOpenAI,
+ Endpoint: CompositeRouteEndpointResponses,
+ Enabled: true,
+ })
+
+ require.NoError(t, err)
+ require.NotNil(t, route)
+ require.Equal(t, CompositeRouteMatchExact, route.MatchType)
+ require.Equal(t, "openrouter/gpt-5", route.UpstreamModel)
+}
+
func TestAdminService_UpdateAndDeleteCompositeRouteRequireRouteOwnership(t *testing.T) {
groupRepo := &groupRepoStubForAdmin{
getByID: &Group{ID: 7, Platform: PlatformComposite},
diff --git a/backend/internal/service/billing_service.go b/backend/internal/service/billing_service.go
index 98eb9c3ec..748eaf009 100644
--- a/backend/internal/service/billing_service.go
+++ b/backend/internal/service/billing_service.go
@@ -272,6 +272,17 @@ func (s *BillingService) initFallbackPricing() {
SupportsCacheBreakdown: false,
}
+ // Gemini 3.6 Flash (Google AI pricing: $1.50 input / $7.50 output /
+ // $0.15 cached input per MTok). Antigravity's -high/-low/-medium/-tiered
+ // aliases are matched below so unavailable remote pricing never records
+ // token-bearing requests at $0.
+ s.fallbackPrices["gemini-3.6-flash"] = &ModelPricing{
+ InputPricePerToken: 1.5e-6,
+ OutputPricePerToken: 7.5e-6,
+ CacheReadPricePerToken: 0.15e-6,
+ SupportsCacheBreakdown: false,
+ }
+
// OpenAI GPT-5.4（业务指定价格）
s.fallbackPrices["gpt-5.4"] = &ModelPricing{
InputPricePerToken: 2.5e-6, // $2.5 per MTok
@@ -630,6 +641,9 @@ func (s *BillingService) getFallbackPricing(model string) *ModelPricing {
if strings.Contains(modelLower, "gemini-3.1-pro") || strings.Contains(modelLower, "gemini-3-1-pro") {
return s.fallbackPrices["gemini-3.1-pro"]
}
+ if strings.Contains(modelLower, "gemini-3.6-flash") || strings.Contains(modelLower, "gemini-3-6-flash") {
+ return s.fallbackPrices["gemini-3.6-flash"]
+ }
// DeepSeek V4 系列：仅匹配已知 V4 Pro/Flash 与官方兼容别名
// （deepseek-chat / deepseek-reasoner → V4 Flash），未知 deepseek-* 型号不回退，避免误计价。
diff --git a/backend/internal/service/composite_model_route.go b/backend/internal/service/composite_model_route.go
index 2bae5c62d..a008a3e9f 100644
--- a/backend/internal/service/composite_model_route.go
+++ b/backend/internal/service/composite_model_route.go
@@ -118,7 +118,12 @@ func normalizeCompositeRouteInput(input CompositeRouteInput) CompositeRouteInput
input.TargetPlatform = strings.TrimSpace(input.TargetPlatform)
input.UpstreamModel = strings.TrimSpace(input.UpstreamModel)
input.Endpoint = normalizeCompositeRouteEndpoint(input.Endpoint)
- if input.UpstreamModel == "" {
+ // 仅对 exact 路由把空 upstream_model 回填成 public_model：exact 命中时请求模型
+ // 恒等于 public_model，回填只影响持久化/后台展示，保留原有契约不变。
+ // prefix 路由留空则不回填——Resolve 会回退到具体请求模型，从而透传原始模型
+ // （否则 public=deepseek-v4 的前缀路由会把 deepseek-v4-flash / deepseek-v4-pro
+ // 都塌缩成固定的 deepseek-v4）。显式填写 upstream_model 时任何模式都原样固定转发。
+ if input.UpstreamModel == "" && input.MatchType == CompositeRouteMatchExact {
input.UpstreamModel = input.PublicModel
}
input.Notes = strings.TrimSpace(input.Notes)
diff --git a/backend/internal/service/composite_route_resolver_test.go b/backend/internal/service/composite_route_resolver_test.go
index ed6f6f085..35028934d 100644
--- a/backend/internal/service/composite_route_resolver_test.go
+++ b/backend/internal/service/composite_route_resolver_test.go
@@ -107,6 +107,63 @@ func TestCompositeRouteResolverPrefersEndpointSpecificLongestPrefix(t *testing.T
require.Equal(t, int64(2), decision.Route.ID)
}
+// TestCompositeRouteResolverPrefixEmptyUpstreamPassesThroughRequestedModel 验证：
+// 前缀匹配路由留空 upstream_model 时，转发的是具体请求模型（各自原样），而不是
+// 塌缩成 public_model。这是「留空 = 透传原始模型」语义的核心场景。
+func TestCompositeRouteResolverPrefixEmptyUpstreamPassesThroughRequestedModel(t *testing.T) {
+ resolver := NewCompositeRouteResolver(compositeRouteRepoStub{
+ routes: []CompositeModelRoute{
+ {
+ ID: 1,
+ GroupID: 7,
+ PublicModel: "deepseek-v4",
+ MatchType: CompositeRouteMatchPrefix,
+ TargetPlatform: PlatformOpenAI,
+ UpstreamModel: "", // 留空 = 透传
+ Endpoint: CompositeRouteEndpointAny,
+ Priority: 100,
+ Enabled: true,
+ },
+ },
+ })
+
+ for _, model := range []string{"deepseek-v4-flash", "deepseek-v4-pro", "deepseek-v4"} {
+ decision, err := resolver.Resolve(context.Background(), 7, model, CompositeRouteEndpointChatCompletions)
+ require.NoError(t, err)
+ require.True(t, decision.Matched, "model %q should match prefix route", model)
+ require.Equal(t, CompositeRouteSourceExplicit, decision.Source)
+ require.Equal(t, PlatformOpenAI, decision.TargetPlatform)
+ require.Equal(t, model, decision.UpstreamModel, "model %q should pass through verbatim", model)
+ }
+}
+
+// TestCompositeRouteResolverPrefixExplicitUpstreamStillFixed 验证：前缀匹配路由显式
+// 填写 upstream_model 时，所有命中请求仍转发同一个固定上游模型（行为不变）。
+func TestCompositeRouteResolverPrefixExplicitUpstreamStillFixed(t *testing.T) {
+ resolver := NewCompositeRouteResolver(compositeRouteRepoStub{
+ routes: []CompositeModelRoute{
+ {
+ ID: 1,
+ GroupID: 7,
+ PublicModel: "deepseek-v4",
+ MatchType: CompositeRouteMatchPrefix,
+ TargetPlatform: PlatformOpenAI,
+ UpstreamModel: "deepseek-chat",
+ Endpoint: CompositeRouteEndpointAny,
+ Priority: 100,
+ Enabled: true,
+ },
+ },
+ })
+
+ for _, model := range []string{"deepseek-v4-flash", "deepseek-v4-pro"} {
+ decision, err := resolver.Resolve(context.Background(), 7, model, CompositeRouteEndpointChatCompletions)
+ require.NoError(t, err)
+ require.True(t, decision.Matched)
+ require.Equal(t, "deepseek-chat", decision.UpstreamModel)
+ }
+}
+
func TestCompositeRouteResolverIgnoresDisabledRoutesAndFallsBackToDetector(t *testing.T) {
resolver := NewCompositeRouteResolver(compositeRouteRepoStub{
routes: []CompositeModelRoute{
diff --git a/backend/internal/service/gateway_claude_oauth_body.go b/backend/internal/service/gateway_claude_oauth_body.go
index 9fbbc674d..9450ddbb1 100644
--- a/backend/internal/service/gateway_claude_oauth_body.go
+++ b/backend/internal/service/gateway_claude_oauth_body.go
@@ -1208,3 +1208,28 @@ func (s *GatewayService) claudeOAuthSystemPromptInjectionSettings(ctx context.Co
}
return s.settingService.GetClaudeOAuthSystemPromptInjectionSettings(ctx)
}
+
+// systemHasBillingAttributionBlock 检查请求体的 system 字段中是否包含真实 Claude Code
+// 客户端注入的 billing attribution block。该 block 格式稳定（见 gateway_billing_block.go），
+// 仅由真实 Claude Code CLI 生成；第三方客户端（opencode 等）不会生成此 block。
+//
+// 用于识别被上游 API 网关代理的真实 Claude Code 流量：此类请求的 User-Agent 被网关替换
+// 为 Go-http-client，但 body 保留了完整的客户端特征。如果不识别这类请求而走 mimicry
+// 重写 system，会破坏 Anthropic prompt cache 的前缀一致性，导致 messages 级缓存永不命中。
+func systemHasBillingAttributionBlock(body []byte) bool {
+ system := gjson.GetBytes(body, "system")
+ if !system.IsArray() {
+ return false
+ }
+ found := false
+ system.ForEach(func(_, item gjson.Result) bool {
+ text := item.Get("text").String()
+ if strings.HasPrefix(text, claudeCodeBillingHeaderPrefix) &&
+ strings.Contains(text, claudeCodeEntrypointMarker) {
+ found = true
+ return false
+ }
+ return true
+ })
+ return found
+}
diff --git a/backend/internal/service/gateway_forward.go b/backend/internal/service/gateway_forward.go
index 3005d93fa..5a78a1981 100644
--- a/backend/internal/service/gateway_forward.go
+++ b/backend/internal/service/gateway_forward.go
@@ -170,6 +170,17 @@ func (s *GatewayService) Forward(ctx context.Context, c *gin.Context, account *A
clientUserAgent = c.GetHeader("User-Agent")
}
isClaudeCode := IsClaudeCodeClient(ctx) || isClaudeCodeClient(clientUserAgent, parsed.MetadataUserID)
+
+ // 补充判定：上游 API 网关（如 new-api）转发真实 Claude Code 流量时，
+ // UA 会变成 Go-http-client 但 body 保留了完整的 Claude Code 特征
+ // （billing attribution block + metadata.user_id）。此时如果仍走 mimicry
+ // 重写 system prompt，会破坏 Anthropic prompt cache 的前缀匹配——
+ // 导致 messages 级缓存永远 miss、cache_creation 每轮全量重写。
+ // 通过检查 body 中的 billing attribution block 来识别被代理的真实 CC 流量。
+ if !isClaudeCode && parsed.MetadataUserID != "" {
+ isClaudeCode = systemHasBillingAttributionBlock(body)
+ }
+
shouldMimicClaudeCode := account.IsOAuth() && !isClaudeCode
if shouldMimicClaudeCode {
diff --git a/backend/internal/service/gateway_forward_as_responses.go b/backend/internal/service/gateway_forward_as_responses.go
index e5f0ddc3c..2aa5255c2 100644
--- a/backend/internal/service/gateway_forward_as_responses.go
+++ b/backend/internal/service/gateway_forward_as_responses.go
@@ -37,15 +37,21 @@ func (s *GatewayService) ForwardAsResponses(
) (*ForwardResult, error) {
startTime := time.Now()
- // 1. Parse Responses request
+ // 1. Lower Codex client-side tools to function tools understood by Anthropic.
+ adaptedBody, clientToolMapping, err := adaptResponsesClientToolsForAnthropic(body)
+ if err != nil {
+ return nil, fmt.Errorf("adapt responses client tools: %w", err)
+ }
+
+ // 2. Parse Responses request
var responsesReq apicompat.ResponsesRequest
- if err := json.Unmarshal(body, &responsesReq); err != nil {
+ if err := json.Unmarshal(adaptedBody, &responsesReq); err != nil {
return nil, fmt.Errorf("parse responses request: %w", err)
}
originalModel := responsesReq.Model
clientStream := responsesReq.Stream
- // 2. Convert Responses → Anthropic
+ // 3. Convert Responses → Anthropic
anthropicReq, err := apicompat.ResponsesToAnthropicRequest(&responsesReq)
if err != nil {
return nil, fmt.Errorf("convert responses to anthropic: %w", err)
@@ -182,14 +188,71 @@ func (s *GatewayService) ForwardAsResponses(
var result *ForwardResult
var handleErr error
if clientStream {
- result, handleErr = s.handleResponsesStreamingResponse(resp, c, originalModel, mappedModel, reasoningEffort, startTime)
+ result, handleErr = s.handleResponsesStreamingResponse(resp, c, originalModel, mappedModel, reasoningEffort, startTime, clientToolMapping)
} else {
- result, handleErr = s.handleResponsesBufferedStreamingResponse(resp, c, originalModel, mappedModel, reasoningEffort, startTime)
+ result, handleErr = s.handleResponsesBufferedStreamingResponse(resp, c, originalModel, mappedModel, reasoningEffort, startTime, clientToolMapping)
}
return result, handleErr
}
+func adaptResponsesClientToolsForAnthropic(body []byte) ([]byte, apicompat.ResponsesClientToolMapping, error) {
+ decoder := json.NewDecoder(bytes.NewReader(body))
+ decoder.UseNumber()
+ var requestBody map[string]any
+ if err := decoder.Decode(&requestBody); err != nil {
+ return body, apicompat.ResponsesClientToolMapping{}, err
+ }
+ additionalToolsChanged, err := liftResponsesAdditionalTools(requestBody)
+ if err != nil {
+ return body, apicompat.ResponsesClientToolMapping{}, err
+ }
+
+ mapping, changed, err := apicompat.AdaptResponsesClientTools(requestBody)
+ if err != nil {
+ return body, apicompat.ResponsesClientToolMapping{}, err
+ }
+ changed = changed || additionalToolsChanged
+ if !changed {
+ return body, mapping, nil
+ }
+ rebuilt, err := json.Marshal(requestBody)
+ if err != nil {
+ return body, apicompat.ResponsesClientToolMapping{}, err
+ }
+ return rebuilt, mapping, nil
+}
+
+func liftResponsesAdditionalTools(requestBody map[string]any) (bool, error) {
+ input, ok := requestBody["input"].([]any)
+ if !ok {
+ return false, nil
+ }
+
+ tools, _ := requestBody["tools"].([]any)
+ kept := make([]any, 0, len(input))
+ changed := false
+ for _, raw := range input {
+ item, ok := raw.(map[string]any)
+ if !ok || strings.TrimSpace(fmt.Sprint(item["type"])) != "additional_tools" {
+ kept = append(kept, raw)
+ continue
+ }
+ additional, ok := item["tools"].([]any)
+ if !ok {
+ return false, fmt.Errorf("additional_tools.tools must be an array")
+ }
+ tools = append(tools, additional...)
+ changed = true
+ }
+ if !changed {
+ return false, nil
+ }
+ requestBody["tools"] = tools
+ requestBody["input"] = kept
+ return true, nil
+}
+
// ExtractResponsesReasoningEffortFromBody reads Responses API reasoning.effort
// and normalizes it for usage logging.
func ExtractResponsesReasoningEffortFromBody(body []byte) *string {
@@ -243,6 +306,7 @@ func (s *GatewayService) handleResponsesBufferedStreamingResponse(
mappedModel string,
reasoningEffort *string,
startTime time.Time,
+ clientToolMapping apicompat.ResponsesClientToolMapping,
) (*ForwardResult, error) {
requestID := resp.Header.Get("x-request-id")
@@ -358,6 +422,10 @@ func (s *GatewayService) handleResponsesBufferedStreamingResponse(
c.Writer.Header().Set("Content-Type", "application/json; charset=utf-8")
if respBytes, err := json.Marshal(responsesResp); err == nil {
respBytes = reverseToolNamesIfPresent(c, respBytes)
+ respBytes, _, err = apicompat.RestoreResponsesClientToolPayload(respBytes, clientToolMapping)
+ if err != nil {
+ return nil, fmt.Errorf("restore responses client tools: %w", err)
+ }
c.Data(http.StatusOK, "application/json; charset=utf-8", respBytes)
} else {
c.JSON(http.StatusOK, responsesResp)
@@ -383,6 +451,7 @@ func (s *GatewayService) handleResponsesStreamingResponse(
mappedModel string,
reasoningEffort *string,
startTime time.Time,
+ clientToolMapping apicompat.ResponsesClientToolMapping,
) (*ForwardResult, error) {
requestID := resp.Header.Get("x-request-id")
@@ -397,6 +466,7 @@ func (s *GatewayService) handleResponsesStreamingResponse(
state := apicompat.NewAnthropicEventToResponsesState()
state.Model = originalModel
+ clientToolRestorer := apicompat.NewResponsesClientToolStreamRestorer(clientToolMapping)
var usage ClaudeUsage
var firstTokenMs *int
firstChunk := true
@@ -441,7 +511,7 @@ func (s *GatewayService) handleResponsesStreamingResponse(
// Convert to Responses events
events := apicompat.AnthropicEventToResponsesEvents(event, state)
for _, evt := range events {
- sse, err := apicompat.ResponsesEventToSSE(evt)
+ payload, err := json.Marshal(evt)
if err != nil {
logger.L().Warn("forward_as_responses stream: failed to marshal event",
zap.Error(err),
@@ -449,12 +519,23 @@ func (s *GatewayService) handleResponsesStreamingResponse(
)
continue
}
- out := string(reverseToolNamesIfPresent(c, []byte(sse)))
- if _, err := fmt.Fprint(c.Writer, out); err != nil {
- logger.L().Info("forward_as_responses stream: client disconnected",
+ payload = reverseToolNamesIfPresent(c, payload)
+ payloads, _, err := clientToolRestorer.RestoreEvent(payload)
+ if err != nil {
+ logger.L().Warn("forward_as_responses stream: failed to restore client tools",
+ zap.Error(err),
zap.String("request_id", requestID),
)
- return true // client disconnected
+ continue
+ }
+ for _, restored := range payloads {
+ eventType := gjson.GetBytes(restored, "type").String()
+ if _, err := fmt.Fprintf(c.Writer, "event: %s\ndata: %s\n\n", eventType, restored); err != nil {
+ logger.L().Info("forward_as_responses stream: client disconnected",
+ zap.String("request_id", requestID),
+ )
+ return true // client disconnected
+ }
}
}
if len(events) > 0 {
diff --git a/backend/internal/service/gateway_forward_as_responses_test.go b/backend/internal/service/gateway_forward_as_responses_test.go
index baaf8b954..6784e7c7a 100644
--- a/backend/internal/service/gateway_forward_as_responses_test.go
+++ b/backend/internal/service/gateway_forward_as_responses_test.go
@@ -3,6 +3,7 @@
package service
import (
+ "encoding/json"
"io"
"net/http"
"net/http/httptest"
@@ -10,10 +11,129 @@ import (
"testing"
"time"
+ "github.com/Wei-Shaw/sub2api/internal/pkg/apicompat"
"github.com/gin-gonic/gin"
"github.com/stretchr/testify/require"
)
+func TestAdaptResponsesClientToolsForAnthropic_FlattensNamespace(t *testing.T) {
+ t.Parallel()
+
+ body := []byte(`{
+ "model":"claude-fable-5",
+ "input":[{"type":"function_call","call_id":"call_1","namespace":"codex_app","name":"read_thread","arguments":"{}"}],
+ "tools":[{"type":"namespace","name":"codex_app","tools":[{"type":"function","name":"read_thread","description":"Read a task","parameters":{"type":"object","properties":{}}}]}]
+ }`)
+
+ adapted, mapping, err := adaptResponsesClientToolsForAnthropic(body)
+ require.NoError(t, err)
+ require.Equal(t, apicompat.ResponsesNamespaceName{Namespace: "codex_app", Name: "read_thread"}, mapping.NamespaceTools["codex_app__read_thread"])
+
+ var request map[string]any
+ require.NoError(t, json.Unmarshal(adapted, &request))
+ tools := request["tools"].([]any)
+ require.Len(t, tools, 1)
+ tool := tools[0].(map[string]any)
+ require.Equal(t, "function", tool["type"])
+ require.Equal(t, "codex_app__read_thread", tool["name"])
+
+ input := request["input"].([]any)
+ call := input[0].(map[string]any)
+ require.Equal(t, "codex_app__read_thread", call["name"])
+ require.NotContains(t, call, "namespace")
+}
+
+func TestAdaptResponsesClientToolsForAnthropic_LiftsAdditionalTools(t *testing.T) {
+ body := []byte(`{
+ "model":"claude-fable-5",
+ "input":[
+ {"type":"additional_tools","tools":[
+ {"type":"custom","name":"exec","description":"Run a command"},
+ {"type":"namespace","name":"codex_app","tools":[
+ {"type":"function","name":"read_thread","parameters":{"type":"object"}}
+ ]}
+ ]},
+ {"type":"message","role":"user","content":[{"type":"input_text","text":"inspect"}]}
+ ]
+ }`)
+
+ adapted, mapping, err := adaptResponsesClientToolsForAnthropic(body)
+ require.NoError(t, err)
+ require.True(t, mapping.CustomTools["exec"])
+ require.Equal(t, apicompat.ResponsesNamespaceName{Namespace: "codex_app", Name: "read_thread"}, mapping.NamespaceTools["codex_app__read_thread"])
+
+ var request map[string]any
+ require.NoError(t, json.Unmarshal(adapted, &request))
+ tools := request["tools"].([]any)
+ require.Len(t, tools, 2)
+ require.Equal(t, "function", tools[0].(map[string]any)["type"])
+ require.Equal(t, "codex_app__read_thread", tools[1].(map[string]any)["name"])
+
+ input := request["input"].([]any)
+ require.Len(t, input, 1)
+ require.Equal(t, "message", input[0].(map[string]any)["type"])
+}
+
+func namespaceToolAnthropicStream() string {
+ return strings.Join([]string{
+ `event: message_start`,
+ `data: {"type":"message_start","message":{"id":"msg_namespace","type":"message","role":"assistant","content":[],"model":"claude-fable-5","stop_reason":"","usage":{"input_tokens":10}}}`,
+ ``,
+ `event: content_block_start`,
+ `data: {"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"toolu_namespace","name":"codex_app__read_thread","input":{"thread_id":"123"}}}`,
+ ``,
+ `event: content_block_stop`,
+ `data: {"type":"content_block_stop","index":0}`,
+ ``,
+ `event: message_delta`,
+ `data: {"type":"message_delta","delta":{"stop_reason":"tool_use"},"usage":{"output_tokens":5}}`,
+ ``,
+ `event: message_stop`,
+ `data: {"type":"message_stop"}`,
+ ``,
+ }, "\n")
+}
+
+func namespaceToolMapping() apicompat.ResponsesClientToolMapping {
+ return apicompat.ResponsesClientToolMapping{NamespaceTools: map[string]apicompat.ResponsesNamespaceName{
+ "codex_app__read_thread": {Namespace: "codex_app", Name: "read_thread"},
+ }}
+}
+
+func TestHandleResponsesBufferedStreamingResponse_RestoresNamespaceTool(t *testing.T) {
+ t.Parallel()
+ gin.SetMode(gin.TestMode)
+
+ rec := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(rec)
+ resp := &http.Response{Body: io.NopCloser(strings.NewReader(namespaceToolAnthropicStream()))}
+
+ svc := &GatewayService{}
+ _, err := svc.handleResponsesBufferedStreamingResponse(resp, c, "claude-fable-5", "claude-fable-5", nil, time.Now(), namespaceToolMapping())
+ require.NoError(t, err)
+ require.Contains(t, rec.Body.String(), `"type":"function_call"`)
+ require.Contains(t, rec.Body.String(), `"name":"read_thread"`)
+ require.Contains(t, rec.Body.String(), `"namespace":"codex_app"`)
+ require.NotContains(t, rec.Body.String(), `"name":"codex_app__read_thread"`)
+}
+
+func TestHandleResponsesStreamingResponse_RestoresNamespaceTool(t *testing.T) {
+ t.Parallel()
+ gin.SetMode(gin.TestMode)
+
+ rec := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(rec)
+ resp := &http.Response{Body: io.NopCloser(strings.NewReader(namespaceToolAnthropicStream()))}
+
+ svc := &GatewayService{}
+ _, err := svc.handleResponsesStreamingResponse(resp, c, "claude-fable-5", "claude-fable-5", nil, time.Now(), namespaceToolMapping())
+ require.NoError(t, err)
+ require.Contains(t, rec.Body.String(), `response.output_item.added`)
+ require.Contains(t, rec.Body.String(), `"name":"read_thread"`)
+ require.Contains(t, rec.Body.String(), `"namespace":"codex_app"`)
+ require.NotContains(t, rec.Body.String(), `"name":"codex_app__read_thread"`)
+}
+
func TestExtractResponsesReasoningEffortFromBody(t *testing.T) {
t.Parallel()
@@ -51,7 +171,7 @@ func TestHandleResponsesBufferedStreamingResponse_PreservesMessageStartCacheUsag
}
svc := &GatewayService{}
- result, err := svc.handleResponsesBufferedStreamingResponse(resp, c, "claude-sonnet-4.5", "claude-sonnet-4.5", nil, time.Now())
+ result, err := svc.handleResponsesBufferedStreamingResponse(resp, c, "claude-sonnet-4.5", "claude-sonnet-4.5", nil, time.Now(), apicompat.ResponsesClientToolMapping{})
require.NoError(t, err)
require.NotNil(t, result)
require.Equal(t, 12, result.Usage.InputTokens)
@@ -87,7 +207,7 @@ func TestHandleResponsesStreamingResponse_PreservesMessageStartCacheUsage(t *tes
}
svc := &GatewayService{}
- result, err := svc.handleResponsesStreamingResponse(resp, c, "claude-sonnet-4.5", "claude-sonnet-4.5", nil, time.Now())
+ result, err := svc.handleResponsesStreamingResponse(resp, c, "claude-sonnet-4.5", "claude-sonnet-4.5", nil, time.Now(), apicompat.ResponsesClientToolMapping{})
require.NoError(t, err)
require.NotNil(t, result)
require.Equal(t, 20, result.Usage.InputTokens)
@@ -198,7 +318,7 @@ func TestHandleResponsesBufferedStreamingResponse_CompactSSEFormat(t *testing.T)
}
svc := &GatewayService{}
- result, err := svc.handleResponsesBufferedStreamingResponse(resp, c, "claude-sonnet-4.5", "claude-sonnet-4.5", nil, time.Now())
+ result, err := svc.handleResponsesBufferedStreamingResponse(resp, c, "claude-sonnet-4.5", "claude-sonnet-4.5", nil, time.Now(), apicompat.ResponsesClientToolMapping{})
require.NoError(t, err)
require.NotNil(t, result)
require.Equal(t, 10, result.Usage.InputTokens)
@@ -232,7 +352,7 @@ func TestHandleResponsesStreamingResponse_CompactSSEFormat(t *testing.T) {
}
svc := &GatewayService{}
- result, err := svc.handleResponsesStreamingResponse(resp, c, "claude-sonnet-4.5", "claude-sonnet-4.5", nil, time.Now())
+ result, err := svc.handleResponsesStreamingResponse(resp, c, "claude-sonnet-4.5", "claude-sonnet-4.5", nil, time.Now(), apicompat.ResponsesClientToolMapping{})
require.NoError(t, err)
require.NotNil(t, result)
require.Equal(t, 15, result.Usage.InputTokens)
diff --git a/backend/internal/service/gateway_hotpath_optimization_test.go b/backend/internal/service/gateway_hotpath_optimization_test.go
index e5bf49b8b..13fc32165 100644
--- a/backend/internal/service/gateway_hotpath_optimization_test.go
+++ b/backend/internal/service/gateway_hotpath_optimization_test.go
@@ -219,7 +219,15 @@ func TestGetUserGroupRateMultiplier_UsesCacheAndSingleflight(t *testing.T) {
}
close(start)
- time.Sleep(20 * time.Millisecond)
+ // Wait for every caller to have recorded its cache miss before releasing the
+ // loader. A fixed sleep raced here: a goroutine that reached the cache after
+ // the singleflight load had already finished got a hit instead of a miss, and
+ // the miss assertion below saw 11 of 12. The miss counter is the observable
+ // that says "all callers are now inside the singleflight group".
+ require.Eventually(t, func() bool {
+ _, miss, _, _, _ := GatewayUserGroupRateCacheStats()
+ return miss == int64(concurrent)
+ }, 5*time.Second, time.Millisecond, "all callers must miss the cache before the loader is released")
close(unblock)
wg.Wait()
diff --git a/backend/internal/service/gateway_record_usage_test.go b/backend/internal/service/gateway_record_usage_test.go
index 28963a430..81aff5827 100644
--- a/backend/internal/service/gateway_record_usage_test.go
+++ b/backend/internal/service/gateway_record_usage_test.go
@@ -194,6 +194,64 @@ func TestGatewayServiceRecordUsage_PreservesRequestedAndUpstreamModels(t *testin
require.Equal(t, mappedModel, *usageRepo.lastLog.UpstreamModel)
}
+func TestGatewayServiceRecordUsage_PreservesChannelMappedUpstreamModel(t *testing.T) {
+ usageRepo := &openAIRecordUsageLogRepoStub{inserted: true}
+ svc := newGatewayRecordUsageServiceForTest(usageRepo, &openAIRecordUsageUserRepoStub{}, &openAIRecordUsageSubRepoStub{})
+
+ err := svc.RecordUsage(context.Background(), &RecordUsageInput{
+ Result: &ForwardResult{
+ RequestID: "gateway_channel_mapping_models",
+ Usage: ClaudeUsage{InputTokens: 10, OutputTokens: 6},
+ Model: "gpt-5.6-terra",
+ UpstreamModel: "gpt-5.6-terra",
+ Duration: time.Second,
+ },
+ APIKey: &APIKey{ID: 501, Quota: 100},
+ User: &User{ID: 601},
+ Account: &Account{ID: 701},
+ ChannelUsageFields: ChannelUsageFields{
+ OriginalModel: "gpt-5.6-sol",
+ ChannelMappedModel: "gpt-5.6-terra",
+ },
+ })
+
+ require.NoError(t, err)
+ require.NotNil(t, usageRepo.lastLog)
+ require.Equal(t, "gpt-5.6-sol", usageRepo.lastLog.RequestedModel)
+ require.Equal(t, "gpt-5.6-terra", usageRepo.lastLog.Model)
+ require.NotNil(t, usageRepo.lastLog.UpstreamModel)
+ require.Equal(t, "gpt-5.6-terra", *usageRepo.lastLog.UpstreamModel)
+}
+
+func TestGatewayServiceRecordUsage_PreservesLoopedChannelAndAccountUpstreamModel(t *testing.T) {
+ usageRepo := &openAIRecordUsageLogRepoStub{inserted: true}
+ svc := newGatewayRecordUsageServiceForTest(usageRepo, &openAIRecordUsageUserRepoStub{}, &openAIRecordUsageSubRepoStub{})
+
+ err := svc.RecordUsage(context.Background(), &RecordUsageInput{
+ Result: &ForwardResult{
+ RequestID: "gateway_looped_mapping_models",
+ Usage: ClaudeUsage{InputTokens: 10, OutputTokens: 6},
+ Model: "gpt-5.6-terra",
+ UpstreamModel: "gpt-5.6-sol",
+ Duration: time.Second,
+ },
+ APIKey: &APIKey{ID: 501, Quota: 100},
+ User: &User{ID: 601},
+ Account: &Account{ID: 701},
+ ChannelUsageFields: ChannelUsageFields{
+ OriginalModel: "gpt-5.6-sol",
+ ChannelMappedModel: "gpt-5.6-terra",
+ },
+ })
+
+ require.NoError(t, err)
+ require.NotNil(t, usageRepo.lastLog)
+ require.Equal(t, "gpt-5.6-sol", usageRepo.lastLog.RequestedModel)
+ require.Equal(t, "gpt-5.6-terra", usageRepo.lastLog.Model)
+ require.NotNil(t, usageRepo.lastLog.UpstreamModel)
+ require.Equal(t, "gpt-5.6-sol", *usageRepo.lastLog.UpstreamModel)
+}
+
func TestGatewayServiceRecordUsage_EmptyImageSizeDefaultsBeforeBillingAndPersistence(t *testing.T) {
imagePrice2K := 0.19
groupID := int64(901)
diff --git a/backend/internal/service/gateway_usage_billing.go b/backend/internal/service/gateway_usage_billing.go
index f445814d0..51b8031fc 100644
--- a/backend/internal/service/gateway_usage_billing.go
+++ b/backend/internal/service/gateway_usage_billing.go
@@ -986,7 +986,7 @@ func (s *GatewayService) buildRecordUsageLog(
RequestID: requestID,
Model: result.Model,
RequestedModel: requestedModel,
- UpstreamModel: optionalNonEqualStringPtr(result.UpstreamModel, result.Model),
+ UpstreamModel: optionalTrimmedStringPtr(result.UpstreamModel),
ReasoningEffort: result.ReasoningEffort,
InboundEndpoint: optionalTrimmedStringPtr(input.InboundEndpoint),
UpstreamEndpoint: optionalTrimmedStringPtr(input.UpstreamEndpoint),
diff --git a/backend/internal/service/gemini_chat_completions_compat_service.go b/backend/internal/service/gemini_chat_completions_compat_service.go
index 5f868a5d6..f23c18008 100644
--- a/backend/internal/service/gemini_chat_completions_compat_service.go
+++ b/backend/internal/service/gemini_chat_completions_compat_service.go
@@ -231,7 +231,11 @@ func (s *GeminiMessagesCompatService) forwardClaudeBodyAsChatCompletions(
Kind: "failover",
Message: upstreamMsg,
})
- return nil, &UpstreamFailoverError{StatusCode: resp.StatusCode, ResponseBody: evBody}
+ return nil, &UpstreamFailoverError{
+ StatusCode: resp.StatusCode,
+ ResponseBody: evBody,
+ RetryableOnSameAccount: account.IsPoolMode() && account.IsPoolModeRetryableStatus(resp.StatusCode),
+ }
}
return nil, s.writeGeminiChatCompletionsMappedError(c, account, resp.StatusCode, requestID, evBody)
diff --git a/backend/internal/service/gemini_error_policy_test.go b/backend/internal/service/gemini_error_policy_test.go
index deae912c9..e71bd141b 100644
--- a/backend/internal/service/gemini_error_policy_test.go
+++ b/backend/internal/service/gemini_error_policy_test.go
@@ -352,6 +352,68 @@ func TestGeminiErrorPolicyIntegration(t *testing.T) {
}
}
+// ---------------------------------------------------------------------------
+// TestPoolModeSkippedFailoverError — pool-mode accounts hitting
+// ErrorPolicySkipped must failover (align with other platform forwards)
+// instead of passing the upstream error through to the client.
+// ---------------------------------------------------------------------------
+
+func TestPoolModeSkippedFailoverError(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+ svc := &GeminiMessagesCompatService{}
+
+ poolAccount := func(extra map[string]any) *Account {
+ creds := map[string]any{"pool_mode": true}
+ for k, v := range extra {
+ creds[k] = v
+ }
+ return &Account{ID: 300, Type: AccountTypeAPIKey, Platform: PlatformGemini, Credentials: creds}
+ }
+
+ tests := []struct {
+ name string
+ account *Account
+ statusCode int
+ expectFailover bool
+ expectSameAccount bool
+ }{
+ {"pool_500_failover_no_same_account_retry", poolAccount(nil), 500, true, false},
+ {"pool_429_failover_with_same_account_retry", poolAccount(nil), 429, true, true},
+ {"pool_custom_retry_codes_500", poolAccount(map[string]any{
+ "pool_mode_retry_status_codes": []any{float64(500)},
+ }), 500, true, true},
+ {"pool_400_not_failover_worthy", poolAccount(nil), 400, false, false},
+ {"non_pool_account_keeps_passthrough", &Account{
+ ID: 301, Type: AccountTypeAPIKey, Platform: PlatformGemini,
+ Credentials: map[string]any{
+ "custom_error_codes_enabled": true,
+ "custom_error_codes": []any{float64(429)},
+ },
+ }, 500, false, false},
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ writer := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(writer)
+ c.Request = httptest.NewRequest(http.MethodPost, "/v1/messages", nil)
+
+ body := []byte(`{"error":{"code":"bad_response_status_code","message":"openai_error"}}`)
+ failoverErr := svc.poolModeSkippedFailoverError(c, tt.account, tt.statusCode, body, "req-1")
+
+ if !tt.expectFailover {
+ require.Nil(t, failoverErr)
+ return
+ }
+ require.NotNil(t, failoverErr)
+ require.Equal(t, tt.statusCode, failoverErr.StatusCode)
+ require.Equal(t, body, failoverErr.ResponseBody)
+ require.Equal(t, tt.expectSameAccount, failoverErr.RetryableOnSameAccount)
+ require.True(t, failoverErr.ShouldRetryNextAccount())
+ })
+ }
+}
+
// ---------------------------------------------------------------------------
// TestGeminiErrorPolicy_NilRateLimitService — verifies nil safety
// ---------------------------------------------------------------------------
diff --git a/backend/internal/service/gemini_messages_compat_service.go b/backend/internal/service/gemini_messages_compat_service.go
index 30f635643..09946ad1c 100644
--- a/backend/internal/service/gemini_messages_compat_service.go
+++ b/backend/internal/service/gemini_messages_compat_service.go
@@ -945,6 +945,9 @@ func (s *GeminiMessagesCompatService) Forward(ctx context.Context, c *gin.Contex
if upstreamReqID == "" {
upstreamReqID = resp.Header.Get("x-goog-request-id")
}
+ if failoverErr := s.poolModeSkippedFailoverError(c, account, resp.StatusCode, respBody, upstreamReqID); failoverErr != nil {
+ return nil, failoverErr
+ }
return nil, s.writeGeminiMappedError(c, account, http.StatusInternalServerError, upstreamReqID, respBody)
case ErrorPolicyMatched, ErrorPolicyTempUnscheduled:
if policy == ErrorPolicyMatched {
@@ -1452,6 +1455,9 @@ func (s *GeminiMessagesCompatService) ForwardNative(ctx context.Context, c *gin.
policy := s.rateLimitService.CheckErrorPolicy(ctx, account, resp.StatusCode, respBody, mappedModel)
switch policy {
case ErrorPolicySkipped:
+ if failoverErr := s.poolModeSkippedFailoverError(c, account, resp.StatusCode, respBody, requestID); failoverErr != nil {
+ return nil, failoverErr
+ }
respBody = unwrapIfNeeded(isOAuth, respBody)
contentType := resp.Header.Get("Content-Type")
if contentType == "" {
@@ -1683,6 +1689,39 @@ func (s *GeminiMessagesCompatService) shouldFailoverGeminiUpstreamError(statusCo
}
}
+// poolModeSkippedFailoverError 池模式账号命中 ErrorPolicySkipped 时构造 failover 错误：
+// 可 failover 的状态码返回 UpstreamFailoverError，交给 handler 层按 pool_mode_retry_count
+// 同账号重试后换号；返回 nil 表示不适用（非池模式或状态码不可 failover），由调用方透传。
+func (s *GeminiMessagesCompatService) poolModeSkippedFailoverError(c *gin.Context, account *Account, statusCode int, respBody []byte, upstreamRequestID string) *UpstreamFailoverError {
+ if !account.IsPoolMode() || !s.shouldFailoverGeminiUpstreamError(statusCode) {
+ return nil
+ }
+ upstreamMsg := sanitizeUpstreamErrorMessage(strings.TrimSpace(extractUpstreamErrorMessage(respBody)))
+ upstreamDetail := ""
+ if s.cfg != nil && s.cfg.Gateway.LogUpstreamErrorBody {
+ maxBytes := s.cfg.Gateway.LogUpstreamErrorBodyMaxBytes
+ if maxBytes <= 0 {
+ maxBytes = 2048
+ }
+ upstreamDetail = truncateString(string(respBody), maxBytes)
+ }
+ appendOpsUpstreamError(c, OpsUpstreamErrorEvent{
+ Platform: account.Platform,
+ AccountID: account.ID,
+ AccountName: account.Name,
+ UpstreamStatusCode: statusCode,
+ UpstreamRequestID: upstreamRequestID,
+ Kind: "failover",
+ Message: upstreamMsg,
+ Detail: upstreamDetail,
+ })
+ return &UpstreamFailoverError{
+ StatusCode: statusCode,
+ ResponseBody: respBody,
+ RetryableOnSameAccount: account.IsPoolModeRetryableStatus(statusCode),
+ }
+}
+
func sleepGeminiBackoff(attempt int) {
delay := geminiRetryBaseDelay * time.Duration(1< geminiRetryMaxDelay {
diff --git a/backend/internal/service/ollama_cloud_usage_test.go b/backend/internal/service/ollama_cloud_usage_test.go
index d315d7eb4..4b4a5aadb 100644
--- a/backend/internal/service/ollama_cloud_usage_test.go
+++ b/backend/internal/service/ollama_cloud_usage_test.go
@@ -36,6 +36,14 @@ type ollamaUsageTestRepo struct {
disableAutoAttempts atomic.Int64
disableAutoCalls atomic.Int64
groupResolveCalls atomic.Int64
+ getByIDCalls atomic.Int64
+}
+
+// GetByID counts loads so a test can wait for a caller to reach the point just
+// before the singleflight group, instead of guessing with a sleep.
+func (r *ollamaUsageTestRepo) GetByID(ctx context.Context, id int64) (*Account, error) {
+ r.getByIDCalls.Add(1)
+ return r.upstreamBillingProbeAccountRepo.GetByID(ctx, id)
}
func (r *ollamaUsageTestRepo) ListOllamaCloudUsageGroupAccounts(_ context.Context, anchors []*Account) ([]Account, error) {
@@ -805,7 +813,19 @@ func TestOllamaCloudUsageRefreshSingleflightAndRunnerDeduplicateSharedGroup(t *t
errs := make(chan error, 2)
go func() { _, err := svc.Refresh(context.Background(), first.ID); errs <- err }()
<-started
+ // The first caller is now parked in the stub, having loaded the account twice
+ // (once to build the group key, once inside the singleflight function).
+ loadsBeforeSecond := repo.getByIDCalls.Load()
go func() { _, err := svc.Refresh(context.Background(), second.ID); errs <- err }()
+ // Only release the first caller once the second one has loaded its own
+ // account, which happens immediately before it joins the singleflight group.
+ // Releasing right after starting the goroutine raced: if the first refresh
+ // finished first, the second became a fresh singleflight execution, re-read
+ // the account, saw the LastAttemptAt just written, and failed with the 30s
+ // manual-refresh 429 instead of sharing the in-flight result.
+ require.Eventually(t, func() bool {
+ return repo.getByIDCalls.Load() > loadsBeforeSecond
+ }, 5*time.Second, time.Millisecond, "the second caller must reach the singleflight group before the first is released")
close(release)
require.NoError(t, <-errs)
require.NoError(t, <-errs)
diff --git a/backend/internal/service/openai_gateway_grok_test.go b/backend/internal/service/openai_gateway_grok_test.go
index d13cfa19f..09a0df401 100644
--- a/backend/internal/service/openai_gateway_grok_test.go
+++ b/backend/internal/service/openai_gateway_grok_test.go
@@ -2006,6 +2006,37 @@ func TestAccountTestServiceGrokAPIKeyAllowsConfiguredHTTPWhenGlobalPolicyDoes(t
require.Contains(t, recorder.Body.String(), `"type":"test_complete"`)
}
+func TestAccountTestServiceGrokOAuthPaymentRequiredTemporarilyUnschedulesAccount(t *testing.T) {
+ gin.SetMode(gin.TestMode)
+
+ account := healthyGrokOAuthGatewayTestAccount(56, "access-token")
+ repo := &grokQuotaAccountRepo{}
+ upstream := &httpUpstreamRecorder{resp: &http.Response{
+ StatusCode: http.StatusPaymentRequired,
+ Header: http.Header{"Content-Type": []string{"application/json"}},
+ Body: io.NopCloser(strings.NewReader(`{"code":"personal-team-blocked:spending-limit"}`)),
+ }}
+ svc := &AccountTestService{
+ accountRepo: repo,
+ grokTokenProvider: NewGrokTokenProvider(repo, nil),
+ httpUpstream: upstream,
+ }
+ recorder := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(recorder)
+ c.Request = httptest.NewRequest(http.MethodPost, "/api/v1/admin/accounts/56/test", nil)
+ before := time.Now()
+
+ err := svc.testGrokAccountConnection(c, account, "grok")
+
+ require.Error(t, err)
+ require.Equal(t, 1, repo.tempUnschedCalls)
+ require.Equal(t, account.ID, repo.lastTempUnschedID)
+ require.Equal(t, "grok payment required", repo.lastTempUnschedReason)
+ require.WithinDuration(t, before.Add(30*time.Minute), repo.lastTempUnschedUntil, time.Second)
+ require.Contains(t, recorder.Body.String(), `"type":"error"`)
+ require.Contains(t, recorder.Body.String(), "Grok Responses API returned 402")
+}
+
func TestForwardAsChatCompletionsForGrokStreamingUsesRawXAIChatCompletions(t *testing.T) {
gin.SetMode(gin.TestMode)
diff --git a/backend/internal/service/openai_gateway_record_usage_test.go b/backend/internal/service/openai_gateway_record_usage_test.go
index d2eca05d7..f0dc78b74 100644
--- a/backend/internal/service/openai_gateway_record_usage_test.go
+++ b/backend/internal/service/openai_gateway_record_usage_test.go
@@ -1335,6 +1335,71 @@ func TestOpenAIGatewayServiceRecordUsage_UsesRequestedModelAndUpstreamModelMetad
require.Equal(t, 1, userRepo.deductCalls)
}
+func TestOpenAIGatewayServiceRecordUsage_PreservesChannelMappedUpstreamModel(t *testing.T) {
+ usageRepo := &openAIRecordUsageLogRepoStub{inserted: true}
+ userRepo := &openAIRecordUsageUserRepoStub{}
+ subRepo := &openAIRecordUsageSubRepoStub{}
+ svc := newOpenAIRecordUsageServiceForTest(usageRepo, userRepo, subRepo, nil)
+
+ err := svc.RecordUsage(context.Background(), &OpenAIRecordUsageInput{
+ Result: &OpenAIForwardResult{
+ RequestID: "openai_channel_mapping_models",
+ Model: "gpt-5.6-terra",
+ UpstreamModel: "gpt-5.6-terra",
+ Usage: OpenAIUsage{
+ InputTokens: 20,
+ OutputTokens: 10,
+ },
+ Duration: time.Second,
+ },
+ APIKey: &APIKey{ID: 10},
+ User: &User{ID: 20},
+ Account: &Account{ID: 30},
+ ChannelUsageFields: ChannelUsageFields{
+ OriginalModel: "gpt-5.6-sol",
+ ChannelMappedModel: "gpt-5.6-terra",
+ },
+ })
+
+ require.NoError(t, err)
+ require.NotNil(t, usageRepo.lastLog)
+ require.Equal(t, "gpt-5.6-sol", usageRepo.lastLog.RequestedModel)
+ require.Equal(t, "gpt-5.6-terra", usageRepo.lastLog.Model)
+ require.NotNil(t, usageRepo.lastLog.UpstreamModel)
+ require.Equal(t, "gpt-5.6-terra", *usageRepo.lastLog.UpstreamModel)
+}
+
+func TestOpenAIGatewayServiceRecordUsage_PreservesLoopedChannelAndAccountUpstreamModel(t *testing.T) {
+ usageRepo := &openAIRecordUsageLogRepoStub{inserted: true}
+ userRepo := &openAIRecordUsageUserRepoStub{}
+ subRepo := &openAIRecordUsageSubRepoStub{}
+ svc := newOpenAIRecordUsageServiceForTest(usageRepo, userRepo, subRepo, nil)
+
+ err := svc.RecordUsage(context.Background(), &OpenAIRecordUsageInput{
+ Result: &OpenAIForwardResult{
+ RequestID: "openai_looped_mapping_models",
+ Model: "gpt-5.6-terra",
+ UpstreamModel: "gpt-5.6-sol",
+ Usage: OpenAIUsage{InputTokens: 20, OutputTokens: 10},
+ Duration: time.Second,
+ },
+ APIKey: &APIKey{ID: 10},
+ User: &User{ID: 20},
+ Account: &Account{ID: 30},
+ ChannelUsageFields: ChannelUsageFields{
+ OriginalModel: "gpt-5.6-sol",
+ ChannelMappedModel: "gpt-5.6-terra",
+ },
+ })
+
+ require.NoError(t, err)
+ require.NotNil(t, usageRepo.lastLog)
+ require.Equal(t, "gpt-5.6-sol", usageRepo.lastLog.RequestedModel)
+ require.Equal(t, "gpt-5.6-terra", usageRepo.lastLog.Model)
+ require.NotNil(t, usageRepo.lastLog.UpstreamModel)
+ require.Equal(t, "gpt-5.6-sol", *usageRepo.lastLog.UpstreamModel)
+}
+
func TestOpenAIGatewayServiceRecordUsage_BillsMappedRequestsUsingRequestedModel(t *testing.T) {
usageRepo := &openAIRecordUsageLogRepoStub{inserted: true}
userRepo := &openAIRecordUsageUserRepoStub{}
diff --git a/backend/internal/service/openai_gateway_request_body.go b/backend/internal/service/openai_gateway_request_body.go
index 14520958f..fdd401911 100644
--- a/backend/internal/service/openai_gateway_request_body.go
+++ b/backend/internal/service/openai_gateway_request_body.go
@@ -156,6 +156,119 @@ func sanitizeEncryptedReasoningInputItem(item any) (next any, changed bool, keep
return inputItem, true, true
}
+// SanitizeOpenAICrossModeFailoverReasoning derives a failover attempt body from
+// the canonical request body by dropping provider-specific encrypted reasoning
+// input items in full (encrypted_content plus the coupled id/summary shape).
+//
+// This is the proactive counterpart to the reactive same-account
+// invalid_encrypted_content recovery in Forward: when a failover switches from an
+// OpenAI passthrough account (which forwards upstream-native encrypted reasoning,
+// e.g. Kiro) to a non-passthrough account (e.g. Bedrock Mantle) that rejects the
+// provider-specific reasoning IDs/shape, the whole reasoning item must go before
+// the request reaches the new upstream. Unlike trimOpenAIEncryptedReasoningItems,
+// which only strips the encrypted_content / null-content fields while preserving
+// the reasoning item's id and summary, this drops the entire item.
+//
+// The input slice is treated as immutable and is never mutated; a distinct slice
+// is returned only when changed is true.
+func SanitizeOpenAICrossModeFailoverReasoning(body []byte) (sanitized []byte, changed bool, err error) {
+ if len(body) == 0 {
+ return body, false, nil
+ }
+ if !gjson.GetBytes(body, "input").Exists() {
+ return body, false, nil
+ }
+ var decoded map[string]any
+ decoder := json.NewDecoder(bytes.NewReader(body))
+ decoder.UseNumber()
+ if err := decoder.Decode(&decoded); err != nil {
+ return body, false, fmt.Errorf("decode cross-mode failover body: %w", err)
+ }
+ if !dropOpenAIEncryptedReasoningInputItems(decoded) {
+ return body, false, nil
+ }
+ out, marshalErr := marshalOpenAIUpstreamJSON(decoded)
+ if marshalErr != nil {
+ return body, false, fmt.Errorf("serialize cross-mode failover body: %w", marshalErr)
+ }
+ return out, true, nil
+}
+
+// dropOpenAIEncryptedReasoningInputItems removes reasoning input items that carry
+// provider-specific encrypted_content in full — including their coupled id and
+// summary — and reports whether anything changed. Contrast with
+// trimOpenAIEncryptedReasoningItems, which only strips fields while keeping the
+// reasoning item skeleton.
+func dropOpenAIEncryptedReasoningInputItems(reqBody map[string]any) bool {
+ if len(reqBody) == 0 {
+ return false
+ }
+ inputValue, has := reqBody["input"]
+ if !has {
+ return false
+ }
+ switch input := inputValue.(type) {
+ case []any:
+ filtered := input[:0]
+ changed := false
+ for _, item := range input {
+ if isOpenAIEncryptedReasoningInputItem(item) {
+ changed = true
+ continue
+ }
+ filtered = append(filtered, item)
+ }
+ if !changed {
+ return false
+ }
+ if len(filtered) == 0 {
+ delete(reqBody, "input")
+ return true
+ }
+ reqBody["input"] = filtered
+ return true
+ case []map[string]any:
+ filtered := input[:0]
+ changed := false
+ for _, item := range input {
+ if isOpenAIEncryptedReasoningInputItem(item) {
+ changed = true
+ continue
+ }
+ filtered = append(filtered, item)
+ }
+ if !changed {
+ return false
+ }
+ if len(filtered) == 0 {
+ delete(reqBody, "input")
+ return true
+ }
+ reqBody["input"] = filtered
+ return true
+ case map[string]any:
+ if isOpenAIEncryptedReasoningInputItem(input) {
+ delete(reqBody, "input")
+ return true
+ }
+ return false
+ default:
+ return false
+ }
+}
+
+func isOpenAIEncryptedReasoningInputItem(item any) bool {
+ inputItem, ok := item.(map[string]any)
+ if !ok {
+ return false
+ }
+ if itemType, _ := inputItem["type"].(string); strings.TrimSpace(itemType) != "reasoning" {
+ return false
+ }
+ _, has := inputItem["encrypted_content"]
+ return has
+}
+
func IsOpenAIResponsesCompactPathForTest(c *gin.Context) bool {
return isOpenAIResponsesCompactPath(c)
}
diff --git a/backend/internal/service/openai_gateway_request_body_reasoning_test.go b/backend/internal/service/openai_gateway_request_body_reasoning_test.go
index 62a885511..ad14f4d8d 100644
--- a/backend/internal/service/openai_gateway_request_body_reasoning_test.go
+++ b/backend/internal/service/openai_gateway_request_body_reasoning_test.go
@@ -5,6 +5,7 @@ import (
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
+ "github.com/tidwall/gjson"
)
func TestTrimOpenAIEncryptedReasoningItems_ContentNull(t *testing.T) {
@@ -98,6 +99,53 @@ func TestTrimOpenAIEncryptedReasoningItems_NoReasoningItems(t *testing.T) {
assert.False(t, changed)
}
+func TestSanitizeOpenAICrossModeFailoverReasoning_DropsWholeEncryptedItem(t *testing.T) {
+ body := []byte(`{"model":"gpt-5.1","input":[` +
+ `{"type":"message","role":"user","content":"hi"},` +
+ `{"type":"reasoning","id":"rs_kiro_1","encrypted_content":"ENC","summary":[{"type":"summary_text","text":"t"}]},` +
+ `{"type":"message","role":"assistant","content":"yo"}` +
+ `]}`)
+
+ sanitized, changed, err := SanitizeOpenAICrossModeFailoverReasoning(body)
+ require.NoError(t, err)
+ require.True(t, changed)
+ // The whole reasoning item is gone — id and summary go with encrypted_content,
+ // unlike trimOpenAIEncryptedReasoningItems which keeps the skeleton.
+ require.NotContains(t, string(sanitized), "reasoning")
+ require.NotContains(t, string(sanitized), "rs_kiro_1")
+ require.NotContains(t, string(sanitized), "summary_text")
+ require.Equal(t, int64(2), gjson.GetBytes(sanitized, "input.#").Int())
+}
+
+func TestSanitizeOpenAICrossModeFailoverReasoning_NoEncryptedIsNoop(t *testing.T) {
+ body := []byte(`{"model":"gpt-5.1","input":[{"type":"reasoning","summary":[{"type":"summary_text","text":"t"}]}]}`)
+ sanitized, changed, err := SanitizeOpenAICrossModeFailoverReasoning(body)
+ require.NoError(t, err)
+ require.False(t, changed, "reasoning without encrypted_content must be preserved")
+ require.Equal(t, string(body), string(sanitized))
+}
+
+func TestSanitizeOpenAICrossModeFailoverReasoning_NoInputIsNoop(t *testing.T) {
+ body := []byte(`{"model":"gpt-5.1"}`)
+ sanitized, changed, err := SanitizeOpenAICrossModeFailoverReasoning(body)
+ require.NoError(t, err)
+ require.False(t, changed)
+ require.Equal(t, string(body), string(sanitized))
+}
+
+func TestSanitizeOpenAICrossModeFailoverReasoning_PreservesLargeIntegers(t *testing.T) {
+ body := []byte(`{"model":"gpt-5.1","input":[` +
+ `{"type":"reasoning","id":"rs_kiro_1","encrypted_content":"ENC"},` +
+ `{"type":"message","role":"user","content":"hi"}` +
+ `],"tools":[{"type":"function","function":{"name":"lookup","parameters":{"type":"object","properties":{"id":{"const":9007199254740993}}}}}]}`)
+
+ sanitized, changed, err := SanitizeOpenAICrossModeFailoverReasoning(body)
+ require.NoError(t, err)
+ require.True(t, changed)
+ require.Contains(t, string(sanitized), `"const":9007199254740993`,
+ "sanitization must not round JSON integers through float64")
+}
+
func TestTrimOpenAIEncryptedReasoningItems_ContentNullDropsBareSkeleton(t *testing.T) {
reqBody := map[string]any{
"input": []any{
diff --git a/backend/internal/service/openai_gateway_usage.go b/backend/internal/service/openai_gateway_usage.go
index 16429f740..124469833 100644
--- a/backend/internal/service/openai_gateway_usage.go
+++ b/backend/internal/service/openai_gateway_usage.go
@@ -256,7 +256,7 @@ func (s *OpenAIGatewayService) RecordUsage(ctx context.Context, input *OpenAIRec
RequestID: requestID,
Model: result.Model,
RequestedModel: requestedModel,
- UpstreamModel: optionalNonEqualStringPtr(result.UpstreamModel, result.Model),
+ UpstreamModel: optionalTrimmedStringPtr(result.UpstreamModel),
ServiceTier: result.ServiceTier,
ReasoningEffort: result.ReasoningEffort,
InboundEndpoint: optionalTrimmedStringPtr(input.InboundEndpoint),
diff --git a/backend/internal/service/openai_ws_forwarder.go b/backend/internal/service/openai_ws_forwarder.go
index d22bec21d..9c0869fbe 100644
--- a/backend/internal/service/openai_ws_forwarder.go
+++ b/backend/internal/service/openai_ws_forwarder.go
@@ -207,8 +207,9 @@ func (e *OpenAIWSClientCloseError) Reason() string {
// OpenAIWSIngressHooks 定义入站 WS 每个 turn 的生命周期回调。
type OpenAIWSIngressHooks struct {
- // InitialRequestModel 是首帧渠道映射前的请求模型，只用于 usage metadata
- // 的 reasoning effort 后缀推导，禁止用于上游请求或计费模型。
+ // InitialRequestModel is the client-facing model from the first frame,
+ // before channel or account mapping. Ingress modes preserve it for usage
+ // attribution while MapRequestModel determines the upstream model.
InitialRequestModel string
// MaxReasoningEffort limits explicit reasoning effort values for this WS session.
MaxReasoningEffort string
@@ -216,7 +217,10 @@ type OpenAIWSIngressHooks struct {
ReasoningEffortMappings []ReasoningEffortMapping
BeforeTurn func(turn int) error
BeforeRequest func(turn int, payload []byte, originalModel string) error
- AfterTurn func(turn int, result *OpenAIForwardResult, turnErr error)
+ // MapRequestModel resolves the current turn's client model to the model
+ // that must be written into the upstream response.create frame.
+ MapRequestModel func(turn int, originalModel string) (string, error)
+ AfterTurn func(turn int, result *OpenAIForwardResult, turnErr error)
}
func (s *OpenAIGatewayService) getOpenAIWSConnPool() *openAIWSConnPool {
diff --git a/backend/internal/service/openai_ws_forwarder_ingress.go b/backend/internal/service/openai_ws_forwarder_ingress.go
index c896ec794..3664ae8b2 100644
--- a/backend/internal/service/openai_ws_forwarder_ingress.go
+++ b/backend/internal/service/openai_ws_forwarder_ingress.go
@@ -163,7 +163,7 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient(
return rebuilt, nil
}
- parseClientPayload := func(raw []byte) (openAIWSClientPayload, error) {
+ parseClientPayload := func(turn int, raw []byte) (openAIWSClientPayload, error) {
trimmed := bytes.TrimSpace(raw)
if len(trimmed) == 0 {
return openAIWSClientPayload{}, NewOpenAIWSClientCloseError(coderws.StatusPolicyViolation, "empty websocket request payload", nil)
@@ -288,7 +288,17 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient(
normalized = rebuilt
}
}
- upstreamModel := normalizeOpenAIModelForUpstream(account, account.GetMappedModel(originalModel))
+ requestModel := originalModel
+ if hooks != nil && hooks.MapRequestModel != nil {
+ mappedModel, mapErr := hooks.MapRequestModel(turn, originalModel)
+ if mapErr != nil {
+ return openAIWSClientPayload{}, mapErr
+ }
+ if mappedModel = strings.TrimSpace(mappedModel); mappedModel != "" {
+ requestModel = mappedModel
+ }
+ }
+ upstreamModel := normalizeOpenAIModelForUpstream(account, account.GetMappedModel(requestModel))
if modelMissing || upstreamModel != originalModel {
next, setErr := applyPayloadMutation(normalized, "model", upstreamModel)
if setErr != nil {
@@ -412,7 +422,7 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient(
return payload, nil
}
- firstPayload, err := parseClientPayload(firstClientMessage)
+ firstPayload, err := parseClientPayload(1, firstClientMessage)
if err != nil {
return err
}
@@ -513,7 +523,13 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient(
}
grokCacheIdentity := ""
if account.Platform == PlatformGrok {
- grokCacheIdentity, err = resolveGrokWSCacheIdentity(c, account, grokCacheSeedPayload, currentBridgePayload.originalModel)
+ grokCacheIdentity, err = resolveGrokWSCacheIdentity(
+ c,
+ account,
+ grokCacheSeedPayload,
+ currentBridgePayload.payloadRaw,
+ currentBridgePayload.originalModel,
+ )
if err != nil {
return fmt.Errorf("resolve Grok websocket cache identity: %w", err)
}
@@ -573,7 +589,7 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient(
}
return fmt.Errorf("read client websocket request: %w", readErr)
}
- nextPayload, parseErr := parseClientPayload(nextClientMessage)
+ nextPayload, parseErr := parseClientPayload(turn+1, nextClientMessage)
if parseErr != nil {
return parseErr
}
@@ -792,7 +808,10 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient(
mappedModel := ""
var mappedModelBytes []byte
if originalModel != "" {
- mappedModel = normalizeOpenAIModelForUpstream(account, account.GetMappedModel(originalModel))
+ mappedModel = strings.TrimSpace(gjson.GetBytes(payload, "model").String())
+ if mappedModel == "" {
+ mappedModel = normalizeOpenAIModelForUpstream(account, account.GetMappedModel(originalModel))
+ }
needModelReplace = mappedModel != "" && mappedModel != originalModel
if needModelReplace {
mappedModelBytes = []byte(mappedModel)
@@ -1589,7 +1608,7 @@ func (s *OpenAIGatewayService) ProxyResponsesWebSocketFromClient(
return fmt.Errorf("read client websocket request: %w", readErr)
}
- nextPayload, parseErr := parseClientPayload(nextClientMessage)
+ nextPayload, parseErr := parseClientPayload(turn+1, nextClientMessage)
if parseErr != nil {
return parseErr
}
diff --git a/backend/internal/service/openai_ws_http_bridge.go b/backend/internal/service/openai_ws_http_bridge.go
index eb7943589..b2c7c67f6 100644
--- a/backend/internal/service/openai_ws_http_bridge.go
+++ b/backend/internal/service/openai_ws_http_bridge.go
@@ -286,7 +286,10 @@ func (s *OpenAIGatewayService) proxyOpenAIWSHTTPBridgeTurn(
needModelReplace := false
var mappedModelBytes []byte
if originalModel != "" {
- mappedModel = normalizeOpenAIModelForUpstream(account, account.GetMappedModel(originalModel))
+ mappedModel = strings.TrimSpace(gjson.GetBytes(body, "model").String())
+ if mappedModel == "" {
+ mappedModel = normalizeOpenAIModelForUpstream(account, account.GetMappedModel(originalModel))
+ }
needModelReplace = mappedModel != "" && mappedModel != originalModel
if needModelReplace {
mappedModelBytes = []byte(mappedModel)
@@ -487,12 +490,12 @@ func (s *OpenAIGatewayService) proxyOpenAIWSHTTPBridgeTurn(
return resultWithUsage(), terminalErr
}
-func resolveGrokWSCacheIdentity(c *gin.Context, account *Account, payload []byte, originalModel string) (string, error) {
- body, err := prepareOpenAIWSHTTPBridgeBody(payload)
+func resolveGrokWSCacheIdentity(c *gin.Context, account *Account, seedPayload, currentPayload []byte, originalModel string) (string, error) {
+ body, err := prepareOpenAIWSHTTPBridgeBody(seedPayload)
if err != nil {
return "", err
}
- upstreamModel := resolveGrokWSUpstreamModel(account, body, originalModel)
+ upstreamModel := resolveGrokWSUpstreamModel(account, currentPayload, originalModel)
body, err = patchGrokResponsesBody(body, upstreamModel)
if err != nil {
return "", err
@@ -502,7 +505,11 @@ func resolveGrokWSCacheIdentity(c *gin.Context, account *Account, payload []byte
func resolveGrokWSUpstreamModel(account *Account, body []byte, originalModel string) string {
upstreamModel := strings.TrimSpace(gjson.GetBytes(body, "model").String())
- if account != nil && originalModel != "" {
+ originalModel = strings.TrimSpace(originalModel)
+ // Shared ingress has already applied channel and account mappings when the
+ // body model differs from the client-facing model. Only resolve from the
+ // original model when the body still carries that original value.
+ if account != nil && originalModel != "" && (upstreamModel == "" || upstreamModel == originalModel) {
if mappedModel := normalizeOpenAIModelForUpstream(account, account.GetMappedModel(originalModel)); mappedModel != "" {
upstreamModel = mappedModel
}
diff --git a/backend/internal/service/openai_ws_http_bridge_test.go b/backend/internal/service/openai_ws_http_bridge_test.go
index 73f8d1f01..802146cd3 100644
--- a/backend/internal/service/openai_ws_http_bridge_test.go
+++ b/backend/internal/service/openai_ws_http_bridge_test.go
@@ -520,7 +520,7 @@ func TestProxyOpenAIWSHTTPBridgeTurnPromotesCodexAdditionalToolsForMixedCache(t
require.Empty(t, upstream.lastReq.Header.Get(grokClientToolCacheOptInHeader))
}
-func TestProxyResponsesWebSocketFromClientForGrokUsesXAIHTTPBridge(t *testing.T) {
+func TestProxyResponsesWebSocketFromClientForGrokUsesXAIHTTPBridgeAndPreservesMappedModels(t *testing.T) {
gin.SetMode(gin.TestMode)
bridgeResponse := func(responseID, requestID string, cachedTokens int) *http.Response {
@@ -594,7 +594,14 @@ func TestProxyResponsesWebSocketFromClientForGrokUsesXAIHTTPBridge(t *testing.T)
ginCtx.Request = req
ginCtx.Set("api_key", &APIKey{ID: 7101})
- errCh <- svc.ProxyResponsesWebSocketFromClient(r.Context(), ginCtx, conn, account, "access-token", firstMessage, nil)
+ errCh <- svc.ProxyResponsesWebSocketFromClient(r.Context(), ginCtx, conn, account, "access-token", firstMessage, &OpenAIWSIngressHooks{
+ MapRequestModel: func(_ int, originalModel string) (string, error) {
+ if originalModel == "channel-alias" {
+ return "grok-4.3", nil
+ }
+ return originalModel, nil
+ },
+ })
}))
defer wsServer.Close()
@@ -626,7 +633,7 @@ func TestProxyResponsesWebSocketFromClientForGrokUsesXAIHTTPBridge(t *testing.T)
require.Equal(t, "resp_grok_ws_1", gjson.GetBytes(completed, "response.id").String())
writeCtx, cancelWrite = context.WithTimeout(context.Background(), 3*time.Second)
- err = clientConn.Write(writeCtx, coderws.MessageText, []byte(`{"type":"response.create","generate":true,"model":"grok","stream":true,"previous_response_id":"resp_grok_ws_1","input":"second turn"}`))
+ err = clientConn.Write(writeCtx, coderws.MessageText, []byte(`{"type":"response.create","generate":true,"model":"channel-alias","stream":true,"previous_response_id":"resp_grok_ws_1","input":"second turn"}`))
cancelWrite()
require.NoError(t, err)
@@ -637,6 +644,7 @@ func TestProxyResponsesWebSocketFromClientForGrokUsesXAIHTTPBridge(t *testing.T)
require.Equal(t, "response.output_text.delta", gjson.GetBytes(delta, "type").String())
require.Equal(t, "response.completed", gjson.GetBytes(completed, "type").String())
require.Equal(t, "resp_grok_ws_2", gjson.GetBytes(completed, "response.id").String())
+ require.Equal(t, "channel-alias", gjson.GetBytes(completed, "response.model").String())
writeCtx, cancelWrite = context.WithTimeout(context.Background(), 3*time.Second)
err = clientConn.Write(writeCtx, coderws.MessageText, []byte(`{"type":"response.create","generate":true,"model":"grok-4.3","stream":true,"previous_response_id":"resp_grok_ws_2","input":"third turn with a different model"}`))
@@ -666,7 +674,7 @@ func TestProxyResponsesWebSocketFromClientForGrokUsesXAIHTTPBridge(t *testing.T)
require.Equal(t, "sub2api-grok/1.0", upstream.lastReq.Header.Get("User-Agent"))
require.Equal(t, grokCLIVersion, upstream.lastReq.Header.Get("X-Grok-Client-Version"))
require.Equal(t, "grok-4.5", gjson.GetBytes(upstream.bodies[0], "model").String())
- require.Equal(t, "grok-4.5", gjson.GetBytes(upstream.bodies[1], "model").String())
+ require.Equal(t, "grok-4.3", gjson.GetBytes(upstream.bodies[1], "model").String())
require.Equal(t, "grok-4.3", gjson.GetBytes(upstream.bodies[2], "model").String())
require.NotEmpty(t, gjson.GetBytes(upstream.lastBody, "prompt_cache_key").String())
require.Equal(t, gjson.GetBytes(upstream.lastBody, "prompt_cache_key").String(), upstream.lastReq.Header.Get(grokConversationIDHeader))
@@ -677,9 +685,10 @@ func TestProxyResponsesWebSocketFromClientForGrokUsesXAIHTTPBridge(t *testing.T)
secondIdentity := gjson.GetBytes(upstream.bodies[1], "prompt_cache_key").String()
thirdIdentity := gjson.GetBytes(upstream.bodies[2], "prompt_cache_key").String()
require.NotEmpty(t, firstIdentity)
- require.Equal(t, firstIdentity, secondIdentity)
+ require.NotEmpty(t, secondIdentity)
+ require.NotEqual(t, firstIdentity, secondIdentity)
require.NotEmpty(t, thirdIdentity)
- require.NotEqual(t, firstIdentity, thirdIdentity)
+ require.Equal(t, secondIdentity, thirdIdentity)
require.Equal(t, firstIdentity, upstream.requests[0].Header.Get(grokConversationIDHeader))
require.Equal(t, secondIdentity, upstream.requests[1].Header.Get(grokConversationIDHeader))
require.Equal(t, thirdIdentity, upstream.requests[2].Header.Get(grokConversationIDHeader))
diff --git a/backend/internal/service/openai_ws_v2/passthrough_relay.go b/backend/internal/service/openai_ws_v2/passthrough_relay.go
index 4dae079b5..8d98fc78a 100644
--- a/backend/internal/service/openai_ws_v2/passthrough_relay.go
+++ b/backend/internal/service/openai_ws_v2/passthrough_relay.go
@@ -7,6 +7,7 @@ import (
"net"
"strconv"
"strings"
+ "sync"
"sync/atomic"
"time"
@@ -86,6 +87,7 @@ type RelayTraceEvent struct {
type relayState struct {
usage Usage
+ requestModelMu sync.RWMutex
requestModel string
lastResponseID string
terminalEventType string
@@ -164,6 +166,12 @@ func Relay(
defer cancel()
return upstreamConn.WriteFrame(writeCtx, msgType, payload)
}
+ writeClientFrameUpstream := func(msgType coderws.MessageType, payload []byte) error {
+ if msgType == coderws.MessageText && strings.TrimSpace(gjson.GetBytes(payload, "type").String()) == "response.create" {
+ state.setRequestModel(strings.TrimSpace(gjson.GetBytes(payload, "model").String()))
+ }
+ return writeUpstream(msgType, payload)
+ }
writeClient := func(msgType coderws.MessageType, payload []byte) error {
writeCtx, cancel := context.WithTimeout(relayCtx, writeTimeout)
defer cancel()
@@ -215,7 +223,7 @@ func Relay(
if !clientReaderStarted.CompareAndSwap(false, true) {
return
}
- go runClientToUpstream(relayCtx, clientConn, options.ReadClientFrame, writeUpstream, markActivity, clientToUpstreamFrames, onTrace, exitCh)
+ go runClientToUpstream(relayCtx, clientConn, options.ReadClientFrame, writeClientFrameUpstream, markActivity, clientToUpstreamFrames, onTrace, exitCh)
}
if !options.StartClientAfterFirstDownstream {
startClientReader()
@@ -712,7 +720,7 @@ func emitTurnComplete(
}
requestModel := ""
if state != nil {
- requestModel = state.requestModel
+ requestModel = state.currentRequestModel()
}
onTurnComplete(RelayTurnResult{
RequestModel: requestModel,
@@ -873,13 +881,31 @@ func enrichResult(result *RelayResult, state *relayState, duration time.Duration
if state == nil {
return
}
- result.RequestModel = state.requestModel
+ result.RequestModel = state.currentRequestModel()
result.Usage = state.usage
result.RequestID = state.lastResponseID
result.TerminalEventType = state.terminalEventType
result.FirstTokenMs = state.firstTokenMs
}
+func (s *relayState) setRequestModel(model string) {
+ if s == nil || model == "" {
+ return
+ }
+ s.requestModelMu.Lock()
+ s.requestModel = model
+ s.requestModelMu.Unlock()
+}
+
+func (s *relayState) currentRequestModel() string {
+ if s == nil {
+ return ""
+ }
+ s.requestModelMu.RLock()
+ defer s.requestModelMu.RUnlock()
+ return s.requestModel
+}
+
func isDisconnectError(err error) bool {
if err == nil {
return false
diff --git a/backend/internal/service/openai_ws_v2/passthrough_relay_test.go b/backend/internal/service/openai_ws_v2/passthrough_relay_test.go
index a5d77fe0f..c083943bc 100644
--- a/backend/internal/service/openai_ws_v2/passthrough_relay_test.go
+++ b/backend/internal/service/openai_ws_v2/passthrough_relay_test.go
@@ -472,6 +472,56 @@ func TestRelay_OnTurnComplete_PerTerminalEvent(t *testing.T) {
require.Equal(t, 5, result.Usage.OutputTokens)
}
+func TestRelay_OnTurnComplete_UsesCurrentResponseCreateModel(t *testing.T) {
+ t.Parallel()
+
+ clientConn := newPassthroughTestFrameConn(nil, false)
+ upstreamConn := newPassthroughTestFrameConn(nil, false)
+ firstPayload := []byte(`{"type":"response.create","model":"gpt-5.6-sol","input":[]}`)
+
+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+ defer cancel()
+ turns := make(chan RelayTurnResult, 2)
+ done := make(chan struct{})
+ go func() {
+ defer close(done)
+ _, _ = Relay(ctx, clientConn, upstreamConn, firstPayload, RelayOptions{
+ OnTurnComplete: func(turn RelayTurnResult) {
+ turns <- turn
+ },
+ })
+ }()
+
+ upstreamConn.readCh <- passthroughTestFrame{
+ msgType: coderws.MessageText,
+ payload: []byte(`{"type":"response.completed","response":{"id":"resp_sol","usage":{"input_tokens":2,"output_tokens":1}}}`),
+ }
+ firstTurn := <-turns
+ require.Equal(t, "gpt-5.6-sol", firstTurn.RequestModel)
+
+ clientConn.readCh <- passthroughTestFrame{
+ msgType: coderws.MessageText,
+ payload: []byte(`{"type":"response.create","model":"gpt-5.6-terra","input":[]}`),
+ }
+ require.Eventually(t, func() bool {
+ return len(upstreamConn.Writes()) == 2
+ }, time.Second, 10*time.Millisecond)
+ upstreamConn.readCh <- passthroughTestFrame{
+ msgType: coderws.MessageText,
+ payload: []byte(`{"type":"response.completed","response":{"id":"resp_terra","usage":{"input_tokens":3,"output_tokens":1}}}`),
+ }
+ secondTurn := <-turns
+ require.Equal(t, "gpt-5.6-terra", secondTurn.RequestModel)
+
+ _ = clientConn.Close()
+ _ = upstreamConn.Close()
+ select {
+ case <-done:
+ case <-time.After(2 * time.Second):
+ t.Fatal("relay did not stop after client close")
+ }
+}
+
func TestRelay_OnTurnComplete_ProvidesTurnMetrics(t *testing.T) {
t.Parallel()
diff --git a/backend/internal/service/openai_ws_v2_passthrough_adapter.go b/backend/internal/service/openai_ws_v2_passthrough_adapter.go
index 934a35fcc..ae74027bc 100644
--- a/backend/internal/service/openai_ws_v2_passthrough_adapter.go
+++ b/backend/internal/service/openai_ws_v2_passthrough_adapter.go
@@ -25,6 +25,9 @@ type openAIWSClientFrameConn struct {
interTurnIdleTimeout time.Duration
interTurnStarted chan struct{}
waitingForNextTurn atomic.Bool
+ // The relay observes upstream payloads, while clients must keep seeing the
+ // model identifier they supplied for the current turn.
+ restoreResponseModel func([]byte) []byte
}
// openAIWSPolicyEnforcingFrameConn wraps a client-side FrameConn and runs
@@ -133,6 +136,8 @@ func openAIWSPassthroughPolicyModelFromSessionFrame(account *Account, payload []
type openAIWSPassthroughUsageMeta struct {
serviceTier atomic.Pointer[string]
reasoningEffort atomic.Pointer[string]
+ requestModel atomic.Pointer[string]
+ upstreamModel atomic.Pointer[string]
// 仅在 client->upstream filter goroutine 中读写；Load 侧通过上方原子指针同步。
sessionRequestModel string
@@ -154,6 +159,7 @@ func (m *openAIWSPassthroughUsageMeta) initFromFirstFrame(policyOutput []byte, m
}
m.serviceTier.Store(extractOpenAIServiceTierFromBody(policyOutput))
m.reasoningEffort.Store(extractOpenAIReasoningEffortFromBody(policyOutput, mappedModel, m.sessionRequestModel))
+ m.storeTurnModels(m.sessionRequestModel, policyOutput)
}
func (m *openAIWSPassthroughUsageMeta) updateSessionRequestModel(payload []byte) {
@@ -181,6 +187,51 @@ func (m *openAIWSPassthroughUsageMeta) updateFromResponseCreate(policyOutput []b
}
m.serviceTier.Store(extractOpenAIServiceTierFromBody(policyOutput))
m.reasoningEffort.Store(extractOpenAIReasoningEffortFromBody(policyOutput, mappedModel, requestModelForFrame))
+ m.storeTurnModels(requestModelForFrame, policyOutput)
+}
+
+func (m *openAIWSPassthroughUsageMeta) storeTurnModels(requestModel string, upstreamPayload []byte) {
+ if m == nil {
+ return
+ }
+ requestModel = strings.TrimSpace(requestModel)
+ upstreamModel := strings.TrimSpace(gjson.GetBytes(upstreamPayload, "model").String())
+ if upstreamModel == "" {
+ upstreamModel = requestModel
+ }
+ m.requestModel.Store(openAIWSTrimmedStringPtr(requestModel))
+ m.upstreamModel.Store(openAIWSTrimmedStringPtr(upstreamModel))
+}
+
+func (m *openAIWSPassthroughUsageMeta) turnModels(fallback string) (string, string) {
+ requestModel := strings.TrimSpace(fallback)
+ upstreamModel := requestModel
+ if m == nil {
+ return requestModel, upstreamModel
+ }
+ if current := m.requestModel.Load(); current != nil && strings.TrimSpace(*current) != "" {
+ requestModel = strings.TrimSpace(*current)
+ }
+ if current := m.upstreamModel.Load(); current != nil && strings.TrimSpace(*current) != "" {
+ upstreamModel = strings.TrimSpace(*current)
+ }
+ return requestModel, upstreamModel
+}
+
+func openAIWSTrimmedStringPtr(value string) *string {
+ value = strings.TrimSpace(value)
+ if value == "" {
+ return nil
+ }
+ return &value
+}
+
+func openAIWSDifferentModel(requestModel, upstreamModel string) string {
+ upstreamModel = strings.TrimSpace(upstreamModel)
+ if upstreamModel == "" || upstreamModel == strings.TrimSpace(requestModel) {
+ return ""
+ }
+ return upstreamModel
}
func openAIWSPassthroughRequestModelForFrame(payload []byte) string {
@@ -585,6 +636,9 @@ func (c *openAIWSClientFrameConn) WriteFrame(ctx context.Context, msgType coderw
if normalized, changed := normalizeCompletedImageGenerationStatus(payload); changed {
payload = normalized
}
+ if c.restoreResponseModel != nil {
+ payload = c.restoreResponseModel(payload)
+ }
}
return c.conn.Write(ctx, msgType, payload)
}
@@ -655,10 +709,25 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2Passthrough(
// negotiated at session.update time. Without this fallback, an empty
// model would miss any admin-configured model whitelist and be silently
// passed through, defeating that policy on every frame after the first.
- capturedSessionModel := openAIWSPassthroughPolicyModelForFrame(account, firstClientMessage)
initialRequestModel := ""
if hooks != nil {
- initialRequestModel = hooks.InitialRequestModel
+ initialRequestModel = strings.TrimSpace(hooks.InitialRequestModel)
+ }
+ if initialRequestModel == "" {
+ initialRequestModel = openAIWSPassthroughRequestModelForFrame(firstClientMessage)
+ }
+ if hooks != nil && hooks.MapRequestModel != nil {
+ mappedModel, mapErr := hooks.MapRequestModel(1, initialRequestModel)
+ if mapErr != nil {
+ return mapErr
+ }
+ if mappedModel = strings.TrimSpace(mappedModel); mappedModel != "" {
+ firstClientMessage = s.ReplaceModelInBody(firstClientMessage, mappedModel)
+ }
+ }
+ capturedSessionModel := openAIWSPassthroughPolicyModelForFrame(account, firstClientMessage)
+ if capturedSessionModel != "" && capturedSessionModel != strings.TrimSpace(gjson.GetBytes(firstClientMessage, "model").String()) {
+ firstClientMessage = s.ReplaceModelInBody(firstClientMessage, capturedSessionModel)
}
usageMeta := newOpenAIWSPassthroughUsageMeta(initialRequestModel, firstClientMessage)
updatedFirst, blocked, policyErr := s.applyOpenAIFastPolicyToWSResponseCreate(ctx, account, capturedSessionModel, firstClientMessage)
@@ -839,6 +908,14 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2Passthrough(
controlCtx: ctx,
interTurnIdleTimeout: s.openAIWSIngressInterTurnIdleTimeout(),
interTurnStarted: make(chan struct{}, 1),
+ restoreResponseModel: func(payload []byte) []byte {
+ eventType := strings.TrimSpace(gjson.GetBytes(payload, "type").String())
+ if !openAIWSEventMayContainModel(eventType) {
+ return payload
+ }
+ requestModel, upstreamModel := usageMeta.turnModels("")
+ return replaceOpenAIWSMessageModel(payload, upstreamModel, requestModel)
+ },
}
policyClientConn := &openAIWSPolicyEnforcingFrameConn{
inner: clientFrameConn,
@@ -878,17 +955,29 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2Passthrough(
}
}
}
- if isResponseCreate && hooks != nil && hooks.BeforeRequest != nil {
- turnNo := int(completedTurns.Load()) + 1
- if turnNo < 2 {
- turnNo = 2
+ turnNo := int(completedTurns.Load()) + 1
+ if turnNo < 2 {
+ turnNo = 2
+ }
+ requestModelForThisFrame := ""
+ if isResponseCreate {
+ requestModelForThisFrame = usageMeta.requestModelForFrame(payload)
+ if requestModelForThisFrame == "" {
+ requestModelForThisFrame = capturedSessionModel
}
- requestModel := usageMeta.requestModelForFrame(payload)
- if requestModel == "" {
- requestModel = capturedSessionModel
+ if hooks != nil && hooks.BeforeRequest != nil {
+ if err := hooks.BeforeRequest(turnNo, payload, requestModelForThisFrame); err != nil {
+ return payload, nil, err
+ }
}
- if err := hooks.BeforeRequest(turnNo, payload, requestModel); err != nil {
- return payload, nil, err
+ if hooks != nil && hooks.MapRequestModel != nil {
+ upstreamModel, err := hooks.MapRequestModel(turnNo, requestModelForThisFrame)
+ if err != nil {
+ return payload, nil, err
+ }
+ if upstreamModel = strings.TrimSpace(upstreamModel); upstreamModel != "" {
+ payload = s.ReplaceModelInBody(payload, upstreamModel)
+ }
}
}
// 在评估策略前先刷新 capturedSessionModel：客户端可能通过
@@ -902,7 +991,9 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2Passthrough(
capturedSessionModel = updated
}
usageMeta.updateSessionRequestModel(payload)
- requestModelForThisFrame := usageMeta.requestModelForFrame(payload)
+ if requestModelForThisFrame == "" {
+ requestModelForThisFrame = usageMeta.requestModelForFrame(payload)
+ }
// Per-frame model first; if the client omits "model" on a
// follow-up frame (legal in Realtime), fall back to the
// session-level model captured from the first frame so the
@@ -912,6 +1003,9 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2Passthrough(
if model == "" {
model = capturedSessionModel
}
+ if isResponseCreate && model != "" && model != strings.TrimSpace(gjson.GetBytes(payload, "model").String()) {
+ payload = s.ReplaceModelInBody(payload, model)
+ }
out, blocked, policyErr := s.applyOpenAIFastPolicyToWSResponseCreate(ctx, account, model, payload)
// 多轮 passthrough usage：仅在成功（non-block / non-err）
// 的 response.create 帧上更新 usageMeta，使用
@@ -999,6 +1093,7 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2Passthrough(
},
OnTurnComplete: func(turn openaiwsv2.RelayTurnResult) {
turnNo := int(completedTurns.Add(1))
+ turnRequestModel, turnUpstreamModel := usageMeta.turnModels(turn.RequestModel)
turnResult := &OpenAIForwardResult{
RequestID: turn.RequestID,
Usage: OpenAIUsage{
@@ -1008,7 +1103,8 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2Passthrough(
CacheReadInputTokens: turn.Usage.CacheReadInputTokens,
ImageOutputTokens: turn.Usage.ImageOutputTokens,
},
- Model: turn.RequestModel,
+ Model: turnRequestModel,
+ UpstreamModel: openAIWSDifferentModel(turnRequestModel, turnUpstreamModel),
ServiceTier: usageMeta.serviceTier.Load(),
ReasoningEffort: usageMeta.reasoningEffort.Load(),
Stream: true,
@@ -1019,11 +1115,13 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2Passthrough(
FirstTokenMs: turn.FirstTokenMs,
}
logOpenAIWSV2Passthrough(
- "relay_turn_completed account_id=%d turn=%d request_id=%s terminal_event=%s duration_ms=%d first_token_ms=%d input_tokens=%d output_tokens=%d cache_read_tokens=%d",
+ "relay_turn_completed account_id=%d turn=%d request_id=%s terminal_event=%s turn_requested_model=%s turn_upstream_model=%s duration_ms=%d first_token_ms=%d input_tokens=%d output_tokens=%d cache_read_tokens=%d",
account.ID,
turnNo,
truncateOpenAIWSLogValue(turnResult.RequestID, openAIWSIDValueMaxLen),
truncateOpenAIWSLogValue(turn.TerminalEventType, openAIWSLogValueMaxLen),
+ truncateOpenAIWSLogValue(turnRequestModel, openAIWSLogValueMaxLen),
+ truncateOpenAIWSLogValue(turnUpstreamModel, openAIWSLogValueMaxLen),
turnResult.Duration.Milliseconds(),
openAIWSFirstTokenMsForLog(turnResult.FirstTokenMs),
turnResult.Usage.InputTokens,
@@ -1114,6 +1212,7 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2Passthrough(
return NewOpenAIWSClientCloseError(status, reason, cause)
}
+ resultRequestModel, resultUpstreamModel := usageMeta.turnModels(relayResult.RequestModel)
result := &OpenAIForwardResult{
RequestID: relayResult.RequestID,
Usage: OpenAIUsage{
@@ -1123,7 +1222,8 @@ func (s *OpenAIGatewayService) proxyResponsesWebSocketV2Passthrough(
CacheReadInputTokens: relayResult.Usage.CacheReadInputTokens,
ImageOutputTokens: relayResult.Usage.ImageOutputTokens,
},
- Model: relayResult.RequestModel,
+ Model: resultRequestModel,
+ UpstreamModel: openAIWSDifferentModel(resultRequestModel, resultUpstreamModel),
ServiceTier: usageMeta.serviceTier.Load(),
ReasoningEffort: usageMeta.reasoningEffort.Load(),
Stream: true,
diff --git a/backend/internal/service/payment_service.go b/backend/internal/service/payment_service.go
index 3518fbe2e..792a842a2 100644
--- a/backend/internal/service/payment_service.go
+++ b/backend/internal/service/payment_service.go
@@ -144,28 +144,32 @@ type RefundResult struct {
}
type DashboardStats struct {
- TodayAmount float64 `json:"today_amount"`
- TotalAmount float64 `json:"total_amount"`
- TodayCount int `json:"today_count"`
- TotalCount int `json:"total_count"`
- AvgAmount float64 `json:"avg_amount"`
- PendingOrders int `json:"pending_orders"`
+ TodayAmount CurrencyAmounts `json:"today_amount"`
+ TotalAmount CurrencyAmounts `json:"total_amount"`
+ TodayCount int `json:"today_count"`
+ TotalCount int `json:"total_count"`
+ AvgAmount CurrencyAmounts `json:"avg_amount"`
+ PendingOrders int `json:"pending_orders"`
DailySeries []DailyStats `json:"daily_series"`
PaymentMethods []PaymentMethodStat `json:"payment_methods"`
- TopUsers []TopUserStat `json:"top_users"`
+ TopUsers TopUsersByCurrency `json:"top_users"`
}
+// CurrencyAmounts holds payment amounts keyed by their ISO 4217 currency.
+// Amounts in different currencies must never be added together.
+type CurrencyAmounts map[string]float64
+
type DailyStats struct {
- Date string `json:"date"`
- Amount float64 `json:"amount"`
- Count int `json:"count"`
+ Date string `json:"date"`
+ Amount CurrencyAmounts `json:"amount"`
+ Count int `json:"count"`
}
type PaymentMethodStat struct {
- Type string `json:"type"`
- Amount float64 `json:"amount"`
- Count int `json:"count"`
+ Type string `json:"type"`
+ Amount CurrencyAmounts `json:"amount"`
+ Count int `json:"count"`
}
type TopUserStat struct {
@@ -174,6 +178,10 @@ type TopUserStat struct {
Amount float64 `json:"amount"`
}
+// TopUsersByCurrency contains an independent ranked user list for each
+// currency. A single cross-currency leaderboard would be misleading.
+type TopUsersByCurrency map[string][]TopUserStat
+
// --- Service ---
type PaymentService struct {
diff --git a/backend/internal/service/payment_stats.go b/backend/internal/service/payment_stats.go
index d206b2717..9dc48e012 100644
--- a/backend/internal/service/payment_stats.go
+++ b/backend/internal/service/payment_stats.go
@@ -54,22 +54,27 @@ func (s *PaymentService) GetDashboardStats(ctx context.Context, days int) (*Dash
}
func computeBasicStats(st *DashboardStats, orders []*dbent.PaymentOrder, todayStart time.Time) {
- var totalAmount, todayAmount float64
+ st.TotalAmount = make(CurrencyAmounts)
+ st.TodayAmount = make(CurrencyAmounts)
+ st.AvgAmount = make(CurrencyAmounts)
+ currencyCounts := make(map[string]int)
var todayCount int
for _, o := range orders {
- totalAmount += o.PayAmount
+ currency := PaymentOrderCurrency(o)
+ st.TotalAmount[currency] += o.PayAmount
+ currencyCounts[currency]++
if o.PaidAt != nil && !o.PaidAt.Before(todayStart) {
- todayAmount += o.PayAmount
+ st.TodayAmount[currency] += o.PayAmount
todayCount++
}
}
- st.TotalAmount = math.Round(totalAmount*100) / 100
- st.TodayAmount = math.Round(todayAmount*100) / 100
st.TotalCount = len(orders)
st.TodayCount = todayCount
- if st.TotalCount > 0 {
- st.AvgAmount = math.Round(totalAmount/float64(st.TotalCount)*100) / 100
+ for currency, totalAmount := range st.TotalAmount {
+ st.AvgAmount[currency] = roundAmount(totalAmount / float64(currencyCounts[currency]))
}
+ roundCurrencyAmounts(st.TotalAmount)
+ roundCurrencyAmounts(st.TodayAmount)
}
func buildDailySeries(orders []*dbent.PaymentOrder, since time.Time, days int) []DailyStats {
@@ -81,20 +86,20 @@ func buildDailySeries(orders []*dbent.PaymentOrder, since time.Time, days int) [
date := o.PaidAt.Format("2006-01-02")
ds, ok := dailyMap[date]
if !ok {
- ds = &DailyStats{Date: date}
+ ds = &DailyStats{Date: date, Amount: make(CurrencyAmounts)}
dailyMap[date] = ds
}
- ds.Amount += o.PayAmount
+ ds.Amount[PaymentOrderCurrency(o)] += o.PayAmount
ds.Count++
}
series := make([]DailyStats, 0, days)
for i := 0; i < days; i++ {
date := since.AddDate(0, 0, i+1).Format("2006-01-02")
if ds, ok := dailyMap[date]; ok {
- ds.Amount = math.Round(ds.Amount*100) / 100
+ roundCurrencyAmounts(ds.Amount)
series = append(series, *ds)
} else {
- series = append(series, DailyStats{Date: date})
+ series = append(series, DailyStats{Date: date, Amount: make(CurrencyAmounts)})
}
}
return series
@@ -105,49 +110,71 @@ func buildMethodDistribution(orders []*dbent.PaymentOrder) []PaymentMethodStat {
for _, o := range orders {
ms, ok := methodMap[o.PaymentType]
if !ok {
- ms = &PaymentMethodStat{Type: o.PaymentType}
+ ms = &PaymentMethodStat{Type: o.PaymentType, Amount: make(CurrencyAmounts)}
methodMap[o.PaymentType] = ms
}
- ms.Amount += o.PayAmount
+ ms.Amount[PaymentOrderCurrency(o)] += o.PayAmount
ms.Count++
}
methods := make([]PaymentMethodStat, 0, len(methodMap))
for _, ms := range methodMap {
- ms.Amount = math.Round(ms.Amount*100) / 100
+ roundCurrencyAmounts(ms.Amount)
methods = append(methods, *ms)
}
+ sort.Slice(methods, func(i, j int) bool {
+ return methods[i].Type < methods[j].Type
+ })
return methods
}
-func buildTopUsers(orders []*dbent.PaymentOrder) []TopUserStat {
- userMap := make(map[int64]*TopUserStat)
+func buildTopUsers(orders []*dbent.PaymentOrder) TopUsersByCurrency {
+ userMap := make(map[string]map[int64]*TopUserStat)
for _, o := range orders {
- us, ok := userMap[o.UserID]
+ currency := PaymentOrderCurrency(o)
+ users, ok := userMap[currency]
+ if !ok {
+ users = make(map[int64]*TopUserStat)
+ userMap[currency] = users
+ }
+ us, ok := users[o.UserID]
if !ok {
us = &TopUserStat{UserID: o.UserID, Email: o.UserEmail}
- userMap[o.UserID] = us
+ users[o.UserID] = us
}
us.Amount += o.PayAmount
}
- userList := make([]*TopUserStat, 0, len(userMap))
- for _, us := range userMap {
- us.Amount = math.Round(us.Amount*100) / 100
- userList = append(userList, us)
- }
- sort.Slice(userList, func(i, j int) bool {
- return userList[i].Amount > userList[j].Amount
- })
- limit := topUsersLimit
- if len(userList) < limit {
- limit = len(userList)
- }
- result := make([]TopUserStat, 0, limit)
- for i := 0; i < limit; i++ {
- result = append(result, *userList[i])
+ result := make(TopUsersByCurrency, len(userMap))
+ for currency, users := range userMap {
+ userList := make([]*TopUserStat, 0, len(users))
+ for _, us := range users {
+ us.Amount = roundAmount(us.Amount)
+ userList = append(userList, us)
+ }
+ sort.Slice(userList, func(i, j int) bool {
+ return userList[i].Amount > userList[j].Amount
+ })
+ limit := topUsersLimit
+ if len(userList) < limit {
+ limit = len(userList)
+ }
+ result[currency] = make([]TopUserStat, 0, limit)
+ for i := 0; i < limit; i++ {
+ result[currency] = append(result[currency], *userList[i])
+ }
}
return result
}
+func roundCurrencyAmounts(amounts CurrencyAmounts) {
+ for currency, amount := range amounts {
+ amounts[currency] = roundAmount(amount)
+ }
+}
+
+func roundAmount(amount float64) float64 {
+ return math.Round(amount*100) / 100
+}
+
// --- Audit Logs ---
func (s *PaymentService) writeAuditLog(ctx context.Context, oid int64, action, op string, detail map[string]any) {
diff --git a/backend/internal/service/payment_stats_test.go b/backend/internal/service/payment_stats_test.go
new file mode 100644
index 000000000..267719288
--- /dev/null
+++ b/backend/internal/service/payment_stats_test.go
@@ -0,0 +1,84 @@
+//go:build unit
+
+package service
+
+import (
+ "testing"
+ "time"
+
+ dbent "github.com/Wei-Shaw/sub2api/ent"
+ "github.com/stretchr/testify/require"
+)
+
+func TestComputeBasicStatsGroupsAmountsByCurrency(t *testing.T) {
+ t.Parallel()
+
+ todayStart := time.Date(2026, time.July, 25, 0, 0, 0, 0, time.UTC)
+ yesterday := todayStart.Add(-time.Hour)
+ today := todayStart.Add(time.Hour)
+ orders := []*dbent.PaymentOrder{
+ paymentStatsTestOrder(1, "alice@example.com", "CNY", 10, &today),
+ paymentStatsTestOrder(2, "bob@example.com", "USD", 10, &today),
+ paymentStatsTestOrder(1, "alice@example.com", "CNY", 5, &yesterday),
+ }
+
+ stats := &DashboardStats{}
+ computeBasicStats(stats, orders, todayStart)
+
+ require.Equal(t, CurrencyAmounts{"CNY": 15, "USD": 10}, stats.TotalAmount)
+ require.Equal(t, CurrencyAmounts{"CNY": 10, "USD": 10}, stats.TodayAmount)
+ require.Equal(t, CurrencyAmounts{"CNY": 7.5, "USD": 10}, stats.AvgAmount)
+ require.Equal(t, 3, stats.TotalCount)
+ require.Equal(t, 2, stats.TodayCount)
+}
+
+func TestPaymentDashboardBreakdownsGroupAmountsAndRankingsByCurrency(t *testing.T) {
+ t.Parallel()
+
+ firstDay := time.Date(2026, time.July, 24, 12, 0, 0, 0, time.UTC)
+ secondDay := firstDay.AddDate(0, 0, 1)
+ orders := []*dbent.PaymentOrder{
+ paymentStatsTestOrder(1, "alice@example.com", "CNY", 5.555, &firstDay),
+ paymentStatsTestOrder(2, "bob@example.com", "CNY", 10, &firstDay),
+ paymentStatsTestOrder(1, "alice@example.com", "USD", 20, &secondDay),
+ paymentStatsTestOrder(2, "bob@example.com", "USD", 10, &secondDay),
+ }
+ orders[0].PaymentType = "stripe"
+ orders[1].PaymentType = "stripe"
+ orders[2].PaymentType = "stripe"
+ orders[3].PaymentType = "alipay"
+
+ daily := buildDailySeries(orders, firstDay.AddDate(0, 0, -1), 2)
+ require.Equal(t, []DailyStats{
+ {Date: "2026-07-24", Amount: CurrencyAmounts{"CNY": 15.56}, Count: 2},
+ {Date: "2026-07-25", Amount: CurrencyAmounts{"USD": 30}, Count: 2},
+ }, daily)
+
+ methods := buildMethodDistribution(orders)
+ require.Equal(t, []PaymentMethodStat{
+ {Type: "alipay", Amount: CurrencyAmounts{"USD": 10}, Count: 1},
+ {Type: "stripe", Amount: CurrencyAmounts{"CNY": 15.56, "USD": 20}, Count: 3},
+ }, methods)
+
+ users := buildTopUsers(orders)
+ require.Equal(t, TopUsersByCurrency{
+ "CNY": {
+ {UserID: 2, Email: "bob@example.com", Amount: 10},
+ {UserID: 1, Email: "alice@example.com", Amount: 5.56},
+ },
+ "USD": {
+ {UserID: 1, Email: "alice@example.com", Amount: 20},
+ {UserID: 2, Email: "bob@example.com", Amount: 10},
+ },
+ }, users)
+}
+
+func paymentStatsTestOrder(userID int64, email, currency string, amount float64, paidAt *time.Time) *dbent.PaymentOrder {
+ return &dbent.PaymentOrder{
+ UserID: userID,
+ UserEmail: email,
+ PayAmount: amount,
+ PaidAt: paidAt,
+ ProviderSnapshot: map[string]any{"currency": currency},
+ }
+}
diff --git a/backend/internal/service/pricing_service.go b/backend/internal/service/pricing_service.go
index 636bd690c..c969ec18d 100644
--- a/backend/internal/service/pricing_service.go
+++ b/backend/internal/service/pricing_service.go
@@ -695,16 +695,24 @@ func (s *PricingService) GetModelPricing(modelName string) *LiteLLMModelPricing
}
func (s *PricingService) buildModelLookupCandidates(modelLower string) []string {
- // Prefer canonical model name first (this also improves billing compatibility with "models/xxx").
- candidates := []string{
- normalizeModelNameForPricing(modelLower),
+ rawCandidates := []string{
modelLower,
- }
- candidates = append(candidates,
strings.TrimPrefix(modelLower, "models/"),
lastSegment(modelLower),
lastSegment(strings.TrimPrefix(modelLower, "models/")),
- )
+ }
+ normalized := normalizeModelNameForPricing(modelLower)
+
+ // A tier-specific entry should take precedence when the pricing catalog gains
+ // one later. Today Antigravity's Gemini 3.6 Flash tiers share the base rate,
+ // so the normalized base remains the fallback after the exact aliases.
+ candidates := rawCandidates
+ if normalizeGeminiThinkingTierAlias(lastSegment(modelLower)) != lastSegment(modelLower) {
+ candidates = append(candidates, normalized)
+ } else {
+ // Prefer canonical model names for all other aliases (including models/xxx).
+ candidates = append([]string{normalized}, candidates...)
+ }
seen := make(map[string]struct{}, len(candidates))
out := make([]string, 0, len(candidates))
@@ -752,6 +760,20 @@ func normalizeModelNameForPricing(model string) string {
}
return canonical
}
+ return normalizeGeminiThinkingTierAlias(model)
+}
+
+// normalizeGeminiThinkingTierAlias maps Antigravity's Gemini 3.6 Flash
+// thinking-tier model IDs to the public base model. The tier controls reasoning
+// behavior, not the published token rate, so this keeps -high/-low/-medium and
+// -tiered requests on the same price card as gemini-3.6-flash.
+func normalizeGeminiThinkingTierAlias(model string) string {
+ const baseModel = "gemini-3.6-flash"
+ for _, tier := range []string{"-high", "-low", "-medium", "-tiered"} {
+ if model == baseModel+tier {
+ return baseModel
+ }
+ }
return model
}
diff --git a/backend/internal/service/pricing_service_test.go b/backend/internal/service/pricing_service_test.go
index 88553f0fb..48e5159ad 100644
--- a/backend/internal/service/pricing_service_test.go
+++ b/backend/internal/service/pricing_service_test.go
@@ -454,6 +454,83 @@ func TestGetModelPricing_OpenAICompactAliasUsesStaticFallback(t *testing.T) {
require.InDelta(t, 1.5e-5, got.OutputCostPerToken, 1e-12)
}
+func TestPricingService_Gemini36FlashThinkingTiersUseBasePricing(t *testing.T) {
+ basePricing := &LiteLLMModelPricing{
+ InputCostPerToken: 1.5e-6,
+ OutputCostPerToken: 7.5e-6,
+ CacheReadInputTokenCost: 0.15e-6,
+ }
+ svc := &PricingService{pricingData: map[string]*LiteLLMModelPricing{
+ "gemini-3.6-flash": basePricing,
+ }}
+
+ for _, model := range []string{
+ "gemini-3.6-flash",
+ "gemini-3.6-flash-high",
+ "gemini-3.6-flash-low",
+ "gemini-3.6-flash-medium",
+ "gemini-3.6-flash-tiered",
+ } {
+ t.Run(model, func(t *testing.T) {
+ require.Same(t, basePricing, svc.GetModelPricing(model))
+ })
+ }
+}
+
+func TestPricingService_Gemini36FlashTierSpecificPricingTakesPrecedence(t *testing.T) {
+ basePricing := &LiteLLMModelPricing{InputCostPerToken: 1.5e-6}
+ tierPricing := &LiteLLMModelPricing{InputCostPerToken: 2e-6}
+ svc := &PricingService{pricingData: map[string]*LiteLLMModelPricing{
+ "gemini-3.6-flash": basePricing,
+ "gemini-3.6-flash-low": tierPricing,
+ }}
+
+ require.Same(t, tierPricing, svc.GetModelPricing("models/gemini-3.6-flash-low"))
+}
+
+func TestBillingService_Gemini36FlashThinkingTierFallbacksAreBillable(t *testing.T) {
+ svc := NewBillingService(&config.Config{}, nil)
+ tokens := UsageTokens{InputTokens: 1_000_000, OutputTokens: 1_000_000, CacheReadTokens: 1_000_000}
+
+ for _, model := range []string{
+ "gemini-3.6-flash",
+ "gemini-3.6-flash-high",
+ "gemini-3.6-flash-low",
+ "gemini-3.6-flash-medium",
+ "gemini-3.6-flash-tiered",
+ } {
+ t.Run(model, func(t *testing.T) {
+ cost, err := svc.CalculateCost(model, tokens, 1)
+ require.NoError(t, err)
+ require.InDelta(t, 1.5, cost.InputCost, 1e-12)
+ require.InDelta(t, 7.5, cost.OutputCost, 1e-12)
+ require.InDelta(t, 0.15, cost.CacheReadCost, 1e-12)
+ require.InDelta(t, 9.15, cost.TotalCost, 1e-12)
+ })
+ }
+}
+
+func TestDefaultPricingIncludesGemini36FlashRates(t *testing.T) {
+ data, err := os.ReadFile(filepath.Join("..", "..", "resources", "model-pricing", "model_prices_and_context_window.json"))
+ require.NoError(t, err)
+
+ pricingSvc := &PricingService{}
+ pricingData, err := pricingSvc.parsePricingData(data)
+ require.NoError(t, err)
+ pricingSvc.pricingData = pricingData
+ billingSvc := NewBillingService(&config.Config{}, pricingSvc)
+
+ for _, model := range []string{"gemini-3.6-flash", "gemini-3.6-flash-low", "gemini-3.6-flash-high"} {
+ t.Run(model, func(t *testing.T) {
+ pricing, err := billingSvc.GetModelPricing(model)
+ require.NoError(t, err)
+ require.InDelta(t, 1.5e-6, pricing.InputPricePerToken, 1e-12)
+ require.InDelta(t, 7.5e-6, pricing.OutputPricePerToken, 1e-12)
+ require.InDelta(t, 0.15e-6, pricing.CacheReadPricePerToken, 1e-12)
+ })
+ }
+}
+
func TestDefaultPricingIncludesCodexAutoReview(t *testing.T) {
data, err := os.ReadFile(filepath.Join("..", "..", "resources", "model-pricing", "model_prices_and_context_window.json"))
require.NoError(t, err)
diff --git a/backend/internal/service/setting_update.go b/backend/internal/service/setting_update.go
index 7449a3de6..2364b8948 100644
--- a/backend/internal/service/setting_update.go
+++ b/backend/internal/service/setting_update.go
@@ -5,6 +5,7 @@ import (
"encoding/json"
"errors"
"fmt"
+ "log/slog"
"math"
"strconv"
"strings"
@@ -15,22 +16,50 @@ import (
infraerrors "github.com/Wei-Shaw/sub2api/internal/pkg/errors"
)
+// OmittedSettingKeys marks setting keys the caller's payload never carried.
+// SystemSettings is a plain struct, so a field the caller omitted arrives as a
+// zero value and is indistinguishable from a deliberate clear. Listing the key
+// here drops it from the write, leaving the stored value in place.
+//
+// A nil or empty set keeps whole-document semantics: every key is written.
+type OmittedSettingKeys map[string]struct{}
+
+func (o OmittedSettingKeys) dropFrom(updates map[string]string) {
+ for key := range o {
+ delete(updates, key)
+ }
+}
+
// UpdateSettings 更新系统设置
func (s *SettingService) UpdateSettings(ctx context.Context, settings *SystemSettings) error {
+ return s.UpdateSettingsOmitting(ctx, settings, nil)
+}
+
+// UpdateSettingsOmitting persists system settings, leaving the keys in omitted
+// at their stored value.
+func (s *SettingService) UpdateSettingsOmitting(ctx context.Context, settings *SystemSettings, omitted OmittedSettingKeys) error {
updates, err := s.buildSystemSettingsUpdates(ctx, settings)
if err != nil {
return err
}
+ omitted.dropFrom(updates)
- err = s.settingRepo.SetMultiple(ctx, updates)
- if err == nil {
- s.refreshCachedSettings(settings)
+ if err := s.settingRepo.SetMultiple(ctx, updates); err != nil {
+ return err
}
- return err
+ s.refreshCachedSettingsAfterWrite(ctx, settings, omitted)
+ return nil
}
// UpdateSettingsWithAuthSourceDefaults persists system settings and auth-source defaults in a single write.
func (s *SettingService) UpdateSettingsWithAuthSourceDefaults(ctx context.Context, settings *SystemSettings, authDefaults *AuthSourceDefaultSettings) error {
+ return s.UpdateSettingsWithAuthSourceDefaultsOmitting(ctx, settings, authDefaults, nil)
+}
+
+// UpdateSettingsWithAuthSourceDefaultsOmitting persists system settings and
+// auth-source defaults in a single write, leaving the keys in omitted at their
+// stored value.
+func (s *SettingService) UpdateSettingsWithAuthSourceDefaultsOmitting(ctx context.Context, settings *SystemSettings, authDefaults *AuthSourceDefaultSettings, omitted OmittedSettingKeys) error {
updates, err := s.buildSystemSettingsUpdates(ctx, settings)
if err != nil {
return err
@@ -43,12 +72,30 @@ func (s *SettingService) UpdateSettingsWithAuthSourceDefaults(ctx context.Contex
for key, value := range authSourceUpdates {
updates[key] = value
}
+ omitted.dropFrom(updates)
- err = s.settingRepo.SetMultiple(ctx, updates)
- if err == nil {
- s.refreshCachedSettings(settings)
+ if err := s.settingRepo.SetMultiple(ctx, updates); err != nil {
+ return err
}
- return err
+ s.refreshCachedSettingsAfterWrite(ctx, settings, omitted)
+ return nil
+}
+
+// refreshCachedSettingsAfterWrite keeps the in-process caches in step with the
+// write that just landed. A partial payload carries zero values for the fields
+// it omitted, so in that case the caches are rebuilt from storage rather than
+// from the request struct.
+func (s *SettingService) refreshCachedSettingsAfterWrite(ctx context.Context, settings *SystemSettings, omitted OmittedSettingKeys) {
+ if len(omitted) == 0 {
+ s.refreshCachedSettings(settings)
+ return
+ }
+ stored, err := s.GetAllSettings(ctx)
+ if err != nil {
+ slog.Warn("refresh cached settings after partial update failed", "error", err)
+ return
+ }
+ s.refreshCachedSettings(stored)
}
func (s *SettingService) buildSystemSettingsUpdates(ctx context.Context, settings *SystemSettings) (map[string]string, error) {
diff --git a/backend/internal/service/token_refresh_pool_health_test.go b/backend/internal/service/token_refresh_pool_health_test.go
index f4950d879..a9bd760d9 100644
--- a/backend/internal/service/token_refresh_pool_health_test.go
+++ b/backend/internal/service/token_refresh_pool_health_test.go
@@ -630,7 +630,29 @@ func TestTokenRefreshService_SaturatedProviderPreservesConcurrencyAndActualQPSSt
starts := refresher.startsSnapshot()
require.Len(t, starts, attemptCount)
configuredSpacing := time.Second / time.Duration(providerQPS)
- minimumObservedSpacing := configuredSpacing - 10*time.Millisecond
+
+ // The floor is a tenth of the configured spacing, not spacing minus a few
+ // milliseconds. Each start timestamp is taken after the rate gate releases
+ // the goroutine, so scheduler delay can compress one observed gap without
+ // the gate having done anything wrong: this assertion failed on a loaded
+ // machine at 13ms and again at 37ms against a 40ms floor, both times with
+ // the gate pacing correctly.
+ //
+ // A tenth still separates the two cases by a wide margin. Measured with
+ // providerQPS=20 (50ms spacing), 8 attempts, providerConcurrency=2:
+ //
+ // gate at 50ms -> minimum observed gap 49.97ms
+ // gate at 0 -> minimum observed gap 22µs
+ //
+ // So an unpaced gate lands three orders of magnitude below the 5ms floor
+ // and is still caught, while jitter on a busy machine has room to move.
+ //
+ // Do not swap this for an assertion on the total span of the starts: the
+ // span is dominated by how long each attempt takes under
+ // providerConcurrency, not by the gate. Same measurement — 471ms paced
+ // against 241ms unpaced — so a span check passes with the gate disabled and
+ // tests nothing.
+ minimumObservedSpacing := configuredSpacing / 10
actualMinimumSpacing := starts[1].Sub(starts[0])
for i := 1; i < len(starts); i++ {
spacing := starts[i].Sub(starts[i-1])
diff --git a/backend/internal/service/usage_log_helpers.go b/backend/internal/service/usage_log_helpers.go
index 7cc8a713c..b431b50ae 100644
--- a/backend/internal/service/usage_log_helpers.go
+++ b/backend/internal/service/usage_log_helpers.go
@@ -10,16 +10,6 @@ func optionalTrimmedStringPtr(raw string) *string {
return &trimmed
}
-// optionalNonEqualStringPtr returns a pointer to value if it is non-empty and
-// differs from compare; otherwise nil. Used to store upstream_model only when
-// it differs from the requested model.
-func optionalNonEqualStringPtr(value, compare string) *string {
- if value == "" || value == compare {
- return nil
- }
- return &value
-}
-
func forwardResultBillingModel(requestedModel, upstreamModel string) string {
if trimmed := strings.TrimSpace(requestedModel); trimmed != "" {
return trimmed
diff --git a/backend/resources/model-pricing/model_prices_and_context_window.json b/backend/resources/model-pricing/model_prices_and_context_window.json
index 8c3e95aab..21180fb56 100644
--- a/backend/resources/model-pricing/model_prices_and_context_window.json
+++ b/backend/resources/model-pricing/model_prices_and_context_window.json
@@ -2339,6 +2339,23 @@
"supports_web_search": true,
"web_search_billing_unit": "per_query"
},
+ "gemini-3.6-flash": {
+ "cache_read_input_token_cost": 1.5e-07,
+ "cache_read_input_token_cost_priority": 2.7e-07,
+ "input_cost_per_token": 1.5e-06,
+ "input_cost_per_token_priority": 2.7e-06,
+ "litellm_provider": "vertex_ai-language-models",
+ "max_input_tokens": 1048576,
+ "max_output_tokens": 65536,
+ "max_tokens": 65536,
+ "mode": "chat",
+ "output_cost_per_token": 7.5e-06,
+ "output_cost_per_token_priority": 1.35e-05,
+ "source": "https://ai.google.dev/gemini-api/docs/latest-model",
+ "supports_prompt_caching": true,
+ "supports_reasoning": true,
+ "supports_service_tier": true
+ },
"gemini-embedding-001": {
"input_cost_per_token": 1.5e-07,
"litellm_provider": "vertex_ai-embedding-models",
diff --git a/deploy/Caddyfile b/deploy/Caddyfile
index 079b5f07e..77e1bf4c5 100644
--- a/deploy/Caddyfile
+++ b/deploy/Caddyfile
@@ -67,7 +67,14 @@ api.sub2api.com {
gzip 6
minimum_length 256
match {
- header Content-Type text/*
+ # 不使用 text/*，否则 text/event-stream 会被压缩并缓冲到流结束
+ header Content-Type text/css*
+ header Content-Type text/csv*
+ header Content-Type text/html*
+ header Content-Type text/javascript*
+ header Content-Type text/markdown*
+ header Content-Type text/plain*
+ header Content-Type text/xml*
header Content-Type application/json*
header Content-Type application/javascript*
header Content-Type application/xml*
diff --git a/deploy/EDGE_SECURITY.md b/deploy/EDGE_SECURITY.md
index 956507c4f..5e9ab10fb 100644
--- a/deploy/EDGE_SECURITY.md
+++ b/deploy/EDGE_SECURITY.md
@@ -128,6 +128,20 @@ server {
}
```
+If Nginx gzip is enabled in the `http` block, keep `text/event-stream` out of
+`gzip_types` and do not use `gzip_types *` for Sub2API. The
+`proxy_buffering off` setting above prevents proxy buffering, but it does not
+disable the gzip response filter. Use an explicit list for ordinary responses:
+
+```nginx
+gzip on;
+gzip_types text/plain text/css application/json application/javascript application/xml image/svg+xml;
+```
+
+If a shared global configuration cannot exclude SSE by content type, set
+`gzip off;` in the locations serving streaming API routes. This leaves gzip
+available for the web UI and static assets.
+
Do not use an incoming `$http_x_forwarded_for` value unless Nginx real-IP
processing is restricted to explicit trusted proxy CIDRs.
@@ -140,6 +154,17 @@ the TCP peer. It is therefore a direct-to-Caddy baseline. Do not use its
attributed to a CDN egress address, collapsing rejection aggregation and the
invalid-auth limiter onto unrelated users.
+The bundled Caddy configuration leaves `flush_interval` unset so Caddy can
+automatically flush `text/event-stream` responses while still propagating
+client cancellation upstream. Do not set it globally: positive values can add
+streaming latency, while Caddy 2.6.2's special `-1` mode also causes
+reverse-proxied requests to continue after clients disconnect. The
+configuration uses an explicit response content-type list for compression. Do
+not replace that list with `text/*` or the shorthand `encode gzip zstd`: both
+match `text/event-stream` and can buffer SSE until the response ends. Keep
+streaming responses uncompressed while retaining compression for the web UI,
+JSON, and static assets.
+
For a CDN deployment, first firewall the origin so only current CDN egress
CIDRs can connect. Then configure those exact ranges as Caddy trusted proxies
and derive upstream headers from Caddy's parsed `{client_ip}`. For example:
diff --git a/deploy/test-caddyfile-cache.sh b/deploy/test-caddyfile-cache.sh
index 789e48ee2..41e5e255c 100755
--- a/deploy/test-caddyfile-cache.sh
+++ b/deploy/test-caddyfile-cache.sh
@@ -4,15 +4,82 @@ set -eu
repo_root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
caddyfile="$repo_root/deploy/Caddyfile"
active_config=$(sed 's/[[:space:]]*#.*$//' "$caddyfile")
+normalized_config=$(printf '%s\n' "$active_config" | awk '
+ NF > 0 {
+ for (field = 1; field <= NF; field++) {
+ token = $field
+ sub(/^["`]/, "", token)
+ sub(/["`]$/, "", token)
+ printf "%s%s", (field == 1 ? "" : " "), token
+ }
+ print ""
+ }
+')
-if printf '%s\n' "$active_config" | grep -Eiq 'Cache-Control.*immutable'; then
+# Keep one canonical encode block instead of reimplementing Caddy matcher semantics.
+expected_encode_block=$(cat <<'EOF'
+encode {
+zstd
+gzip 6
+minimum_length 256
+match {
+header Content-Type text/css*
+header Content-Type text/csv*
+header Content-Type text/html*
+header Content-Type text/javascript*
+header Content-Type text/markdown*
+header Content-Type text/plain*
+header Content-Type text/xml*
+header Content-Type application/json*
+header Content-Type application/javascript*
+header Content-Type application/xml*
+header Content-Type application/rss+xml*
+header Content-Type image/svg+xml*
+}
+}
+EOF
+)
+
+if printf '%s\n' "$normalized_config" | grep -Eiq 'cache-control.*immutable'; then
echo "Caddyfile must not force immutable caching; the backend owns asset cache policy" >&2
exit 1
fi
-if ! printf '%s\n' "$active_config" | grep -Eq '^[[:space:]]*reverse_proxy[[:space:]]+localhost:8080'; then
+if ! printf '%s\n' "$normalized_config" | grep -Eq '^reverse_proxy localhost:8080([[:space:]]|$)'; then
echo "Caddyfile must continue proxying all application routes to localhost:8080" >&2
exit 1
fi
-echo "Caddyfile preserves backend Cache-Control policy and reverse_proxy routing"
+if printf '%s\n' "$normalized_config" | grep -Eq '^import([[:space:]]|$)'; then
+ echo "Caddyfile must not import configuration outside this canonical policy check" >&2
+ exit 1
+fi
+
+if printf '%s\n' "$normalized_config" | grep -Eiq '^flush_interval([[:space:]]|$)'; then
+ echo "Caddyfile must leave flush_interval unset so SSE auto-flushing and client cancellation remain intact" >&2
+ exit 1
+fi
+
+encode_directive_count=$(printf '%s\n' "$normalized_config" | awk '$1 == "encode" { count++ } END { print count + 0 }')
+if [ "$encode_directive_count" -ne 1 ]; then
+ echo "Caddyfile must contain exactly one explicit encode block" >&2
+ exit 1
+fi
+
+actual_encode_block=$(printf '%s\n' "$normalized_config" | awk '
+ $1 == "encode" { in_block = 1 }
+ in_block {
+ print
+ for (field = 1; field <= NF; field++) {
+ if ($field == "{") depth++
+ if ($field == "}") depth--
+ }
+ if (depth == 0) exit
+ }
+')
+if [ "$actual_encode_block" != "$expected_encode_block" ]; then
+ echo "Caddyfile encode block must keep the canonical non-SSE compression policy" >&2
+ exit 1
+fi
+
+echo "Caddyfile preserves backend cache policy, SSE streaming, and non-SSE compression"
diff --git a/frontend/src/components/admin/payment/DailyRevenueChart.vue b/frontend/src/components/admin/payment/DailyRevenueChart.vue
index 77583da17..6e2544f99 100644
--- a/frontend/src/components/admin/payment/DailyRevenueChart.vue
+++ b/frontend/src/components/admin/payment/DailyRevenueChart.vue
@@ -33,31 +33,43 @@ import {
} from 'chart.js'
import { Line } from 'vue-chartjs'
import LoadingSpinner from '@/components/common/LoadingSpinner.vue'
+import type { DailyPaymentStats } from '@/types/payment'
ChartJS.register(CategoryScale, LinearScale, PointElement, LineElement, Tooltip, Legend, Filler)
const { t } = useI18n()
const props = defineProps<{
- data: { date: string; amount: number; count: number }[]
+ data: DailyPaymentStats[]
loading?: boolean
}>()
+const colors = [
+ ['rgb(59, 130, 246)', 'rgba(59, 130, 246, 0.1)'],
+ ['rgb(168, 85, 247)', 'rgba(168, 85, 247, 0.1)'],
+ ['rgb(245, 158, 11)', 'rgba(245, 158, 11, 0.1)'],
+ ['rgb(239, 68, 68)', 'rgba(239, 68, 68, 0.1)'],
+]
+
const chartData = computed(() => {
if (!props.data || props.data.length === 0) return null
+ const currencies = [...new Set(props.data.flatMap(day => Object.keys(day.amount)))].sort()
return {
labels: props.data.map(d => d.date),
datasets: [
- {
- label: t('payment.admin.revenue'),
- data: props.data.map(d => d.amount),
- borderColor: 'rgb(59, 130, 246)',
- backgroundColor: 'rgba(59, 130, 246, 0.1)',
- fill: true,
- tension: 0.3,
- pointRadius: 3,
- pointHoverRadius: 5,
- },
+ ...currencies.map((currency, index) => {
+ const [borderColor, backgroundColor] = colors[index % colors.length]
+ return {
+ label: `${currency} ${t('payment.admin.revenue')}`,
+ data: props.data.map(day => day.amount[currency] || 0),
+ borderColor,
+ backgroundColor,
+ fill: true,
+ tension: 0.3,
+ pointRadius: 3,
+ pointHoverRadius: 5,
+ }
+ }),
{
label: t('payment.admin.orderCount'),
data: props.data.map(d => d.count),
diff --git a/frontend/src/components/admin/payment/OrderStatsCards.vue b/frontend/src/components/admin/payment/OrderStatsCards.vue
index 0f7ec956d..1fece5fb5 100644
--- a/frontend/src/components/admin/payment/OrderStatsCards.vue
+++ b/frontend/src/components/admin/payment/OrderStatsCards.vue
@@ -8,7 +8,9 @@
{{ t('payment.admin.todayRevenue') }}
-
${{ formatMoney(stats.today_amount) }}
+
+ {{ formatMoney(currency, amount) }}
+
{{ stats.today_count }} {{ t('payment.admin.orders') }}
@@ -24,7 +26,9 @@
{{ t('payment.admin.totalRevenue') }}
-
${{ formatMoney(stats.total_amount) }}
+
+ {{ formatMoney(currency, amount) }}
+
{{ stats.total_count }} {{ t('payment.admin.orders') }}
@@ -53,7 +57,9 @@
{{ t('payment.admin.avgAmount') }}
-
${{ formatMoney(stats.avg_amount) }}
+
+ {{ formatMoney(currency, amount) }}
+
@@ -63,7 +69,7 @@
diff --git a/frontend/src/components/admin/payment/PaymentMethodChart.vue b/frontend/src/components/admin/payment/PaymentMethodChart.vue
index dd6909e95..00b3178f2 100644
--- a/frontend/src/components/admin/payment/PaymentMethodChart.vue
+++ b/frontend/src/components/admin/payment/PaymentMethodChart.vue
@@ -18,20 +18,23 @@
{{ t('payment.methods.' + method.type, method.type) }}
-
-
- ${{ method.amount.toFixed(2) }}
+
+
+ {{ formatMoney(currency, amount) }}
({{ method.count }})
{{ t('payment.admin.noData') }}
-
-
-
- {{ idx + 1 }}
+
+
{{ currency }}
+
+
+
+ {{ idx + 1 }}
+
+ {{ user.email }}
+
+
+ {{ formatMoney(currency, user.amount) }}
-
{{ user.email }}
-
- ${{ user.amount.toFixed(2) }}
-
@@ -36,11 +39,12 @@
diff --git a/frontend/src/components/admin/usage/UsageFilters.vue b/frontend/src/components/admin/usage/UsageFilters.vue
index 6a5fad626..0965567ce 100644
--- a/frontend/src/components/admin/usage/UsageFilters.vue
+++ b/frontend/src/components/admin/usage/UsageFilters.vue
@@ -523,5 +523,7 @@ const setUserKeyword = (email: string) => {
showUserDropdown.value = false
}
-defineExpose({ setUserKeyword })
+const getUserSearchRevision = () => userSearchSequence
+
+defineExpose({ getUserSearchRevision, setUserKeyword })
diff --git a/frontend/src/components/channels/AvailableChannelsTable.vue b/frontend/src/components/channels/AvailableChannelsTable.vue
index 2de45c6a5..23130d3fd 100644
--- a/frontend/src/components/channels/AvailableChannelsTable.vue
+++ b/frontend/src/components/channels/AvailableChannelsTable.vue
@@ -2,7 +2,10 @@
-
+
{{ columns.name }}
@@ -168,6 +171,151 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {{ columns.groups }}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
+
+
+
+ {{ columns.supportedModels }}
+
+
+
+ {{ noModelsLabel }}
+
+
+
+
+
+
+
('vue-i18n')
+ return {
+ ...actual,
+ useI18n: () => ({ t: (key: string) => key }),
+ }
+})
const componentPath = resolve(dirname(fileURLToPath(import.meta.url)), '../AvailableChannelsTable.vue')
const componentSource = readFileSync(componentPath, 'utf8')
@@ -18,3 +30,150 @@ describe('AvailableChannelsTable scroll integration', () => {
expect(componentSource).not.toMatch(//)
})
})
+
+const rows: UserAvailableChannel[] = [
+ {
+ name: 'Primary channel',
+ description: 'Fast and reliable access',
+ platforms: [
+ {
+ platform: 'anthropic',
+ groups: [
+ {
+ id: 1,
+ name: 'Exclusive Pro',
+ platform: 'anthropic',
+ subscription_type: 'standard',
+ rate_multiplier: 1.2,
+ peak_rate_enabled: true,
+ peak_start: '08:00',
+ peak_end: '10:00',
+ peak_rate_multiplier: 1.5,
+ is_exclusive: true,
+ },
+ {
+ id: 2,
+ name: 'Public',
+ platform: 'anthropic',
+ subscription_type: 'standard',
+ rate_multiplier: 1,
+ peak_rate_enabled: false,
+ peak_start: '',
+ peak_end: '',
+ peak_rate_multiplier: 1,
+ is_exclusive: false,
+ },
+ ],
+ supported_models: [{ name: 'claude-test', platform: 'anthropic', pricing: null }],
+ },
+ ],
+ },
+]
+
+const baseProps = {
+ columns: {
+ name: 'Channel',
+ description: 'Description',
+ platform: 'Platform',
+ groups: 'Groups and rates',
+ supportedModels: 'Models and pricing',
+ },
+ rows,
+ loading: false,
+ pricingKeyPrefix: 'availableChannels.pricing',
+ noPricingLabel: 'No pricing',
+ noModelsLabel: 'No models',
+ emptyLabel: 'No channels',
+ userGroupRates: { 1: 0.8 },
+}
+
+function mountTable(props = {}) {
+ return mount(AvailableChannelsTable, {
+ props: { ...baseProps, ...props },
+ global: {
+ plugins: [createPinia()],
+ stubs: {
+ Icon: { props: ['name'], template: '
' },
+ PlatformIcon: { template: '
' },
+ GroupBadge: {
+ props: ['name', 'rateMultiplier', 'userRateMultiplier'],
+ template:
+ '
{{ name }}:{{ rateMultiplier }}:{{ userRateMultiplier }} ',
+ },
+ SupportedModelChip: {
+ props: ['model', 'noPricingLabel'],
+ template: '
{{ model.name }}:{{ noPricingLabel }} ',
+ },
+ },
+ },
+ })
+}
+
+describe('AvailableChannelsTable responsive surfaces', () => {
+ it('keeps the five-column table as the desktop-only surface', () => {
+ const wrapper = mountTable()
+ const desktop = wrapper.get('[data-testid="desktop-channels"]')
+
+ // TablePageLayout has a more-specific `display: table` rule for descendants,
+ // so these display utilities must remain important at both breakpoints.
+ expect(desktop.classes()).toContain('!hidden')
+ expect(desktop.classes()).toContain('lg:!table')
+ expect(desktop.findAll('thead th')).toHaveLength(5)
+ expect(desktop.text()).toContain('Primary channel')
+ expect(desktop.text()).toContain('Fast and reliable access')
+ expect(desktop.findAll('[data-group-badge]')).toHaveLength(2)
+ expect(desktop.get('[data-model-chip]').text()).toContain('claude-test:No pricing')
+ })
+
+ it('renders a mobile-only readable surface with groups, rates, peaks, and model pricing chips', () => {
+ const wrapper = mountTable()
+ const mobile = wrapper.get('[data-testid="mobile-channels"]')
+
+ expect(mobile.classes()).toContain('lg:hidden')
+ expect(mobile.classes()).toContain('overflow-x-hidden')
+ expect(mobile.text()).toContain('Primary channel')
+ expect(mobile.text()).toContain('Fast and reliable access')
+ expect(mobile.text()).toContain('Groups and rates')
+ expect(mobile.text()).toContain('Models and pricing')
+ expect(mobile.text()).toContain('availableChannels.exclusive')
+ expect(mobile.text()).toContain('availableChannels.public')
+ expect(mobile.get('[data-group-badge]').text()).toBe('Exclusive Pro:1.2:0.8')
+ expect(mobile.findAll('[data-group-badge]')).toHaveLength(2)
+ expect(mobile.get('[data-icon="clock"]')).toBeTruthy()
+ expect(mobile.text()).toContain('08:00')
+ expect(mobile.text()).toContain('10:00')
+ expect(mobile.text()).toContain('×1.5')
+ expect(mobile.get('[data-model-chip]').text()).toBe('claude-test:No pricing')
+ expect(mobile.findAll('.max-w-full')).not.toHaveLength(0)
+ })
+
+ it('keeps the mobile placeholders when a platform has no groups or models', () => {
+ const wrapper = mountTable({
+ rows: [
+ {
+ name: 'Fallback channel',
+ description: '',
+ platforms: [{ platform: 'openai', groups: [], supported_models: [] }],
+ },
+ ],
+ })
+ const mobile = wrapper.get('[data-testid="mobile-channels"]')
+
+ expect(mobile.text()).toContain('Fallback channel')
+ expect(mobile.text()).toContain('openai')
+ expect(mobile.text()).toContain('No models')
+ expect(mobile.findAll('dd')[0].text()).toBe('-')
+ })
+
+ it('provides loading and empty states on both responsive surfaces', async () => {
+ const wrapper = mountTable({ loading: true, rows: [] })
+
+ expect(wrapper.get('[data-testid="desktop-channels"] [data-icon="refresh"]')).toBeTruthy()
+ expect(wrapper.get('[data-testid="mobile-loading"] [data-icon="refresh"]')).toBeTruthy()
+
+ await wrapper.setProps({ loading: false })
+
+ expect(wrapper.get('[data-testid="desktop-channels"]').text()).toContain('No channels')
+ expect(wrapper.get('[data-testid="mobile-empty"]').text()).toContain('No channels')
+ })
+})
diff --git a/frontend/src/components/user/monitor/MonitorTimeline.vue b/frontend/src/components/user/monitor/MonitorTimeline.vue
index 2445bc519..548e2c084 100644
--- a/frontend/src/components/user/monitor/MonitorTimeline.vue
+++ b/frontend/src/components/user/monitor/MonitorTimeline.vue
@@ -17,7 +17,7 @@
+
+export interface DailyPaymentStats {
+ date: string
+ amount: CurrencyAmounts
+ count: number
+}
+
+export interface PaymentMethodStats {
+ type: string
+ amount: CurrencyAmounts
+ count: number
+}
+
+export interface TopUserPaymentStats {
+ user_id: number
+ email: string
+ amount: number
+}
+
export interface DashboardStats {
- today_amount: number
- total_amount: number
+ today_amount: CurrencyAmounts
+ total_amount: CurrencyAmounts
today_count: number
total_count: number
- avg_amount: number
- daily_series: { date: string; amount: number; count: number }[]
- payment_methods: { type: string; amount: number; count: number }[]
- top_users: { user_id: number; email: string; amount: number }[]
+ avg_amount: CurrencyAmounts
+ daily_series: DailyPaymentStats[]
+ payment_methods: PaymentMethodStats[]
+ top_users: Record
}
diff --git a/frontend/src/views/admin/GroupsView.vue b/frontend/src/views/admin/GroupsView.vue
index 260628fd0..54375581b 100644
--- a/frontend/src/views/admin/GroupsView.vue
+++ b/frontend/src/views/admin/GroupsView.vue
@@ -3886,6 +3886,9 @@
class="input"
placeholder="gpt-5"
/>
+
+ {{ t("admin.groups.compositeRoutes.upstreamModelHint") }}
+
diff --git a/frontend/src/views/admin/UsageView.vue b/frontend/src/views/admin/UsageView.vue
index 8930cf635..2d64c92f0 100644
--- a/frontend/src/views/admin/UsageView.vue
+++ b/frontend/src/views/admin/UsageView.vue
@@ -335,6 +335,26 @@ const applyRouteQueryFilters = () => {
granularity.value = getGranularityForRange(startDate.value, endDate.value)
}
+const loadRouteUserFilterLabel = async () => {
+ const requestedUserId = filters.value.user_id
+ if (!requestedUserId) return
+ const userSearchRevision = usageFiltersRef.value?.getUserSearchRevision?.()
+
+ const routeUserFilterIsCurrent = () => (
+ filters.value.user_id === requestedUserId
+ && usageFiltersRef.value?.getUserSearchRevision?.() === userSearchRevision
+ )
+
+ try {
+ const user = await adminAPI.users.getById(requestedUserId, true)
+ if (!routeUserFilterIsCurrent()) return
+ usageFiltersRef.value?.setUserKeyword?.(user.email || String(requestedUserId))
+ } catch {
+ if (!routeUserFilterIsCurrent()) return
+ usageFiltersRef.value?.setUserKeyword?.(String(requestedUserId))
+ }
+}
+
const onDateRangeChange = (range: { startDate: string; endDate: string; preset: string | null }) => {
startDate.value = range.startDate
endDate.value = range.endDate
@@ -822,6 +842,7 @@ const handleColumnClickOutside = (event: MouseEvent) => {
onMounted(() => {
applyRouteQueryFilters()
+ void loadRouteUserFilterLabel()
loadLogs()
loadStats()
loadModelStats(modelDistributionSource.value, true)
diff --git a/frontend/src/views/admin/__tests__/UsageView.spec.ts b/frontend/src/views/admin/__tests__/UsageView.spec.ts
index 6afeebe93..e0fc24b12 100644
--- a/frontend/src/views/admin/__tests__/UsageView.spec.ts
+++ b/frontend/src/views/admin/__tests__/UsageView.spec.ts
@@ -1,9 +1,10 @@
import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest'
import { flushPromises, mount } from '@vue/test-utils'
+import { defineComponent, ref } from 'vue'
import UsageView from '../UsageView.vue'
-const { list, getStats, getSnapshotV2, getById, getModelStats, listErrorLogs } = vi.hoisted(() => {
+const { list, getStats, getSnapshotV2, getById, getModelStats, listErrorLogs, routeQuery } = vi.hoisted(() => {
vi.stubGlobal('localStorage', {
getItem: vi.fn(() => null),
setItem: vi.fn(),
@@ -17,6 +18,7 @@ const { list, getStats, getSnapshotV2, getById, getModelStats, listErrorLogs } =
getById: vi.fn(),
getModelStats: vi.fn(),
listErrorLogs: vi.fn(),
+ routeQuery: {} as Record
,
}
})
@@ -85,12 +87,28 @@ vi.mock('vue-i18n', async () => {
vi.mock('vue-router', () => ({
useRoute: () => ({
- query: {}
+ query: routeQuery
})
}))
const AppLayoutStub = { template: '
' }
-const UsageFiltersStub = { template: '
' }
+const UsageFiltersStub = defineComponent({
+ setup(_, { expose }) {
+ const userKeyword = ref('')
+ let userSearchRevision = 0
+ const setUserKeyword = (email: string) => {
+ userSearchRevision += 1
+ userKeyword.value = email
+ }
+ expose({
+ getUserSearchRevision: () => userSearchRevision,
+ setUserKeyword,
+ simulateUserInput: setUserKeyword,
+ })
+ return { userKeyword }
+ },
+ template: '{{ userKeyword }}
',
+})
const UsageTableStub = {
emits: ['userClick'],
template: 'user
',
@@ -120,6 +138,114 @@ const GroupDistributionChartStub = {
`,
}
+const mountRouteFilteredUsageView = () => mount(UsageView, {
+ global: { stubs: {
+ AppLayout: AppLayoutStub, UsageStatsCards: true, UsageFilters: UsageFiltersStub,
+ UsageTable: true, UsageExportProgress: true, UsageCleanupDialog: true,
+ UserBalanceHistoryModal: true, Pagination: true, Select: true,
+ DateRangePicker: true, Icon: true, TokenUsageTrend: true,
+ ModelDistributionChart: true, GroupDistributionChart: true,
+ EndpointDistributionChart: true, UserTokenRanking: true,
+ } },
+})
+
+describe('admin UsageView route filters', () => {
+ beforeEach(() => {
+ vi.useFakeTimers()
+ Object.keys(routeQuery).forEach((key) => delete routeQuery[key])
+ list.mockReset().mockResolvedValue({ items: [], total: 0, pages: 0 })
+ getStats.mockReset().mockResolvedValue({
+ total_requests: 0,
+ total_input_tokens: 0,
+ total_output_tokens: 0,
+ total_cache_tokens: 0,
+ total_tokens: 0,
+ total_cost: 0,
+ total_actual_cost: 0,
+ average_duration_ms: 0,
+ })
+ getSnapshotV2.mockReset().mockResolvedValue({ trend: [], models: [], groups: [] })
+ getModelStats.mockReset().mockResolvedValue({ models: [] })
+ getById.mockReset()
+ })
+
+ afterEach(() => {
+ Object.keys(routeQuery).forEach((key) => delete routeQuery[key])
+ vi.useRealTimers()
+ })
+
+ it('shows the routed user while applying user_id to usage requests', async () => {
+ routeQuery.user_id = '42'
+ getById.mockResolvedValue({ id: 42, email: 'route-user@test.com' })
+
+ const wrapper = mountRouteFilteredUsageView()
+ await flushPromises()
+
+ expect(getById).toHaveBeenCalledWith(42, true)
+ expect(list).toHaveBeenCalledWith(expect.objectContaining({ user_id: 42 }), expect.anything())
+ expect(wrapper.find('[data-test="user-filter-label"]').text()).toBe('route-user@test.com')
+ })
+
+ it('does not apply a stale routed user label after user_id changes', async () => {
+ routeQuery.user_id = '42'
+ let resolveLookup!: (user: { id: number; email: string }) => void
+ getById.mockReturnValue(new Promise((resolve) => { resolveLookup = resolve }))
+
+ const wrapper = mountRouteFilteredUsageView()
+ await wrapper.vm.$nextTick()
+ ;(wrapper.vm as any).filters.user_id = 84
+ ;(wrapper.findComponent(UsageFiltersStub).vm as any).setUserKeyword('current-user@test.com')
+
+ resolveLookup({ id: 42, email: 'stale-user@test.com' })
+ await flushPromises()
+
+ expect(wrapper.find('[data-test="user-filter-label"]').text()).toBe('current-user@test.com')
+ })
+
+ it('does not overwrite newer user input when the routed user lookup succeeds', async () => {
+ routeQuery.user_id = '42'
+ let resolveLookup!: (user: { id: number; email: string }) => void
+ getById.mockReturnValue(new Promise((resolve) => { resolveLookup = resolve }))
+
+ const wrapper = mountRouteFilteredUsageView()
+ await wrapper.vm.$nextTick()
+ ;(wrapper.findComponent(UsageFiltersStub).vm as any).simulateUserInput('new-search@test.com')
+
+ resolveLookup({ id: 42, email: 'route-user@test.com' })
+ await flushPromises()
+
+ expect((wrapper.vm as any).filters.user_id).toBe(42)
+ expect(wrapper.find('[data-test="user-filter-label"]').text()).toBe('new-search@test.com')
+ })
+
+ it('does not overwrite newer user input when the routed user lookup fails', async () => {
+ routeQuery.user_id = '42'
+ let rejectLookup!: (error: Error) => void
+ getById.mockReturnValue(new Promise((_, reject) => { rejectLookup = reject }))
+
+ const wrapper = mountRouteFilteredUsageView()
+ await wrapper.vm.$nextTick()
+ ;(wrapper.findComponent(UsageFiltersStub).vm as any).simulateUserInput('new-search@test.com')
+
+ rejectLookup(new Error('lookup failed'))
+ await flushPromises()
+
+ expect((wrapper.vm as any).filters.user_id).toBe(42)
+ expect(wrapper.find('[data-test="user-filter-label"]').text()).toBe('new-search@test.com')
+ })
+
+ it('shows the routed user ID when its label lookup fails', async () => {
+ routeQuery.user_id = '42'
+ getById.mockRejectedValue(new Error('lookup failed'))
+
+ const wrapper = mountRouteFilteredUsageView()
+ await flushPromises()
+
+ expect(list).toHaveBeenCalledWith(expect.objectContaining({ user_id: 42 }), expect.anything())
+ expect(wrapper.find('[data-test="user-filter-label"]').text()).toBe('42')
+ })
+})
+
describe('admin UsageView distribution metric toggles', () => {
beforeEach(() => {
vi.useFakeTimers()
diff --git a/frontend/src/views/admin/orders/AdminPaymentDashboardView.vue b/frontend/src/views/admin/orders/AdminPaymentDashboardView.vue
index 5a80db44f..70fe95962 100644
--- a/frontend/src/views/admin/orders/AdminPaymentDashboardView.vue
+++ b/frontend/src/views/admin/orders/AdminPaymentDashboardView.vue
@@ -41,8 +41,8 @@
{{ t('payment.methods.' + method.type, method.type) }}
-
-
¥{{ method.amount.toFixed(2) }}
+
+ {{ formatMoney(currency, amount) }}
({{ method.count }})
@@ -50,14 +50,17 @@
{{ t('payment.admin.topUsers') }}
-
{{ t('payment.admin.noData') }}
+
{{ t('payment.admin.noData') }}
-
-
-
{{ idx + 1 }}
-
{{ user.email }}
+
+
{{ currency }}
+
+
+ {{ idx + 1 }}
+ {{ user.email }}
+
+
{{ formatMoney(currency, user.amount) }}
-
¥{{ user.amount.toFixed(2) }}
@@ -73,7 +76,7 @@ import { useI18n } from 'vue-i18n'
import { useAppStore } from '@/stores/app'
import { adminPaymentAPI } from '@/api/admin/payment'
import { extractI18nErrorMessage } from '@/utils/apiError'
-import type { DashboardStats } from '@/types/payment'
+import type { CurrencyAmounts, DashboardStats, TopUserPaymentStats } from '@/types/payment'
import AppLayout from '@/components/layout/AppLayout.vue'
import LoadingSpinner from '@/components/common/LoadingSpinner.vue'
import Icon from '@/components/icons/Icon.vue'
@@ -104,6 +107,22 @@ function rankClass(idx: number): string {
return 'bg-gray-100 text-gray-500 dark:bg-dark-700 dark:text-gray-400'
}
+function sortedAmounts(amounts: CurrencyAmounts): [string, number][] {
+ return Object.entries(amounts).sort(([left], [right]) => left.localeCompare(right))
+}
+
+function sortedTopUsers(usersByCurrency: Record
): [string, TopUserPaymentStats[]][] {
+ return Object.entries(usersByCurrency).sort(([left], [right]) => left.localeCompare(right))
+}
+
+function hasTopUsers(usersByCurrency: Record): boolean {
+ return Object.values(usersByCurrency).some(users => users.length > 0)
+}
+
+function formatMoney(currency: string, amount: number): string {
+ return new Intl.NumberFormat(undefined, { style: 'currency', currency }).format(amount)
+}
+
async function loadDashboard() {
loading.value = true
try {
diff --git a/frontend/src/views/auth/RegisterView.vue b/frontend/src/views/auth/RegisterView.vue
index b4a7a6009..4b8977914 100644
--- a/frontend/src/views/auth/RegisterView.vue
+++ b/frontend/src/views/auth/RegisterView.vue
@@ -134,6 +134,27 @@
+
+
+
+ {{ t('auth.invitationCodeLabel') }}
+ ({{ t('common.optional') }})
+
+
+
+
@@ -183,7 +204,7 @@
-
+
(true)
const emailVerifyEnabled = ref(false)
const promoCodeEnabled = ref(true)
const invitationCodeEnabled = ref(false)
+const affiliateEnabled = ref(false)
const turnstileEnabled = ref(false)
const turnstileSiteKey = ref('')
const siteName = ref('Sub2API')
@@ -459,6 +481,7 @@ onMounted(async () => {
emailVerifyEnabled.value = settings.email_verify_enabled
promoCodeEnabled.value = settings.promo_code_enabled
invitationCodeEnabled.value = settings.invitation_code_enabled
+ affiliateEnabled.value = settings.affiliate_enabled
turnstileEnabled.value = settings.turnstile_enabled
turnstileSiteKey.value = settings.turnstile_site_key || ''
siteName.value = settings.site_name || 'Sub2API'
diff --git a/frontend/src/views/auth/__tests__/RegisterView.spec.ts b/frontend/src/views/auth/__tests__/RegisterView.spec.ts
new file mode 100644
index 000000000..20f63018a
--- /dev/null
+++ b/frontend/src/views/auth/__tests__/RegisterView.spec.ts
@@ -0,0 +1,112 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import RegisterView from '@/views/auth/RegisterView.vue'
+
+const { getPublicSettingsMock } = vi.hoisted(() => ({
+ getPublicSettingsMock: vi.fn()
+}))
+
+const publicSettings = {
+ registration_enabled: true,
+ email_verify_enabled: false,
+ promo_code_enabled: false,
+ invitation_code_enabled: false,
+ affiliate_enabled: true,
+ turnstile_enabled: true,
+ turnstile_site_key: 'site-key',
+ site_name: 'Sub2API',
+ registration_email_suffix_whitelist: [],
+ linuxdo_oauth_enabled: false,
+ wechat_oauth_enabled: false,
+ oidc_oauth_enabled: false,
+ github_oauth_enabled: false,
+ google_oauth_enabled: false
+}
+
+vi.mock('vue-router', () => ({
+ useRouter: () => ({ push: vi.fn() }),
+ useRoute: () => ({ query: {} })
+}))
+
+vi.mock('vue-i18n', () => ({
+ createI18n: () => ({
+ global: {
+ t: (key: string) => key
+ }
+ }),
+ useI18n: () => ({
+ t: (key: string) => key,
+ locale: { value: 'en' }
+ })
+}))
+
+vi.mock('@/stores', () => ({
+ useAuthStore: () => ({ register: vi.fn() }),
+ useAppStore: () => ({
+ showError: vi.fn(),
+ showSuccess: vi.fn(),
+ showWarning: vi.fn()
+ })
+}))
+
+vi.mock('@/api/auth', async () => {
+ const actual = await vi.importActual('@/api/auth')
+ return {
+ ...actual,
+ getPublicSettings: (...args: unknown[]) => getPublicSettingsMock(...args)
+ }
+})
+
+function mountRegister() {
+ return mount(RegisterView, {
+ global: {
+ stubs: {
+ AuthLayout: { template: '
' },
+ Icon: true,
+ TurnstileWidget: { template: '
' },
+ LoginAgreementPrompt: true,
+ EmailOAuthButtons: true,
+ LinuxDoOAuthSection: true,
+ WechatOAuthSection: true,
+ OidcOAuthSection: true,
+ RouterLink: true,
+ transition: false
+ }
+ }
+ })
+}
+
+describe('RegisterView invitation layout', () => {
+ beforeEach(() => {
+ getPublicSettingsMock.mockReset()
+ getPublicSettingsMock.mockResolvedValue(publicSettings)
+ })
+
+ it('keeps the optional affiliate invitation field before Turnstile', async () => {
+ const wrapper = mountRegister()
+ await flushPromises()
+
+ const invitationField = wrapper.get('[data-testid="affiliate-invitation-field"]')
+ const turnstile = wrapper.get('[data-testid="registration-turnstile"]')
+
+ expect(invitationField.get('input').attributes('id')).toBe('affiliate_code')
+ expect(invitationField.text()).toContain('common.optional')
+ expect(
+ invitationField.element.compareDocumentPosition(turnstile.element) &
+ Node.DOCUMENT_POSITION_FOLLOWING
+ ).toBeTruthy()
+ })
+
+ it('uses the mandatory invitation field without duplicating the affiliate field', async () => {
+ getPublicSettingsMock.mockResolvedValueOnce({
+ ...publicSettings,
+ invitation_code_enabled: true
+ })
+
+ const wrapper = mountRegister()
+ await flushPromises()
+
+ expect(wrapper.find('[data-testid="affiliate-invitation-field"]').exists()).toBe(false)
+ expect(wrapper.get('#invitation_code').exists()).toBe(true)
+ })
+})
