codex-multi-auth 2.21.0 → 2.23.0

package/dist/lib/runtime/responses-websocket.d.ts

@@ -1,17 +1,53 @@
 import type { Duplex } from "node:stream";
 import type { IncomingMessage, Server } from "node:http";
+/** Safe operational evidence only: never persist upstream reason text or payloads. */
+export interface WebSocketDisconnectDiagnostic {
+    at: number;
+    cause: "close" | "transport_error" | "invalid_event" | "buffer_limit" | "send_error";
+    stage: "awaiting_first_event" | "streaming";
+    closeCode?: number;
+    routeKind?: "oauth" | "api" | "zdr";
+    connectionAgeMs?: number;
+    eventCount?: number;
+    requestBytes?: number;
+    inputItemCount?: number;
+    isPrewarm?: boolean;
+    hasPreviousResponse?: boolean;
+    reusedConnection?: boolean;
+    /** Local send callback success, not evidence of upstream receipt. */
+    sendCompleted?: boolean;
+    compressionNegotiated?: boolean;
+    transportErrorCode?: "ECONNRESET" | "EPIPE" | "ETIMEDOUT" | "OTHER";
+    tcpEndReceived?: boolean;
+    tcpCloseHadError?: boolean;
+}
+/** Local admission evidence only; no headers, credentials, or conversation IDs. */
+export interface WebSocketUpgradeRejectionDiagnostic {
+    at: number;
+    reason: "origin" | "capacity" | "repeated_disconnect";
+    status: number;
+    activeConnections: number;
+}
+interface WebSocketStats {
+    connections: number;
+    activeConnections: number;
+    capacityReclaims: number;
+    upstreamConnections: number;
+    upstreamRequests: number;
+    lastDisconnect?: WebSocketDisconnectDiagnostic;
+    lastUpgradeRejection?: WebSocketUpgradeRejectionDiagnostic;
+}
 /** Adapts only the transport; authenticated HTTP routing remains the policy authority. */
 export declare class ResponsesWebSocketGateway {
     private readonly upstreamFetch;
     private readonly options;
-    readonly stats: {
-        connections: number;
-        upstreamConnections: number;
-        upstreamRequests: number;
-    };
+    readonly stats: WebSocketStats;
     private readonly contexts;
     private readonly scope;
     private readonly sessions;
+    /** Credential-hashed, bounded API handshake backoff survives local reconnects. */
+    private readonly apiHandshakeBackoff;
+    private readonly websocketFailures;
     private readonly wss;
     private readonly maxBytes;
     /** Loopback hops must never go through an environment HTTP proxy (NODE_USE_ENV_PROXY). */
@@ -23,8 +59,15 @@ export declare class ResponsesWebSocketGateway {
         routeModel?: (model: string, headers: Headers) => string;
     });
     readonly fetch: typeof fetch;
+    private rememberDisconnect;
+    private needsHttpFallback;
+    /** One writer for the upgrade-rejection diagnostic so the two reject paths cannot drift. */
+    private recordUpgradeRejection;
+    /** Release idle setup sockets only; active work and generated history stay pinned. */
+    private reclaimIdleSession;
     handle(req: IncomingMessage, handler: () => Promise<void>): void;
     attach(server: Server, baseUrl: string): void;
     private serve;
     close(): void;
 }
+export {};

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,23 +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;
@@ -91,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;
@@ -107,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)
@@ -114,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")
@@ -126,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;
@@ -151,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)
@@ -177,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) => {
@@ -194,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();
@@ -221,37 +315,70 @@ 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);
         }
         const active = socket;
         return new Promise((resolve, reject) => {
             let accepted = false, finished = false;
+            let bodyCancelled = false;
+            let eventCount = 0;
+            let sendCompleted = false;
+            let requestTransportErrorCode;
             let streamController;
             const stream = new ReadableStream({
                 start(controller) {
                     streamController = controller;
                 },
                 cancel() {
+                    bodyCancelled = true;
                     active.terminate();
                 },
             }, { highWaterMark: this.maxBytes, size: (chunk) => chunk.byteLength });
             const cleanup = () => {
                 active.off("message", onMessage);
-                active.off("close", onClose);
-                active.off("error", onClose);
+                active.off("close", onSocketClose);
+                active.off("error", onError);
                 init.signal?.removeEventListener("abort", abort);
                 context.signal.removeEventListener("abort", abort);
             };
-            const onClose = () => {
+            const onClose = (closeCode, cause = "close") => {
                 if (finished)
                     return;
                 finished = true;
                 cleanup();
                 this.channels.delete(key);
-                const cancelled = context.signal.aborted || this.closed;
+                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
                 // did not start. Never replay it, even before the first event.
                 const error = cancelled
@@ -269,8 +396,14 @@ class SocketSession {
                     }));
                 }
             };
+            const onSocketClose = (code) => onClose(code);
+            const onError = (error) => {
+                requestTransportErrorCode = transportErrorCode(error);
+                onClose(undefined, "transport_error");
+            };
             const abort = () => active.terminate();
             const onMessage = (raw, isBinary) => {
+                let failureCause = "invalid_event";
                 try {
                     if (isBinary)
                         throw Error("Unexpected binary response");
@@ -278,6 +411,7 @@ class SocketSession {
                     const event = JSON.parse(text);
                     if (!isRecord(event) || typeof event.type !== "string")
                         throw Error("Invalid response event");
+                    eventCount++;
                     if (event.type === "error" && !accepted) {
                         finished = true;
                         cleanup();
@@ -297,8 +431,10 @@ class SocketSession {
                             headers: { ...handshakeHeaders, "content-type": "text/event-stream" },
                         }));
                     }
-                    if ((streamController.desiredSize ?? 0) < -this.maxBytes)
+                    if ((streamController.desiredSize ?? 0) < -this.maxBytes) {
+                        failureCause = "buffer_limit";
                         throw Error("Upstream buffer exceeded");
+                    }
                     streamController.enqueue(Buffer.from(`data: ${text}\n\n`));
                     if (isRecord(event.response) &&
                         typeof event.response.id === "string") {
@@ -310,19 +446,23 @@ 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();
                     }
                 }
                 catch {
+                    onClose(undefined, failureCause);
                     active.terminate();
-                    onClose();
                 }
             };
             active.on("message", onMessage);
-            active.once("close", onClose);
-            active.once("error", onClose);
+            active.once("close", onSocketClose);
+            active.once("error", onError);
             init.signal?.addEventListener("abort", abort, { once: true });
             context.signal.addEventListener("abort", abort, { once: true });
             if (init.signal?.aborted || context.signal.aborted) {
@@ -330,9 +470,14 @@ class SocketSession {
                 return;
             }
             this.stats.upstreamRequests++;
-            active.send(JSON.stringify(body), (error) => {
-                if (error)
-                    onClose();
+            active.send(serializedBody, (error) => {
+                if (error) {
+                    requestTransportErrorCode = transportErrorCode(error);
+                    onClose(undefined, "send_error");
+                    active.terminate();
+                }
+                else
+                    sendCompleted = true;
             });
         });
     }
@@ -343,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). */
@@ -362,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) => {
@@ -372,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];
@@ -394,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"]) {
@@ -414,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))
@@ -428,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)
@@ -440,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;
@@ -457,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;
@@ -548,7 +780,7 @@ export class ResponsesWebSocketGateway {
                     const controller = new AbortController();
                     session.controller = controller;
                     const clientBeta = req.headers["openai-beta"];
-                    this.contexts.set(id, { session, previousId, delta: event.input, signal: controller.signal, clientBeta: typeof clientBeta === "string" ? clientBeta : undefined });
+                    this.contexts.set(id, { routeKind: pool, session, previousId, delta: event.input, signal: controller.signal, clientBeta: typeof clientBeta === "string" ? clientBeta : undefined });
                     const headers = new Headers();
                     for (const [key, value] of Object.entries(req.headers)) {
                         if (typeof value === "string" &&
@@ -600,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);
                             }
@@ -627,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);
     }