codex-multi-auth 2.22.0 → 2.23.0

package/dist/lib/runtime/responses-websocket.js

@@ -1,3 +1,5 @@
+import { MAX_API_ROUTES } from "../api-route-store.js";
+import { OPENAI_HEADER_VALUES } from "../constants.js";
 import { ClientCancellationError } from "../request/client-cancellation.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash, randomUUID } from "node:crypto";
@@ -7,6 +9,13 @@ import { parseModelRoute } from "../model-route-policy.js";
 import { isRecord } from "../utils.js";
 import { ResponseOutputHistory, hasOrphanToolResult } from "./response-output-history.js";
 const CONTEXT_HEADER = "x-local-responses-transport";
+const HTTP_FALLBACK_COOLDOWN_MS = 60_000;
+const MAX_HTTP_FALLBACK_SCOPES = 256;
+const HTTP_FALLBACK_FAILURE_THRESHOLD = 2;
+const MAX_CLIENT_SESSIONS = 64;
+// Conservative request ceiling below observed upstream 1009 rejections. This
+// is a local routing guard, not a claim about the upstream's undocumented cap.
+const MAX_UPSTREAM_WEBSOCKET_REQUEST_BYTES = 8 * 1024 * 1024;
 const terminal = new Set([
     "response.completed",
     "response.failed",
@@ -14,6 +23,28 @@ const terminal = new Set([
     "response.cancelled",
     "error",
 ]);
+/** A thread-scoped hint only; authentication is checked separately before use. */
+function fallbackScope(req) {
+    // Native clients can share a session across threads. Prefer the conversation
+    // identity so a failed thread does not downgrade a healthy sibling.
+    // Current native clients send hyphenated names; retain older underscore
+    // aliases, with thread identity taking priority over a shared session.
+    const identity = ["thread-id", "conversation_id", "session-id", "session_id"]
+        .map(name => req.headers[name])
+        .find((value) => typeof value === "string" && !!value.trim())
+        ?.trim();
+    if (!identity || identity.length > 1024)
+        return undefined;
+    const bearer = req.headers.authorization?.match(/^Bearer\s+(.+)$/i)?.[1]?.trim();
+    const apiKey = req.headers["x-api-key"];
+    const credentials = [...new Set([
+            bearer,
+            typeof apiKey === "string" ? apiKey.trim() : undefined,
+        ].filter((value) => !!value))].sort();
+    if (!credentials.length)
+        return undefined;
+    return createHash("sha256").update(JSON.stringify([credentials, identity])).digest("hex");
+}
 /** Headers that describe the synthetic body or the upgrade itself, never the upstream decision. */
 const LOCAL_ONLY_HEADERS = /^(connection|upgrade|keep-alive|sec-websocket-.*|content-length|content-encoding|content-type|transfer-encoding|set-cookie)$/i;
 function upstreamHeaders(source) {
@@ -32,12 +63,12 @@ function upstreamHeaders(source) {
     }
     return headers;
 }
-/** Union of comma-separated OpenAI-Beta features; the client's own flags are kept. */
+/** Remove the router's HTTP-only flag; preserve every explicit client beta. */
 function mergeBeta(current, client) {
-    if (!client)
-        return current;
-    const features = [...(current ?? "").split(","), ...client.split(",")].map(item => item.trim()).filter(Boolean);
-    return [...new Set(features)].join(", ") || null;
+    const routingFlags = (current ?? "").split(",").map(item => item.trim())
+        .filter(item => item && item !== OPENAI_HEADER_VALUES.BETA_RESPONSES);
+    const clientFlags = (client ?? "").split(",").map(item => item.trim()).filter(Boolean);
+    return [...new Set([...routingFlags, ...clientFlags])].join(", ") || null;
 }
 function wireError(code, status = 400) {
     return {
@@ -60,24 +91,35 @@ function bodyJson(body) {
         throw Error("Invalid response body");
     return value;
 }
+function transportErrorCode(error) {
+    const code = isRecord(error) ? error.code : undefined;
+    return code === "ECONNRESET" || code === "EPIPE" || code === "ETIMEDOUT" ? code : "OTHER";
+}
 /** Per-client memory only; credentials never leave the existing routing boundary. */
 class SocketSession {
     maxBytes;
     stats;
     httpFetch;
+    onDisconnect;
+    onComplete;
+    needsHttpRecovery;
+    httpOnly;
     channels = new Map();
     openedAt = new WeakMap();
+    transportEvidence = new WeakMap();
     owners = new Map();
     chains = new Map();
-    /** Credentials whose WebSocket handshake was refused; they use HTTP for the session. */
-    httpOnly = new Set();
     bytes = 0;
     controller;
     closed = false;
-    constructor(maxBytes, stats, httpFetch = fetch) {
+    constructor(maxBytes, stats, httpFetch = fetch, onDisconnect, onComplete, needsHttpRecovery = () => false, httpOnly = new Map()) {
         this.maxBytes = maxBytes;
         this.stats = stats;
         this.httpFetch = httpFetch;
+        this.onDisconnect = onDisconnect;
+        this.onComplete = onComplete;
+        this.needsHttpRecovery = needsHttpRecovery;
+        this.httpOnly = httpOnly;
     }
     close() {
         this.closed = true;
@@ -92,7 +134,7 @@ class SocketSession {
     remember(id, body, output, pool) {
         const bytes = Buffer.byteLength(JSON.stringify({ body, output }));
         if (bytes > this.maxBytes)
-            return;
+            return false;
         const old = this.chains.get(id);
         if (old)
             this.bytes -= old.bytes;
@@ -108,6 +150,21 @@ class SocketSession {
             this.chains.delete(first);
             this.owners.delete(first);
         }
+        return true;
+    }
+    httpRecovery(input, init, body) {
+        // generate=false is a WebSocket-only prewarm control. Never turn a
+        // transport warmup into a generating HTTP request. The local chain is
+        // remembered by serve(), so the next create can reconstruct its input.
+        if (body.generate === false) {
+            return Promise.resolve(new Response(`data: ${JSON.stringify({
+                type: "response.completed",
+                response: { id: `resp_local_prewarm_${randomUUID()}`, object: "response", status: "completed", output: [] },
+            })}\n\n`, { headers: { "content-type": "text/event-stream" } }));
+        }
+        // This is a newly submitted create. Never retry a create already sent
+        // over a WebSocket; its generation outcome can be ambiguous.
+        return this.httpFetch(input, init);
     }
     async fetch(input, init, context) {
         if (context.signal.aborted || this.closed)
@@ -115,11 +172,14 @@ class SocketSession {
         const url = new URL(String(input));
         url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
         const headers = new Headers(init.headers);
-        // The routing pipeline stamps its HTTP beta flag; the native client's
-        // WebSocket flag (e.g. responses_websockets=<date>) must survive the hop.
+        // The OAuth HTTP beta selects an incompatible upstream protocol when
+        // combined with the native WebSocket beta (metadata then close 1011).
+        // Keep the original client flags, without the router's HTTP injection.
         const beta = mergeBeta(headers.get("openai-beta"), context.clientBeta);
         if (beta)
             headers.set("openai-beta", beta);
+        else
+            headers.delete("openai-beta");
         const key = createHash("sha256")
             .update(url.toString())
             .update("\0")
@@ -127,12 +187,15 @@ class SocketSession {
             .update("\0")
             .update(headers.get("chatgpt-account-id") ?? "")
             .digest("hex");
-        // API/ZDR credentials are not ChatGPT workspaces: when their WebSocket
-        // handshake is refused, the turn (and the session) uses plain HTTP.
         const apiCredential = !headers.has("chatgpt-account-id");
-        if (apiCredential && this.httpOnly.has(key))
-            return this.httpFetch(input, init);
         const body = bodyJson(init.body);
+        for (const [credential, until] of this.httpOnly) {
+            if (until <= Date.now())
+                this.httpOnly.delete(credential);
+        }
+        if (this.needsHttpRecovery() || (apiCredential && this.httpOnly.has(key))) {
+            return this.httpRecovery(input, init, body);
+        }
         delete body.stream;
         delete body.background;
         body.store = false;
@@ -152,6 +215,13 @@ class SocketSession {
         else if (context.previousId && hasOrphanToolResult(body.input)) {
             return Response.json(wireError("previous_response_not_found"), { status: 400 });
         }
+        const serializedBody = JSON.stringify(body);
+        // Measure the actual UTF-8 create after connection-local delta reduction.
+        // HTTP receives the original reconstructed request, never a WS-only delta.
+        if (Buffer.byteLength(serializedBody) > MAX_UPSTREAM_WEBSOCKET_REQUEST_BYTES) {
+            return this.httpRecovery(input, init, body);
+        }
+        const reusedConnection = !!socket;
         let handshakeHeaders;
         if (!socket) {
             if (context.signal.aborted || this.closed)
@@ -178,7 +248,16 @@ class SocketSession {
                 followRedirects: false,
                 handshakeTimeout: 15000,
                 maxPayload: this.maxBytes,
-                perMessageDeflate: false,
+                // Offer native compression with modest zlib work and request dictionary
+                // resets. Message limits also apply after inflation; peers can decline
+                // the extension and continue using WebSockets.
+                perMessageDeflate: {
+                    clientNoContextTakeover: true,
+                    serverNoContextTakeover: true,
+                    concurrencyLimit: 4,
+                    threshold: 1024,
+                    zlibDeflateOptions: { level: 3 },
+                },
             });
             const opening = socket;
             const rejected = await new Promise((resolve, reject) => {
@@ -195,6 +274,20 @@ class SocketSession {
                 init.signal?.addEventListener("abort", abort, { once: true });
                 opening.once("upgrade", (response) => {
                     handshakeHeaders = upstreamHeaders(response.headers);
+                    // ws consumes TCP/TLS errors without re-emitting them. Observe
+                    // the public upgrade socket before its close handler runs.
+                    const tcp = response.socket;
+                    const evidence = { tcpEndReceived: false };
+                    this.transportEvidence.set(opening, evidence);
+                    const onEnd = () => { evidence.tcpEndReceived = true; };
+                    const onError = (error) => { evidence.transportErrorCode = transportErrorCode(error); };
+                    tcp.once("end", onEnd);
+                    tcp.once("error", onError);
+                    tcp.once("close", (hadError) => {
+                        evidence.tcpCloseHadError = hadError;
+                        tcp.off("end", onEnd);
+                        tcp.off("error", onError);
+                    });
                 });
                 opening.once("open", () => {
                     cleanup();
@@ -222,8 +315,13 @@ class SocketSession {
             if (rejected) {
                 if (!apiCredential)
                     return rejected;
-                this.httpOnly.add(key);
-                return this.httpFetch(input, init);
+                if (!this.httpOnly.has(key) && this.httpOnly.size >= MAX_API_ROUTES) {
+                    const oldest = this.httpOnly.keys().next().value;
+                    if (oldest)
+                        this.httpOnly.delete(oldest);
+                }
+                this.httpOnly.set(key, Date.now() + HTTP_FALLBACK_COOLDOWN_MS);
+                return this.httpRecovery(input, init, body);
             }
             this.openedAt.set(socket, Date.now());
             this.channels.set(key, socket);
@@ -233,6 +331,8 @@ class SocketSession {
             let accepted = false, finished = false;
             let bodyCancelled = false;
             let eventCount = 0;
+            let sendCompleted = false;
+            let requestTransportErrorCode;
             let streamController;
             const stream = new ReadableStream({
                 start(controller) {
@@ -258,12 +358,25 @@ class SocketSession {
                 this.channels.delete(key);
                 const cancelled = bodyCancelled || init.signal?.aborted || context.signal.aborted || this.closed;
                 if (!cancelled) {
+                    this.onDisconnect?.();
                     const at = Date.now();
+                    const transport = this.transportEvidence.get(active);
+                    const errorCode = transport?.transportErrorCode ?? requestTransportErrorCode;
                     this.stats.lastDisconnect = {
                         at, cause, routeKind: context.routeKind,
                         connectionAgeMs: Math.max(0, at - (this.openedAt.get(active) ?? at)), eventCount,
                         stage: accepted ? "streaming" : "awaiting_first_event",
                         ...(typeof closeCode === "number" ? { closeCode } : {}),
+                        requestBytes: Buffer.byteLength(serializedBody),
+                        ...(Array.isArray(body.input) ? { inputItemCount: body.input.length } : {}),
+                        isPrewarm: body.generate === false,
+                        hasPreviousResponse: typeof body.previous_response_id === "string" && body.previous_response_id.length > 0,
+                        reusedConnection, sendCompleted,
+                        compressionNegotiated: active.extensions.split(",").some(extension => extension.trim() === "permessage-deflate"),
+                        ...(transport ? { tcpEndReceived: transport.tcpEndReceived,
+                            ...(transport.tcpCloseHadError !== undefined ? { tcpCloseHadError: transport.tcpCloseHadError } : {}),
+                        } : {}),
+                        ...(errorCode ? { transportErrorCode: errorCode } : {}),
                     };
                 }
                 // Once create has been sent, a disconnect cannot prove generation
@@ -284,7 +397,10 @@ class SocketSession {
                 }
             };
             const onSocketClose = (code) => onClose(code);
-            const onError = () => onClose(undefined, "transport_error");
+            const onError = (error) => {
+                requestTransportErrorCode = transportErrorCode(error);
+                onClose(undefined, "transport_error");
+            };
             const abort = () => active.terminate();
             const onMessage = (raw, isBinary) => {
                 let failureCause = "invalid_event";
@@ -330,6 +446,10 @@ class SocketSession {
                         }
                     }
                     if (terminal.has(event.type)) {
+                        // A prewarm completion proves only connection setup, not that
+                        // generation works. It must not erase a real disconnect history.
+                        if (event.type === "response.completed" && body.generate !== false)
+                            this.onComplete?.();
                         finished = true;
                         cleanup();
                         streamController.close();
@@ -350,11 +470,14 @@ class SocketSession {
                 return;
             }
             this.stats.upstreamRequests++;
-            active.send(JSON.stringify(body), (error) => {
+            active.send(serializedBody, (error) => {
                 if (error) {
+                    requestTransportErrorCode = transportErrorCode(error);
                     onClose(undefined, "send_error");
                     active.terminate();
                 }
+                else
+                    sendCompleted = true;
             });
         });
     }
@@ -365,12 +488,17 @@ export class ResponsesWebSocketGateway {
     options;
     stats = {
         connections: 0,
+        activeConnections: 0,
+        capacityReclaims: 0,
         upstreamConnections: 0,
         upstreamRequests: 0,
     };
     contexts = new Map();
     scope = new AsyncLocalStorage();
-    sessions = new Set();
+    sessions = new Map();
+    /** Credential-hashed, bounded API handshake backoff survives local reconnects. */
+    apiHandshakeBackoff = new Map();
+    websocketFailures = new Map();
     wss;
     maxBytes;
     /** Loopback hops must never go through an environment HTTP proxy (NODE_USE_ENV_PROXY). */
@@ -384,6 +512,22 @@ export class ResponsesWebSocketGateway {
             noServer: true,
             maxPayload: this.maxBytes,
             perMessageDeflate: false,
+            // ws validates method/key/version/subprotocol before this synchronous gate.
+            // An invalid newcomer must never evict an existing usable connection.
+            verifyClient: ({ req }, done) => {
+                if (req.socket.destroyed || !req.socket.readable || !req.socket.writable) {
+                    done(false, 503);
+                    return;
+                }
+                if (this.sessions.size >= MAX_CLIENT_SESSIONS && !this.reclaimIdleSession()) {
+                    // Capacity is not an authentication failure. Native Codex handles
+                    // 426 immediately instead of retrying five rejected handshakes.
+                    this.recordUpgradeRejection("capacity", 426);
+                    done(false, 426);
+                    return;
+                }
+                done(true);
+            },
         });
     }
     fetch = async (input, init) => {
@@ -394,6 +538,54 @@ export class ResponsesWebSocketGateway {
             return context.session.fetch(input, init, context);
         return this.upstreamFetch(input, init);
     };
+    rememberDisconnect(scope) {
+        if (!scope)
+            return;
+        const now = Date.now();
+        for (const [key, failure] of this.websocketFailures) {
+            if (failure.until <= now)
+                this.websocketFailures.delete(key);
+        }
+        const count = Math.min((this.websocketFailures.get(scope)?.count ?? 0) + 1, HTTP_FALLBACK_FAILURE_THRESHOLD);
+        this.websocketFailures.delete(scope);
+        this.websocketFailures.set(scope, { until: now + HTTP_FALLBACK_COOLDOWN_MS, count });
+        while (this.websocketFailures.size > MAX_HTTP_FALLBACK_SCOPES) {
+            const oldest = this.websocketFailures.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.websocketFailures.delete(oldest);
+        }
+    }
+    needsHttpFallback(req) {
+        const scope = fallbackScope(req);
+        if (!scope)
+            return false;
+        const failure = this.websocketFailures.get(scope);
+        if (!failure)
+            return false;
+        if (failure.until > Date.now())
+            return failure.count >= HTTP_FALLBACK_FAILURE_THRESHOLD;
+        this.websocketFailures.delete(scope);
+        return false;
+    }
+    /** One writer for the upgrade-rejection diagnostic so the two reject paths cannot drift. */
+    recordUpgradeRejection(reason, status) {
+        this.stats.lastUpgradeRejection = { at: Date.now(), reason, status, activeConnections: this.sessions.size };
+    }
+    /** Release idle setup sockets only; active work and generated history stay pinned. */
+    reclaimIdleSession() {
+        for (const [session, client] of this.sessions) {
+            if (!client.canReclaim())
+                continue;
+            this.sessions.delete(session);
+            this.stats.activeConnections = this.sessions.size;
+            this.stats.capacityReclaims++;
+            session.close();
+            client.socket.terminate();
+            return true;
+        }
+        return false;
+    }
     handle(req, handler) {
         const id = req.headers[CONTEXT_HEADER];
         delete req.headers[CONTEXT_HEADER];
@@ -416,6 +608,12 @@ export class ResponsesWebSocketGateway {
                     return;
                 socket.end(`HTTP/1.1 ${status} Rejected\r\nConnection: close\r\nContent-Length: 0\r\n\r\n`);
             };
+            const rejectAdmission = (reason, status) => {
+                if (socket.destroyed)
+                    return;
+                this.recordUpgradeRejection(reason, status);
+                reject(status);
+            };
             void (async () => {
                 const credentials = {};
                 for (const name of ["authorization", "x-api-key"]) {
@@ -436,7 +634,7 @@ export class ResponsesWebSocketGateway {
                     return;
                 }
                 if (req.headers.origin) {
-                    reject(403);
+                    rejectAdmission("origin", 403);
                     return;
                 }
                 if (await this.options.upgrade?.(req, socket, head))
@@ -450,8 +648,11 @@ export class ResponsesWebSocketGateway {
                     reject(404);
                     return;
                 }
-                if (req.headers.origin || this.sessions.size >= 64) {
-                    reject(403);
+                // Keep native transport on WebSocket during temporary upstream
+                // HTTP recovery. At capacity, preserve admission behavior rather
+                // than evicting another session just to serve a recovery scope.
+                if (this.needsHttpFallback(req) && this.sessions.size >= MAX_CLIENT_SESSIONS) {
+                    rejectAdmission("repeated_disconnect", 426);
                     return;
                 }
                 if (socket.destroyed)
@@ -462,10 +663,18 @@ export class ResponsesWebSocketGateway {
     }
     serve(ws, req, baseUrl) {
         this.stats.connections++;
-        const session = new SocketSession(this.maxBytes, this.stats, this.upstreamFetch);
-        this.sessions.add(session);
+        const scope = fallbackScope(req);
+        const session = new SocketSession(this.maxBytes, this.stats, this.upstreamFetch, () => this.rememberDisconnect(scope), () => { if (scope)
+            this.websocketFailures.delete(scope); }, () => this.needsHttpFallback(req), this.apiHandshakeBackoff);
         let queue = Promise.resolve(), queued = 0, queuedBytes = 0;
         let generation = 0;
+        // Pending work is protected by queued/controller; rejected creates retain no history.
+        let hasGeneratedHistory = false;
+        this.sessions.set(session, {
+            socket: ws,
+            canReclaim: () => !hasGeneratedHistory && queued === 0 && !session.controller && !session.closed && ws.readyState === WebSocket.OPEN,
+        });
+        this.stats.activeConnections = this.sessions.size;
         const send = (event) => {
             if (ws.readyState !== WebSocket.OPEN)
                 return;
@@ -479,6 +688,7 @@ export class ResponsesWebSocketGateway {
         ws.once("close", () => {
             session.close();
             this.sessions.delete(session);
+            this.stats.activeConnections = this.sessions.size;
         });
         ws.on("message", (raw, isBinary) => {
             let event;
@@ -622,8 +832,8 @@ export class ResponsesWebSocketGateway {
                                     isRecord(parsed.response) &&
                                     typeof parsed.response.id === "string") {
                                     const output = outputHistory.finish(parsed.response.output);
-                                    if (output)
-                                        session.remember(parsed.response.id, body, output, pool);
+                                    if (output && session.remember(parsed.response.id, body, output, pool) && body.generate !== false)
+                                        hasGeneratedHistory = true;
                                 }
                                 send(parsed);
                             }
@@ -649,9 +859,13 @@ export class ResponsesWebSocketGateway {
     close() {
         for (const ws of this.wss.clients)
             ws.terminate();
-        for (const session of this.sessions)
+        for (const session of this.sessions.keys())
             session.close();
+        this.sessions.clear();
+        this.stats.activeConnections = 0;
         this.contexts.clear();
+        this.websocketFailures.clear();
+        this.apiHandshakeBackoff.clear();
         this.wss.close();
         void this.loopback.close().catch(() => undefined);
     }

package/dist/lib/runtime/rotation-account-selection.d.ts

@@ -62,16 +62,17 @@ export declare function chooseAccount(params: {
     /**
      * Admit a pinned account that is only blocked by its own cooldown.
      *
-     * Set by the proxy for the RETRY passes of one pinned request, never for
-     * the first pass. A cooldown exists to keep OTHER requests off a flaky
-     * account; a retry budget exists to give THIS request another attempt.
+     * Set by the proxy for RETRY passes, or the first pass when a pin only
+     * has a shared network-error cooldown. Independent concurrent work must
+     * not fail solely because another request encountered a transport error.
+     * Other cooldown reasons still protect the pin from new requests.
      * Conflating them meant every transient branch cooled the pin down before
      * the next selection pass and the budget could never be spent — a pinned
      * request got exactly one upstream attempt under shipped defaults.
      *
      * Only the cooldown is waived. Rate limits, an open circuit, a disabled
      * account, workspace and policy blocks all still reject the pin, and the
-     * cooldown itself stays on the account for everyone else and for the 503's
+     * cooldown itself stays on the account for unpinned selection and the 503's
      * `retry_after_ms`.
      *
      * One ordering note: `getAccountRuntimeSkipReason` reports the FIRST

package/dist/lib/runtime/rotation-server-types.d.ts

@@ -1,4 +1,4 @@
-import type { WebSocketDisconnectDiagnostic } from "./responses-websocket.js";
+import type { WebSocketDisconnectDiagnostic, WebSocketUpgradeRejectionDiagnostic } from "./responses-websocket.js";
 import type { QuotaCacheData } from "../quota-cache.js";
 import type { ApiRouteCredential } from "../api-route-store.js";
 import type { AccountStorageV3 } from "../storage.js";
@@ -24,6 +24,9 @@ export interface RuntimeRotationProxyStatus {
     lastStreamQuotaUpdateAt?: number;
     websocketConnections?: number;
     websocketUpstreamRequests?: number;
+    websocketActiveConnections?: number;
+    websocketCapacityReclaims?: number;
+    lastWebsocketUpgradeRejection?: WebSocketUpgradeRejectionDiagnostic;
     lastWebsocketDisconnect?: WebSocketDisconnectDiagnostic;
     startedAt: number;
     totalRequests: number;

package/dist/lib/runtime-rotation-proxy.js

@@ -2,6 +2,7 @@ import { createAutomaticApiCheck, startAutomaticApiChecks } from "./runtime/auto
 import { startAutomaticAccountChecks } from "./runtime/automatic-account-checks.js";
 import { createAutomaticSubscriptionCheck } from "./runtime/automatic-subscription-checks.js";
 import { ClientCancellationError } from "./request/client-cancellation.js";
+import { fetchWithProxy } from "./request/proxy-fetch.js";
 import { createNativeAccountStorageReader } from "./runtime/native-account-storage.js";
 import { resetSnapshotQuota } from "./runtime/reset-credits.js";
 import { createResetCreditService, loadResetCreditState } from "./runtime/account-reset-credits.js";
@@ -879,7 +880,7 @@ export async function startRuntimeRotationProxy(options) {
     const routingMutexMode = getRoutingMutexMode(pluginConfig);
     activeAccountManager.setRoutingMutexMode(routingMutexMode);
     const schedulingStrategy = getSchedulingStrategy(pluginConfig);
-    const fetchImpl = options.fetchImpl ?? fetch;
+    const fetchImpl = options.fetchImpl ?? fetchWithProxy;
     const host = options.host ?? DEFAULT_HOST;
     // Defense in depth (runtime-proxy-01): the proxy presents managed OAuth tokens
     // and must never be reachable off-box. It is loopback-only with NO opt-out —
@@ -1057,6 +1058,9 @@ export async function startRuntimeRotationProxy(options) {
             schedulingStrategy: state.schedulingStrategy,
             websocketConnections: websocketGateway.stats.connections,
             websocketUpstreamRequests: websocketGateway.stats.upstreamRequests,
+            websocketActiveConnections: websocketGateway.stats.activeConnections,
+            websocketCapacityReclaims: websocketGateway.stats.capacityReclaims,
+            lastWebsocketUpgradeRejection: websocketGateway.stats.lastUpgradeRejection,
             lastWebsocketDisconnect: websocketGateway.stats.lastDisconnect,
             // Redact any email/token material that leaked into a raw upstream or
             // refresh error string before exposing it to status/report consumers
@@ -1875,13 +1879,23 @@ async function handleRequestInner(state, req, res, traceId) {
                     models = await refresh;
                 else {
                     const cached = pickerSnapshot();
-                    if (cached.length)
+                    // An API cache can be warm while this client-version's OAuth
+                    // catalog is still cold. Give subscription discovery the same
+                    // bounded opportunity as an entirely empty picker.
+                    const oauthReady = modelCatalog.cachedList(routableKeys).length > 0 ||
+                        routableKeys.every(key => modelCatalog.hasUsablePickerSnapshot(key));
+                    if (cached.length && oauthReady)
                         models = cached;
                     else {
                         let timer;
                         try {
                             models = await Promise.race([refresh, new Promise(resolve => {
-                                    timer = setTimeout(() => resolve(pickerSnapshot()), 2000);
+                                    timer = setTimeout(() => {
+                                        // Do not let an incomplete API-only success replace the
+                                        // native client's complete cached catalog for minutes.
+                                        const missingSubscription = routableKeys.length > 0 && !modelCatalog.cachedList(routableKeys).length;
+                                        resolve(missingSubscription && routableKeys.some(key => !modelCatalog.hasUsablePickerSnapshot(key)) ? [] : pickerSnapshot());
+                                    }, 2000);
                                 })]);
                         }
                         finally {
@@ -1890,6 +1904,12 @@ async function handleRequestInner(state, req, res, traceId) {
                         }
                     }
                 }
+                // A completed failed fetch is still unknown, not a successful
+                // empty catalog. Never replace native subscription entries with
+                // an API-only success while a routable catalog is unknown.
+                if (!forceCatalogRefresh && !models.some(model => !/^(api|zdr)\//.test(model.slug)) &&
+                    routableKeys.some(key => !modelCatalog.hasUsablePickerSnapshot(key)))
+                    models = [];
                 res.setHeader("etag", setCatalogEtag(state, models));
                 writeJson(res, models.length ? 200 : 503, models.length
                     ? { models }
@@ -2194,12 +2214,13 @@ async function handleRequestInner(state, req, res, traceId) {
                     stickyBoostByAccount: rotationStickyBoost,
                     pidOffsetEnabled: state.pidOffsetEnabled,
                     schedulingStrategy: state.schedulingStrategy,
-                    // Only on a RETRY pass. The first pass still honors a cooldown
-                    // another request left on the pin, so an already-cooling pinned
-                    // account 503s immediately as before; from the second pass on,
-                    // this request's own retry budget outranks the cooldown it just
-                    // created for itself.
-                    allowPinnedCooldown: isPinned && transientAttempts > 0,
+                    // A shared network cooldown is not evidence that the pinned
+                    // credentials cannot serve independent concurrent work. Let each
+                    // new request try; its own retries remain bounded and backed off.
+                    // Other initial cooldowns still block, as do quota/auth/policy
+                    // checks and the circuit admission immediately after selection.
+                    allowPinnedCooldown: isPinned && (transientAttempts > 0 ||
+                        (typeof pinnedIndex === "number" && accountManager.getAccountByIndex(pinnedIndex)?.cooldownReason === "network-error")),
                 });
                 return result;
             };

package/dist/lib/schemas.d.ts

@@ -5,6 +5,11 @@
  */
 import { z } from "zod";
 export declare const PluginConfigSchema: z.ZodObject<{
+    locale: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        en: "en";
+        zh: "zh";
+    }>>;
     codexMode: z.ZodOptional<z.ZodBoolean>;
     codexRuntimeRotationProxy: z.ZodOptional<z.ZodBoolean>;
     codexTuiV2: z.ZodOptional<z.ZodBoolean>;

package/dist/lib/schemas.js

@@ -22,6 +22,7 @@ function schemaLog() {
 // Plugin Configuration Schema
 // ============================================================================
 export const PluginConfigSchema = z.object({
+    locale: z.enum(["auto", "en", "zh"]).optional(),
     codexMode: z.boolean().optional(),
     codexRuntimeRotationProxy: z.boolean().optional(),
     codexTuiV2: z.boolean().optional(),

package/dist/lib/web-dashboard-html.d.ts

@@ -0,0 +1 @@
+export declare function renderDashboardHtml(token: string | null, locale?: "en" | "zh"): string;