feat(proxy): forward Anthropic speed:fast to Codex priority tier

Map official speed:"fast" to upstream service_tier priority, omit priority
when absent, and log resolved service_tier on /v1/messages for Usage admin
fast stats.

Author: caocuong2404

proxy/anthropic.go

@@ -26,6 +26,7 @@ type anthropicRequest struct {
 	OutputConfig *anthropicOutputConfig `json:"output_config,omitempty"`
 	ToolChoice   json.RawMessage        `json:"tool_choice,omitempty"`
 	Metadata     json.RawMessage        `json:"metadata,omitempty"`
+	Speed        string                 `json:"speed,omitempty"`
 }
 
 type anthropicThinking struct {
@@ -240,6 +241,10 @@ func TranslateAnthropicToCodex(rawJSON []byte, modelMappingJSON string) ([]byte,
 	return TranslateAnthropicToCodexWithModels(rawJSON, modelMappingJSON, SupportedModels)
 }
 
+func shouldUseCodexPriorityForAnthropicSpeed(speed string) bool {
+	return strings.ToLower(strings.TrimSpace(speed)) == "fast"
+}
+
 // TranslateAnthropicToCodexWithModels 将 Anthropic Messages 请求转换为 Codex Responses 格式
 // 返回: (codex 请求体, 原始 Anthropic model 名, error)
 func TranslateAnthropicToCodexWithModels(rawJSON []byte, modelMappingJSON string, supportedModels []string) ([]byte, string, error) {
@@ -271,6 +276,12 @@ func TranslateAnthropicToCodexWithModels(rawJSON []byte, modelMappingJSON string
 		"summary": "auto",
 	}
 
+	if shouldUseCodexPriorityForAnthropicSpeed(req.Speed) {
+		if upstreamTier, ok := upstreamServiceTier("priority"); ok {
+			out["service_tier"] = upstreamTier
+		}
+	}
+
 	// tools
 	if len(req.Tools) > 0 {
 		out["tools"] = convertAnthropicTools(req.Tools)

proxy/anthropic_test.go

@@ -62,6 +62,9 @@ func TestTranslateAnthropicToCodex_DefaultsReasoningHighWithSummary(t *testing.T
 	if summary := gjson.GetBytes(got, "reasoning.summary").String(); summary != "auto" {
 		t.Fatalf("reasoning.summary = %q, want auto; body=%s", summary, got)
 	}
+	if tier := gjson.GetBytes(got, "service_tier"); tier.Exists() {
+		t.Fatalf("service_tier should be omitted when speed is absent; body=%s", got)
+	}
 }
 
 func TestTranslateAnthropicToCodex_ThinkingBudgetDoesNotControlEffort(t *testing.T) {
@@ -81,6 +84,78 @@ func TestTranslateAnthropicToCodex_ThinkingBudgetDoesNotControlEffort(t *testing
 	}
 }
 
+func TestTranslateAnthropicToCodex_SpeedFastMapsToCodexPriority(t *testing.T) {
+	cases := []struct {
+		name     string
+		field    string
+		wantTier bool
+	}{
+		{"absent omits priority", "", false},
+		{"speed fast maps to priority", `,"speed":"fast"`, true},
+		{"speed standard omits priority", `,"speed":"standard"`, false},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			raw := []byte(`{
+				"model":"claude-sonnet-4-5",
+				"messages":[{"role":"user","content":"hello"}]` + tc.field + `
+			}`)
+
+			got, _, err := TranslateAnthropicToCodexWithModels(raw, "", []string{"gpt-5.4"})
+			if err != nil {
+				t.Fatalf("TranslateAnthropicToCodexWithModels returned error: %v", err)
+			}
+
+			tier := gjson.GetBytes(got, "service_tier")
+			if tc.wantTier {
+				if tier.String() != "priority" {
+					t.Fatalf("service_tier = %q, want priority; body=%s", tier.String(), got)
+				}
+				if speed := gjson.GetBytes(got, "speed"); speed.Exists() {
+					t.Fatalf("speed should not be forwarded to Codex body; body=%s", got)
+				}
+				return
+			}
+			if tier.Exists() {
+				t.Fatalf("service_tier should be omitted; body=%s", got)
+			}
+			if speed := gjson.GetBytes(got, "speed"); speed.Exists() {
+				t.Fatalf("speed should not be forwarded to Codex body; body=%s", got)
+			}
+		})
+	}
+}
+
+func TestAnthropicUsageServiceTierResolution(t *testing.T) {
+	cases := []struct {
+		name   string
+		speed  string
+		actual string
+		want   string
+	}{
+		{"no fast intent", "", "default", "default"},
+		{"fast intent upstream default", "fast", "default", "fast"},
+		{"fast intent upstream priority", "fast", "priority", "fast"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			field := ""
+			if tc.speed != "" {
+				field = `,"speed":"` + tc.speed + `"`
+			}
+			raw := []byte(`{"model":"claude-opus-4-7","messages":[{"role":"user","content":"hi"}]` + field + `}`)
+			codexBody, _, err := TranslateAnthropicToCodexWithModels(raw, "", []string{"gpt-5.5"})
+			if err != nil {
+				t.Fatalf("TranslateAnthropicToCodexWithModels returned error: %v", err)
+			}
+			got := resolveServiceTier(tc.actual, extractServiceTier(codexBody))
+			if got != tc.want {
+				t.Fatalf("resolveServiceTier(%q, %q) = %q, want %q", tc.actual, extractServiceTier(codexBody), got, tc.want)
+			}
+		})
+	}
+}
+
 func TestTranslateAnthropicToCodexCanonicalizesDynamicMappedModelAlias(t *testing.T) {
 	raw := []byte(`{
 		"model":"claude-haiku-4-5-20251001",

proxy/handler_anthropic.go

@@ -121,6 +121,7 @@ func (h *Handler) Messages(c *gin.Context) {
 
 	// 提取 reasoning effort（从翻译后的 codex body 中）
 	reasoningEffort := extractReasoningEffort(codexBody)
+	serviceTier := extractServiceTier(codexBody)
 	sessionID := ResolveSessionID(c.Request.Header, codexBody)
 	apiKeyID := requestAPIKeyID(c)
 	affinityKey := sessionAffinityKey(sessionID, apiKeyID)
@@ -225,6 +226,7 @@ func (h *Handler) Messages(c *gin.Context) {
 				InboundEndpoint:   "/v1/messages",
 				UpstreamEndpoint:  "/v1/responses",
 				Stream:            isStream,
+				ServiceTier:       resolveServiceTier("", serviceTier),
 				IsRetryAttempt:    shouldRetry,
 				AttemptIndex:      attempt + 1,
 				UpstreamErrorKind: upstreamErrorKind(resp.StatusCode, errBody, decision),
@@ -257,6 +259,7 @@ func (h *Handler) Messages(c *gin.Context) {
 
 		var firstTokenMs int
 		var usage *UsageInfo
+		var actualServiceTier string
 		ttftRecorded := false
 		gotTerminal := false
 		deltaCharCount := 0
@@ -301,6 +304,9 @@ func (h *Handler) Messages(c *gin.Context) {
 				// 提取 usage
 				if eventType == "response.completed" {
 					usage = extractUsageFromResult(parsed.Get("response.usage"))
+					if tier := parsed.Get("response.service_tier").String(); tier != "" {
+						actualServiceTier = tier
+					}
 					gotTerminal = true
 				}
 				if eventType == "response.failed" {
@@ -359,6 +365,9 @@ func (h *Handler) Messages(c *gin.Context) {
 				}
 				if eventType == "response.completed" {
 					usage = extractUsageFromResult(parsed.Get("response.usage"))
+					if tier := parsed.Get("response.service_tier").String(); tier != "" {
+						actualServiceTier = tier
+					}
 					lastCompletedData = data
 					gotTerminal = true
 					return false
@@ -418,6 +427,9 @@ func (h *Handler) Messages(c *gin.Context) {
 			}
 		}
 
+		resolvedServiceTier := resolveServiceTier(actualServiceTier, serviceTier)
+		c.Set("x-service-tier", resolvedServiceTier)
+
 		logInput := &database.UsageLogInput{
 			AccountID:        account.ID(),
 			Endpoint:         "/v1/messages",
@@ -430,6 +442,7 @@ func (h *Handler) Messages(c *gin.Context) {
 			InboundEndpoint:  "/v1/messages",
 			UpstreamEndpoint: "/v1/responses",
 			Stream:           isStream,
+			ServiceTier:      resolvedServiceTier,
 		}
 		if logStatusCode != http.StatusOK {
 			logInput.ErrorMessage = usageLogErrorMessage(logStatusCode, []byte(outcome.failureMessage))