fix: review 跟进——流式报错回传真实状态码等修复

- 流式请求上游拒绝（400/429/5xx、busy、流内错误帧）在尚未写出任何内容时
  按真实状态码回传 JSON 错误体，不再伪装成已提交的 200 SSE 流；
  内容已输出后才失败的仍走 SSE error chunk（wrote 边界）
- AuthError（上游会话/PAT 凭证被拒）映射 502 upstream_error，
  不再落 500，也不透传 401 以免客户端误判自己的 key 失效
- 流内错误帧（InStreamError，导出）按帧内嵌状态码映射，无状态码则 502
- 上游 429 的 Retry-After 响应头捕获并透传（与 busy 路径同形）
- 请求解码启用 UseNumber：verbatim 数字透传精度无损（2^53+1、
  长小数不再经 float64 取整），numberJSON 的 json.Number 分支就此生效
- max_thinking_tokens 客户端显式值原样转发（覆盖 none 档合成的 0），
  类型错误本地 400；不再静默丢弃
- GetCatalog 缓存时间戳改为 fetch 后取值，TTL 不再被取数耗时稀释
- 前端：copy() 判空+catch（非安全上下文不再静默失败）；
  keys/token/settings 加载失败补 toast（与 stats/models 一致）；
  settings 保存注释与实现对齐；后台标签页暂停统计轮询、回前台即刷
- 测试：流式上游拒绝状态码表 / 内容后失败保持 SSE 边界 / AuthError 502 /
  生产解码路径 verbatim 精度 / max_thinking_tokens 透传 /
  admin+web 同 mux 联合装配 / 前端 API 路径与 admin 路由契约
- README 错误回传约定与参数表同步更新

Author: EchoPing07

README.md

@@ -171,7 +171,8 @@ curl http://localhost:10081/v1/models \
 | 请求字段 | 处理 |
 | --- | --- |
 | `reasoning_effort` / `reasoning.effort` | 原样写入 `parameters.reasoning_effort`（顶层优先）。不校验档位、不映射 `minimal`、不因目录未声明而丢弃；模型不支持时由网关报错回传 |
-| `max_tokens` / `max_completion_tokens` | 任意 JSON 数値原样写入 `parameters.max_tokens`（含 0、负数、小数、超大值；`max_tokens` 优先）。未传时才用目录默认值 |
+| `max_tokens` / `max_completion_tokens` | 任意 JSON 数値原样写入 `parameters.max_tokens`（含 0、负数、小数、超大值与超出 float64 精度的整数；`max_tokens` 优先）。未传时才用目录默认值 |
+| `max_thinking_tokens` | 客户端显式传入时原样转发（即使同时携带 `reasoning_effort: "none"`，也以客户端值为准）；仅 `none` 档且未传时才合成显式 `0`（官方客户端的天闭开关） |
 | `temperature` / `top_p` / `stop` / `seed` / `response_format` / `logit_bias` / `presence_penalty` / `frequency_penalty` / `n=1` | 原样写入 `parameters`。网关认不认由网关决定，错误回传 |
 | `n` ≠ 1 | 本地 `400`：响应通道结构上只能产生单个 choice，拒绝静默只返回一个 |
 | 类型错误（如 `"max_tokens": "8000"`、`"reasoning_effort": 3`） | 本地 `400 invalid_request_error` |
@@ -243,7 +244,7 @@ curl http://localhost:10081/v1/models \
 
 **错误响应约定**：登录失败限流返回 `429`（附 `Retry-After`）；创建重复 API Key 返回 `409`；端口配置越界（非 1–65535）返回 `400`；未鉴权或会话过期返回 `401`。
 
-**上游错误回传**：网关对请求本身的拒绝（如不支持的档位、`max_tokens` 范围校验失败）按真实状态码回传——4xx 请求级拒绝 → `400 invalid_request_error` + 网关原始 message；429 → `429 rate_limit_error`；5xx → `502 upstream_error`。参数类型错误（字符串数值等）与 `n`≠1 在本地返回 `400`。流中错误以 SSE error chunk 形式携带真实原因。
+**上游错误回传**：网关对请求本身的拒绝（如不支持的档位、`max_tokens` 范围校验失败）按真实状态码回传——4xx 请求级拒绝 → `400 invalid_request_error` + 网关原始 message；429 → `429 rate_limit_error`（上游携带 `Retry-After` 时一并透传）；5xx → `502 upstream_error`。流式与非流式一视同仁：只要尚未向客户端写出任何内容，拒绝就以真实状态码的 JSON 错误体返回；内容已开始输出后才失败的，则以 SSE error chunk 携带真实原因（此时状态码只能保持 200）。网关在流内报错（HTTP 200 但错误帧）时，若尚无内容，同样按错误帧内嵌的状态码映射（无状态码则 `502`）。上游会话/PAT 凭证被拒（网关 401/403）回传 `502 upstream_error`（上游凭证问题不是客户端的 API key 问题，不回传 401 以免误导）。参数类型错误（字符串数值等）与 `n`≠1 在本地返回 `400`。
 
 ## 额度与计费周期
 

auth/auth.go

@@ -398,15 +398,31 @@ func (e *BusyError) Error() string {
 // message instead of collapsing everything into an opaque 500. Typical
 // sources: parameter rejections (400, e.g. an unsupported max_tokens range
 // or reasoning tier) and gateway faults (5xx).
+//
+// RetryAfter carries the gateway's numeric Retry-After header when the
+// rejection came with one (429); 0 means absent/unparseable, and the client
+// response then simply omits the header.
 type UpstreamError struct {
 	StatusCode int
 	Body       string
+	RetryAfter time.Duration
 }
 
 func (e *UpstreamError) Error() string {
 	return fmt.Sprintf("gateway HTTP %d: %s", e.StatusCode, e.Body)
 }
 
+// retryAfterHeader parses a numeric Retry-After response header into a
+// duration. The HTTP-date form and unparsable/non-positive values yield 0;
+// only 429 rejections are expected to carry the header at all.
+func retryAfterHeader(h string) time.Duration {
+	secs, err := strconv.Atoi(strings.TrimSpace(h))
+	if err != nil || secs <= 0 {
+		return 0
+	}
+	return time.Duration(secs) * time.Second
+}
+
 // busyMeta extracts retryAfterSeconds from the nested JSON message carried
 // inside a 10605 payload, if present.
 func busyMeta(msg string) time.Duration {
@@ -645,7 +661,7 @@ func postEncoded(ctx context.Context, urlStr string, obj interface{}, machineID,
 			}
 			return nil, &AuthError{StatusCode: resp.StatusCode, Detail: string(detail)}
 		}
-		return nil, &UpstreamError{StatusCode: resp.StatusCode, Body: string(truncateErrorBody(detail))}
+		return nil, &UpstreamError{StatusCode: resp.StatusCode, Body: string(truncateErrorBody(detail)), RetryAfter: retryAfterHeader(resp.Header.Get("Retry-After"))}
 	}
 
 	var result map[string]interface{}
@@ -991,7 +1007,7 @@ func call(ctx context.Context, sess *SessionContext, method, fullURL string, jso
 			}
 			return nil, &AuthError{StatusCode: resp.StatusCode, Detail: string(detail)}
 		}
-		return nil, &UpstreamError{StatusCode: resp.StatusCode, Body: string(truncateErrorBody(detail))}
+		return nil, &UpstreamError{StatusCode: resp.StatusCode, Body: string(truncateErrorBody(detail)), RetryAfter: retryAfterHeader(resp.Header.Get("Retry-After"))}
 	}
 
 	var result map[string]interface{}
@@ -1105,20 +1121,23 @@ func isErrorEvent(line string) bool {
 	return strings.HasPrefix(line, "event:") && strings.TrimSpace(line[len("event:"):]) == "error"
 }
 
-// inStreamError describes a gateway failure delivered inside the SSE stream
+// InStreamError describes a gateway failure delivered inside the SSE stream
 // (HTTP status is still 200). Kept when seen so the EOF-without-[DONE]
 // fallback reports the real cause instead of a misleading "connection
-// truncated".
-type inStreamError struct {
-	status int
-	detail string
+// truncated". Status carries the status embedded in the failure frame
+// (statusCodeValue or msgCode); 0 means unknown. Exported so the chat
+// handler can map the client response to the same status instead of a
+// generic 500 when the stream failed before any content was delivered.
+type InStreamError struct {
+	Status int
+	Detail string
 }
 
-func (e *inStreamError) Error() string {
-	if e.status > 0 {
-		return fmt.Sprintf("gateway in-stream error (HTTP %d): %s", e.status, e.detail)
+func (e *InStreamError) Error() string {
+	if e.Status > 0 {
+		return fmt.Sprintf("gateway in-stream error (HTTP %d): %s", e.Status, e.Detail)
 	}
-	return fmt.Sprintf("gateway in-stream error: %s", e.detail)
+	return fmt.Sprintf("gateway in-stream error: %s", e.Detail)
 }
 
 // detectInStreamGatewayError extracts a terminal gateway/provider failure
@@ -1133,7 +1152,7 @@ func (e *inStreamError) Error() string {
 //     {"success":false,"msgCode":500,"message":"Internal Server Error"}
 //
 // A 200 OK envelope with normal chat/usage/[DONE] bodies returns nil.
-func detectInStreamGatewayError(line string) *inStreamError {
+func detectInStreamGatewayError(line string) *InStreamError {
 	if !strings.HasPrefix(line, "data:") {
 		return nil
 	}
@@ -1151,7 +1170,7 @@ func detectInStreamGatewayError(line string) *inStreamError {
 		if detail == "" {
 			detail = env.StatusCode
 		}
-		return &inStreamError{status: env.StatusValue, detail: trimJSONMessage(detail)}
+		return &InStreamError{Status: env.StatusValue, Detail: trimJSONMessage(detail)}
 	}
 	if env.Body != "" || env.StatusCode != "" {
 		// A well-formed envelope with a 2xx status is a normal frame.
@@ -1176,7 +1195,7 @@ func detectInStreamGatewayError(line string) *inStreamError {
 		if detail == "" {
 			detail = fmt.Sprintf("msgCode %d", bare.MsgCode)
 		}
-		return &inStreamError{status: bare.MsgCode, detail: detail}
+		return &InStreamError{Status: bare.MsgCode, Detail: detail}
 	}
 	return nil
 }
@@ -1234,7 +1253,7 @@ func OpenStreamLines(ctx context.Context, sess *SessionContext, fullURL string,
 			}
 			return &AuthError{StatusCode: resp.StatusCode, Detail: string(errBody)}
 		}
-		return &UpstreamError{StatusCode: resp.StatusCode, Body: string(truncateErrorBody(errBody))}
+		return &UpstreamError{StatusCode: resp.StatusCode, Body: string(truncateErrorBody(errBody)), RetryAfter: retryAfterHeader(resp.Header.Get("Retry-After"))}
 	}
 
 	// Cut off silent streams: long generations are fine (lines keep
@@ -1264,7 +1283,7 @@ func OpenStreamLines(ctx context.Context, sess *SessionContext, fullURL string,
 	// success would silently truncate the answer and still emit our own
 	// [DONE] to the client.
 	sawDone := false
-	var gwErr *inStreamError
+	var gwErr *InStreamError
 
 	scanner := bufio.NewScanner(resp.Body)
 	scanner.Buffer(make([]byte, 0, 64*1024), 10*1024*1024)
@@ -1309,7 +1328,7 @@ func OpenStreamLines(ctx context.Context, sess *SessionContext, fullURL string,
 			// sure the EOF fallback reports the real cause (from the error
 			// frames seen before this event) instead of "truncated".
 			if gwErr == nil {
-				gwErr = &inStreamError{detail: "upstream stream failed (event:error)"}
+				gwErr = &InStreamError{Detail: "upstream stream failed (event:error)"}
 			}
 		}
 		if e := detectInStreamGatewayError(line); e != nil && gwErr == nil {

auth/auth_test.go

@@ -131,11 +131,11 @@ func TestDetectInStreamGatewayErrorEnvelope429(t *testing.T) {
 	if e == nil {
 		t.Fatal("429 envelope must be detected as in-stream error")
 	}
-	if e.status != 429 {
-		t.Errorf("status = %d, want 429", e.status)
+	if e.Status != 429 {
+		t.Errorf("status = %d, want 429", e.Status)
 	}
-	if e.detail != "provider_error: All backends failed" {
-		t.Errorf("detail = %q, want provider_error message", e.detail)
+	if e.Detail != "provider_error: All backends failed" {
+		t.Errorf("detail = %q, want provider_error message", e.Detail)
 	}
 }
 
@@ -161,8 +161,8 @@ func TestDetectInStreamGatewayErrorBareFailure(t *testing.T) {
 	if e == nil {
 		t.Fatal("bare success:false frame must be detected")
 	}
-	if e.detail != "Internal Server Error" {
-		t.Errorf("detail = %q", e.detail)
+	if e.Detail != "Internal Server Error" {
+		t.Errorf("detail = %q", e.Detail)
 	}
 }
 

bridge/bridge_test.go

@@ -773,28 +773,27 @@ func TestHandleStreamProviderErrorSurfacesRealCause(t *testing.T) {
 	}}
 	b := newFakeBridge(t, gw)
 
+	// The failure frames carry no content, so nothing is committed to the
+	// client and the rejection must surface as a real HTTP status carrying the
+	// embedded 429 — not a 200 SSE stream whose success every SDK would read.
+	handler := MakeChatHandler(func(string) *OpenAiBridge { return b }, nil)
+	req := httptest.NewRequest("POST", "/v1/chat/completions", strings.NewReader(
+		`{"model":"Fake-Model","messages":[{"role":"user","content":"hi"}],"stream":true}`))
+	req.Header.Set("Authorization", "Bearer sk-test")
 	w := httptest.NewRecorder()
-	err := b.HandleChat(context.Background(), w, map[string]interface{}{
-		"model":    "Fake-Model",
-		"messages": []interface{}{map[string]interface{}{"role": "user", "content": "hi"}},
-		"stream":   true,
-	}, nil)
-	if err == nil {
-		t.Fatal("provider outage stream must fail")
-	}
-	var repErr *StreamReportedError
-	if !errors.As(err, &repErr) {
-		t.Fatalf("expected StreamReportedError, got %T: %v", err, err)
+	handler(w, req)
+
+	if w.Code != http.StatusTooManyRequests {
+		t.Fatalf("status = %d, want 429 (embedded statusCodeValue)\n%s", w.Code, w.Body.String())
 	}
-	body := w.Body.String()
-	if !strings.Contains(body, "HTTP 429") || !strings.Contains(body, "provider_error: All backends failed") {
-		t.Errorf("error chunk must surface the real gateway cause, got:\n%s", body)
+	if !strings.Contains(w.Body.String(), "provider_error: All backends failed") {
+		t.Errorf("error body must surface the real gateway cause, got:\n%s", w.Body.String())
 	}
-	if strings.Contains(body, "connection truncated") {
-		t.Errorf("misleading truncated message must be gone, got:\n%s", body)
+	if strings.Contains(w.Body.String(), "connection truncated") {
+		t.Errorf("misleading truncated message must be gone, got:\n%s", w.Body.String())
 	}
-	if strings.HasSuffix(strings.TrimSpace(body), "data: [DONE]") {
-		t.Error("failed stream must not terminate with [DONE]")
+	if strings.Contains(w.Header().Get("Content-Type"), "text/event-stream") {
+		t.Errorf("no content was delivered; the response must be a JSON error, not SSE")
 	}
 }
 
@@ -1141,18 +1140,22 @@ func TestMakeChatHandlerMapsBusyTo429(t *testing.T) {
 		t.Errorf("Retry-After header missing/invalid: %q", ra)
 	}
 
-	// Streaming path: the error chunk carries the busy message and no second
-	// HTTP-level response is attempted.
+	// Streaming path: with no content delivered yet the response is still
+	// uncommitted, so the busy rejection must surface as a real 429 (with
+	// Retry-After) instead of an already-committed 200 SSE stream.
 	w2 := httptest.NewRecorder()
 	body := `{"model":"Fake-Model","messages":[{"role":"user","content":"hi"}],"stream":true}`
 	req2 := httptest.NewRequest("POST", "/v1/chat/completions", strings.NewReader(body))
 	req2.Header.Set("Authorization", "Bearer sk-test")
 	handler(w2, req2)
-	if w2.Code != 200 {
-		t.Errorf("streaming status = %d, want 200 (SSE headers already sent)", w2.Code)
+	if w2.Code != http.StatusTooManyRequests {
+		t.Errorf("streaming status = %d, want 429 (no content committed yet)\n%s", w2.Code, w2.Body.String())
+	}
+	if ra := w2.Header().Get("Retry-After"); ra == "" || ra == "0" {
+		t.Errorf("streaming Retry-After header missing/invalid: %q", ra)
 	}
-	if !strings.Contains(w2.Body.String(), "10605") {
-		t.Errorf("stream body should carry the busy code:\n%s", w2.Body.String())
+	if !strings.Contains(w2.Body.String(), "upstream busy") {
+		t.Errorf("stream body should carry the busy message:\n%s", w2.Body.String())
 	}
 }
 
@@ -1830,8 +1833,9 @@ func TestFmtResetTime(t *testing.T) {
 // rejectingGateway serves the auth endpoints but rejects every chat request
 // with a fixed status and body, for pass-through error mapping tests.
 type rejectingGateway struct {
-	status int
-	body   string
+	status     int
+	body       string
+	retryAfter string // optional Retry-After header served with the rejection
 }
 
 func newRejectingBridge(t *testing.T, gw *rejectingGateway) *OpenAiBridge {
@@ -1847,6 +1851,9 @@ func newRejectingBridge(t *testing.T, gw *rejectingGateway) *OpenAiBridge {
 	})
 	mux.HandleFunc("/algo/api/v2/service/pro/sse/agent_chat_generation", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "application/json")
+		if gw.retryAfter != "" {
+			w.Header().Set("Retry-After", gw.retryAfter)
+		}
 		w.WriteHeader(gw.status)
 		io.WriteString(w, gw.body)
 	})
@@ -1860,31 +1867,30 @@ func newRejectingBridge(t *testing.T, gw *rejectingGateway) *OpenAiBridge {
 // real status and message instead of being masked as a bridge 500.
 func TestMakeChatHandlerMapsUpstreamErrors(t *testing.T) {
 	cases := []struct {
-		name       string
-		status     int
-		body       string
-		wantCode   int
-		wantInBody string
+		name           string
+		status         int
+		body           string
+		retryAfter     string // Retry-After header served by the gateway, "" for none
+		wantCode       int
+		wantInBody     string
+		wantRetryAfter string
 	}{
 		{"400 parameter rejection passes through",
-			400, `{"code":"invalid_parameter_error","message":"Range of max_tokens validation failed"}`,
-			400, "Range of max_tokens"},
+			400, `{"code":"invalid_parameter_error","message":"Range of max_tokens validation failed"}`, "", 400, "Range of max_tokens", ""},
 		{"404 unknown model",
-			404, `{"code":"not_found","message":"model not found"}`,
-			400, "model not found"},
+			404, `{"code":"not_found","message":"model not found"}`, "", 400, "model not found", ""},
 		{"429 rate limit",
-			429, `{"code":"too_many_requests","message":"slow down"}`,
-			429, "slow down"},
+			429, `{"code":"too_many_requests","message":"slow down"}`, "", 429, "slow down", ""},
+		{"429 rate limit with Retry-After passes it through",
+			429, `{"code":"too_many_requests","message":"slow down"}`, "7", 429, "slow down", "7"},
 		{"500 gateway fault maps to 502",
-			500, `{"code":"internal_error","message":"boom"}`,
-			502, "boom"},
+			500, `{"code":"internal_error","message":"boom"}`, "", 502, "boom", ""},
 		{"503 gateway unavailable maps to 502",
-			503, "service unavailable",
-			502, "service unavailable"},
+			503, "service unavailable", "", 502, "service unavailable", ""},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			gw := &rejectingGateway{status: tc.status, body: tc.body}
+			gw := &rejectingGateway{status: tc.status, body: tc.body, retryAfter: tc.retryAfter}
 			b := newRejectingBridge(t, gw)
 			handler := MakeChatHandler(func(string) *OpenAiBridge { return b }, nil)
 
@@ -1900,6 +1906,9 @@ func TestMakeChatHandlerMapsUpstreamErrors(t *testing.T) {
 			if !strings.Contains(w.Body.String(), tc.wantInBody) {
 				t.Errorf("body must carry the upstream message %q:\n%s", tc.wantInBody, w.Body.String())
 			}
+			if got := w.Header().Get("Retry-After"); got != tc.wantRetryAfter {
+				t.Errorf("Retry-After = %q, want %q", got, tc.wantRetryAfter)
+			}
 		})
 	}
 }