@@ -76,6 +76,7 @@ docker run -d -p 10081:10081 -v qoder2api-data:/app/data -e QODER_DATA_PATH=/app
 | `QODER_SIGNATURE_SECRET` | 内置值 | 请求签名密钥 |
 | `QODER_CHAT_TIMEOUT_SECONDS` | `120` | Chat 响应超时：等待上游开始响应（返回响应头）的最长秒数，范围 1-3600；设置后管理面板中不可修改 |
 | `QODER_IDLE_TIMEOUT_SECONDS` | `300` | 流空闲超时：流式响应中持续无数据的最长等待秒数，范围 1-3600（数据持续到达时流不会被中断）；设置后管理面板中不可修改 |
+| `QODER_MAX_CONCURRENCY` | `1` | 单 PAT 同时发往上游的聊天请求数上限；超出部分本地排队等待。调大会提升吞吐，但超过 Qoder 账号的并发窗口时网关会拒绝请求（业务码 10605） |
 
 > 两个超时也可在管理面板「设置 → 超时配置」中修改，保存后即时生效（无需重启）。响应超时只约束上游「开始响应」，不会截断已经建立的流。
 
 
@@ -337,6 +337,104 @@ func (e *AuthError) Error() string {
 	return s
 }
 
+// --- Gateway busy (queue/concurrency) errors ---
+
+// errBodyCap bounds how much of an upstream error response is read for
+// classification and reporting. The former 300-byte cap could truncate a
+// 10605 envelope mid-JSON, making it unparseable and misclassifying the
+// rejection as an auth failure.
+const errBodyCap = 4 << 10 // 4 KiB
+
+// QoderBusyCode is the gateway's business code for queue/admission-control
+// rejections. It rides HTTP 401/403 envelopes (and in-stream frames with a
+// matching statusCodeValue) even though the session is perfectly valid:
+//
+//	{"code":"10605","message":"{\"isQueued\":false,...,\"retryAfterSeconds\":2,...}"}
+//
+// Treating it as an auth failure causes a pointless token refresh followed
+// by an immediate retry that slams into the same concurrency window.
+const QoderBusyCode = "10605"
+
+// BusyError is a gateway queue/concurrency rejection (business code 10605).
+// The session is valid; the request was refused by admission control and may
+// succeed after RetryAfter.
+type BusyError struct {
+	StatusCode int
+	Code       string
+	Message    string
+	RetryAfter time.Duration
+}
+
+func (e *BusyError) Error() string {
+	s := fmt.Sprintf("gateway busy (%s): %s", e.Code, e.Message)
+	if e.RetryAfter > 0 {
+		s += fmt.Sprintf(" (retry after %s)", e.RetryAfter)
+	}
+	return s
+}
+
+// busyMeta extracts retryAfterSeconds from the nested JSON message carried
+// inside a 10605 payload, if present.
+func busyMeta(msg string) time.Duration {
+	var meta struct {
+		RetryAfterSeconds int `json:"retryAfterSeconds"`
+	}
+	if strings.HasPrefix(strings.TrimSpace(msg), "{") && json.Unmarshal([]byte(msg), &meta) == nil && meta.RetryAfterSeconds > 0 {
+		return time.Duration(meta.RetryAfterSeconds) * time.Second
+	}
+	return 0
+}
+
+// maxBusyMessageRunes caps the upstream-provided busy message echoed into
+// logs and client-facing error bodies.
+const maxBusyMessageRunes = 512
+
+func truncateBusyMessage(s string) string {
+	r := []rune(s)
+	if len(r) <= maxBusyMessageRunes {
+		return s
+	}
+	return string(r[:maxBusyMessageRunes]) + "…"
+}
+
+// busyCodeOf normalizes a JSON "code" field that may arrive as a string
+// ("10605") or a number (10605).
+func busyCodeOf(raw json.RawMessage) string {
+	var s string
+	if json.Unmarshal(raw, &s) == nil {
+		return s
+	}
+	var n float64
+	if json.Unmarshal(raw, &n) == nil && n == float64(int64(n)) {
+		return strconv.FormatInt(int64(n), 10)
+	}
+	return ""
+}
+
+// busyFromAuthEnvelope parses a 401/403 response body and returns a
+// BusyError when it is a queue/concurrency rejection rather than an auth
+// failure. Bodies seen in the wild are prefixed with an upstream status
+// ("403 {..."), so decoding starts at the first '{'.
+func busyFromAuthEnvelope(statusCode int, body []byte) *BusyError {
+	s := strings.TrimSpace(string(body))
+	if i := strings.IndexByte(s, '{'); i > 0 {
+		s = s[i:]
+	}
+	var outer struct {
+		Code    json.RawMessage `json:"code"`
+		Message string          `json:"message"`
+	}
+	if json.Unmarshal([]byte(s), &outer) != nil || busyCodeOf(outer.Code) != QoderBusyCode {
+		return nil
+	}
+	busy := &BusyError{StatusCode: statusCode, Code: QoderBusyCode}
+	if outer.Message != "" {
+		busy.Message = truncateBusyMessage(outer.Message)
+		busy.RetryAfter = busyMeta(outer.Message)
+	}
+	return busy
+}
+
 // --- Signature API Client ---
 
 func commonHeaders(machineID, machineToken, machineType, date, sig string) http.Header {
@@ -381,9 +479,12 @@ func postEncoded(ctx context.Context, urlStr string, obj interface{}, machineID,
 	defer resp.Body.Close()
 
 	if resp.StatusCode != 200 {
-		detail, _ := io.ReadAll(io.LimitReader(resp.Body, 300))
+		detail, _ := io.ReadAll(io.LimitReader(resp.Body, errBodyCap))
 		drainBody(resp.Body)
 		if resp.StatusCode == 401 || resp.StatusCode == 403 {
+			if busy := busyFromAuthEnvelope(resp.StatusCode, detail); busy != nil {
+				return nil, busy
+			}
 			return nil, &AuthError{StatusCode: resp.StatusCode, Detail: string(detail)}
 		}
 		return nil, fmt.Errorf("HTTP %d at %s body=%s", resp.StatusCode, urlStr, string(detail))
@@ -537,9 +638,12 @@ func call(ctx context.Context, sess *SessionContext, method, fullURL string, jso
 	defer resp.Body.Close()
 
 	if resp.StatusCode != 200 {
-		detail, _ := io.ReadAll(io.LimitReader(resp.Body, 300))
+		detail, _ := io.ReadAll(io.LimitReader(resp.Body, errBodyCap))
 		drainBody(resp.Body)
 		if resp.StatusCode == 401 || resp.StatusCode == 403 {
+			if busy := busyFromAuthEnvelope(resp.StatusCode, detail); busy != nil {
+				return nil, busy
+			}
 			return nil, &AuthError{StatusCode: resp.StatusCode, Detail: string(detail)}
 		}
 		return nil, fmt.Errorf("HTTP %d body=%s", resp.StatusCode, string(detail))
@@ -631,7 +735,9 @@ func isDoneLine(line string) bool {
 	if payload == "[DONE]" {
 		return true
 	}
-	var env struct{ Body string `json:"body"` }
+	var env struct {
+		Body string `json:"body"`
+	}
 	if json.Unmarshal([]byte(payload), &env) == nil && env.Body == "[DONE]" {
 		return true
 	}
@@ -674,12 +780,12 @@ func (e *inStreamError) Error() string {
 // from an SSE data line. Two shapes are recognized:
 //
 //  1. Envelope frame with an HTTP error status, e.g. (qmodel_preview
-//	     provider outage):
-//	     {"body":"{\"code\":\"provider_error\",\"message\":\"All backends failed\"...}",
-//	      "statusCodeValue":429,"statusCode":"TOO_MANY_REQUESTS"}
+//     provider outage):
+//     {"body":"{\"code\":\"provider_error\",\"message\":\"All backends failed\"...}",
+//     "statusCodeValue":429,"statusCode":"TOO_MANY_REQUESTS"}
 //
 //  2. Bare success:false gateway error frame, e.g.
-//	     {"success":false,"msgCode":500,"message":"Internal Server Error"}
+//     {"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 {
@@ -688,9 +794,9 @@ func detectInStreamGatewayError(line string) *inStreamError {
 	}
 	payload := strings.TrimSpace(line[len("data:"):])
 	var env struct {
-		Body          string `json:"body"`
-		StatusCode    string `json:"statusCode"`
-		StatusValue   int    `json:"statusCodeValue"`
+		Body        string `json:"body"`
+		StatusCode  string `json:"statusCode"`
+		StatusValue int    `json:"statusCodeValue"`
 	}
 	if err := json.Unmarshal([]byte(payload), &env); err != nil {
 		return nil
@@ -707,10 +813,10 @@ func detectInStreamGatewayError(line string) *inStreamError {
 		return nil
 	}
 	var bare struct {
-		Success  bool             `json:"success"`
-		MsgCode  int              `json:"msgCode"`
-		MsgInfo  string           `json:"msgInfo"`
-		Message  string           `json:"message"`
+		Success bool   `json:"success"`
+		MsgCode int    `json:"msgCode"`
+		MsgInfo string `json:"msgInfo"`
+		Message string `json:"message"`
 	}
 	if err := json.Unmarshal([]byte(payload), &bare); err != nil {
 		return nil
@@ -775,9 +881,12 @@ func OpenStreamLines(ctx context.Context, sess *SessionContext, fullURL string,
 	defer resp.Body.Close()
 
 	if resp.StatusCode != 200 {
-		errBody, _ := io.ReadAll(io.LimitReader(resp.Body, 300))
+		errBody, _ := io.ReadAll(io.LimitReader(resp.Body, errBodyCap))
 		drainBody(resp.Body)
 		if resp.StatusCode == 401 || resp.StatusCode == 403 {
+			if busy := busyFromAuthEnvelope(resp.StatusCode, errBody); busy != nil {
+				return busy
+			}
 			return &AuthError{StatusCode: resp.StatusCode, Detail: string(errBody)}
 		}
 		return fmt.Errorf("HTTP %d %s", resp.StatusCode, string(errBody))
@@ -861,6 +970,9 @@ func OpenStreamLines(ctx context.Context, sess *SessionContext, fullURL string,
 		if e := detectInStreamGatewayError(line); e != nil && gwErr == nil {
 			gwErr = e
 		}
+		if busy := detectInStreamBusyError(line); busy != nil {
+			return busy
+		}
 		isAuthErr, detail := detectInStreamAuthError(line)
 		if isAuthErr {
 			return &AuthError{StatusCode: 401, Detail: detail}
@@ -889,7 +1001,57 @@ func OpenStreamLines(ctx context.Context, sess *SessionContext, fullURL string,
 	return nil
 }
 
+// detectInStreamBusyError reports whether an SSE frame carries the
+// gateway's queue/concurrency rejection (code 10605) under a 401/403
+// statusCodeValue. Such frames look like auth failures but are admission-
+// control refusals; the caller should back off instead of refreshing tokens.
+func detectInStreamBusyError(line string) *BusyError {
+	s := strings.TrimSpace(line)
+	if !strings.HasPrefix(s, "data:") {
+		return nil
+	}
+	// Cheap pre-filter: busy frames always ride a statusCodeValue envelope.
+	// Without this every content delta (potentially large base64 payloads)
+	// would pay a full JSON unmarshal per line.
+	if !strings.Contains(s, "statusCodeValue") {
+		return nil
+	}
+	var obj map[string]interface{}
+	if err := json.Unmarshal([]byte(strings.TrimSpace(s[5:])), &obj); err != nil {
+		return nil
+	}
+	scv, ok := obj["statusCodeValue"].(float64)
+	if !ok || (scv != 401 && scv != 403) {
+		return nil
+	}
+	bodyMap, ok := parseBody(obj).(map[string]interface{})
+	if !ok {
+		return nil
+	}
+	var code string
+	switch c := bodyMap["code"].(type) {
+	case string:
+		code = c
+	case float64:
+		if c == float64(int64(c)) {
+			code = strconv.FormatInt(int64(c), 10)
+		}
+	}
+	if code != QoderBusyCode {
+		return nil
+	}
+	busy := &BusyError{StatusCode: int(scv), Code: code}
+	if msg, _ := bodyMap["message"].(string); msg != "" {
+		busy.Message = truncateBusyMessage(msg)
+		busy.RetryAfter = busyMeta(msg)
+	}
+	return busy
+}
+
 // detectInStreamAuthError detects auth failures inside the SSE stream.
+// Queue/concurrency rejections (code 10605) share the 401/403 envelope but
+// are NOT auth failures; they are left to detectInStreamBusyError so callers
+// can distinguish "token expired" (refresh + retry) from "back off".
 func detectInStreamAuthError(line string) (bool, string) {
 	s := strings.TrimSpace(line)
 	if !strings.HasPrefix(s, "data:") {
@@ -899,6 +1061,9 @@ func detectInStreamAuthError(line string) (bool, string) {
 	if err := json.Unmarshal([]byte(strings.TrimSpace(s[5:])), &obj); err != nil {
 		return false, ""
 	}
+	if detectInStreamBusyError(line) != nil {
+		return false, ""
+	}
 	scv, ok := obj["statusCodeValue"].(float64)
 	if ok && (scv == 401 || scv == 403) {
 		return true, fmt.Sprintf("%v %s", scv, extractBodyMessage(obj))
 
@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"net/http/httptest"
+	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -264,3 +265,87 @@ func TestOpenStreamLinesIdleTimeout(t *testing.T) {
 		t.Errorf("idle timeout fired too late: %s", elapsed)
 	}
 }
+
+// TestBusyErrorParsing locks the classification of gateway admission-control
+// rejections (code 10605): they must surface as BusyError, never AuthError,
+// regardless of whether they arrive as an HTTP 401/403 body or an in-stream
+// control frame.
+func TestBusyErrorParsing(t *testing.T) {
+	// HTTP envelope: body prefixed with the upstream status ("403 {...").
+	envBody := []byte(`403 {"code":"10605","message":"{\"isQueued\":false,\"modelKey\":\"qmodel_38max\",\"queueCount\":0,\"queueType\":\"slow\",\"retryAfterSeconds\":2,\"serviceAvailable\":true,\"waitTime\":0}"}`)
+	busy := busyFromAuthEnvelope(401, envBody)
+	if busy == nil {
+		t.Fatal("expected BusyError from 10605 envelope, got nil")
+	}
+	if busy.RetryAfter != 2*time.Second {
+		t.Errorf("RetryAfter = %v, want 2s", busy.RetryAfter)
+	}
+
+	// A genuine auth failure must still classify as AuthError.
+	if busyFromAuthEnvelope(403, []byte(`{"code":"401","message":"unauthorized"}`)) != nil {
+		t.Error("non-10605 body must not be a BusyError")
+	}
+
+	// In-stream frame with statusCodeValue 403 + code 10605.
+	frame := `data: {"body":"{\"code\":\"10605\",\"message\":\"{\\\"retryAfterSeconds\\\":2}\"}","statusCode":"FORBIDDEN","statusCodeValue":403}`
+	inStream := detectInStreamBusyError(frame)
+	if inStream == nil {
+		t.Fatal("expected BusyError from in-stream 10605 frame, got nil")
+	}
+	if inStream.RetryAfter != 2*time.Second {
+		t.Errorf("in-stream RetryAfter = %v, want 2s", inStream.RetryAfter)
+	}
+	// ...and must NOT be misread as an auth error.
+	if isAuth, _ := detectInStreamAuthError(frame); isAuth {
+		t.Error("10605 frame must not be classified as an auth error")
+	}
+}
+
+// Numeric "code" variants (10605 as a JSON number instead of a string) must
+// still classify as busy, on both the HTTP-envelope and in-stream paths.
+func TestBusyErrorNumericCode(t *testing.T) {
+	env := []byte(`{"code":10605,"message":"{\"retryAfterSeconds\":3}"}`)
+	busy := busyFromAuthEnvelope(403, env)
+	if busy == nil {
+		t.Fatal("expected BusyError for numeric code, got nil")
+	}
+	if busy.RetryAfter != 3*time.Second {
+		t.Errorf("RetryAfter = %v, want 3s", busy.RetryAfter)
+	}
+
+	frame := `data: {"body":"{\"code\":10605,\"message\":\"{}\"}","statusCodeValue":401}`
+	if detectInStreamBusyError(frame) == nil {
+		t.Fatal("expected BusyError for numeric in-stream code, got nil")
+	}
+}
+
+// A truncated 10605 body (larger than the read cap) must not silently fall
+// back to AuthError classification.
+func TestBusyErrorFromLongBody(t *testing.T) {
+	longMsg := `{"isQueued":false,"modelKey":"` + strings.Repeat("m", 4096) + `","retryAfterSeconds":2}`
+	body := []byte(`{"code":"10605","message":` + strconv.Quote(longMsg) + `}`)
+	if busyFromAuthEnvelope(401, body) == nil {
+		t.Fatal("expected BusyError for long 10605 body within read cap, got nil")
+	}
+}
+
+// The upstream-provided message echoed into errors must be length-capped.
+func TestBusyErrorMessageCapped(t *testing.T) {
+	msg := strings.Repeat("x", 10000)
+	busy := busyFromAuthEnvelope(403, []byte(`{"code":"10605","message":"`+msg+`"}`))
+	if busy == nil {
+		t.Fatal("expected BusyError")
+	}
+	if got := len([]rune(busy.Message)); got > maxBusyMessageRunes+10 {
+		t.Errorf("message not capped: %d runes", got)
+	}
+}
+
+// Content-delta frames without a statusCodeValue envelope must skip the busy
+// pre-filter cheaply (no false positives either way).
+func TestDetectInStreamBusyIgnoresPlainDeltas(t *testing.T) {
+	line := `data: {"body":"{\"choices\":[{\"delta\":{\"content\":\"hi\"}}]}"}`
+	if detectInStreamBusyError(line) != nil {
+		t.Error("plain content delta must not be classified as busy")
+	}
+}