openai-ws-opencode 0.1.25 → 0.1.27

package/dist/transport/pool.js

@@ -1,22 +1,18 @@
 import crypto from "node:crypto";
 import { CODEX_WS_URL, OPENAI_MODEL_HEADER, OPENAI_WS_INSTALLATION_ID_ENV, RESPONSE_PROCESSED_DISABLE_ENV, RESPONSE_PROCESSED_ENV, X_CODEX_INSTALLATION_ID_HEADER, X_CODEX_TURN_STATE_HEADER, X_CODEX_WINDOW_ID_HEADER, X_MODELS_ETAG_HEADER, X_OPENAI_SUBAGENT_HEADER, X_REASONING_INCLUDED_HEADER, } from "../constants.js";
 import { loadDefaultWebSocketConstructor } from "./bun-websocket.js";
+import { createTransportBreaker } from "./breaker.js";
 import { transportConfig } from "./config.js";
+import { canonicalWebSocketOrigin, configureTransportCoordinator, getTransportCoordinator, resetTransportCoordinatorForTesting, } from "./coordinator.js";
+import { isWebSocketTransportError, WebSocketTransportError } from "./errors.js";
 let WebSocketImpl = loadDefaultWebSocketConstructor();
-export class WebSocketPreStreamTransportError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "WebSocketPreStreamTransportError";
-    }
-}
-export function isWebSocketPreStreamTransportError(error) {
-    return error instanceof WebSocketPreStreamTransportError || (error instanceof Error && error.name === "WebSocketPreStreamTransportError");
-}
 export const connectionPool = [];
-const acquisitionQueues = new Map();
 const turnStateByContext = new Map();
 const lastResponseIDByContext = new Map();
+const scopeCooldowns = new Map();
+const authEndpoints = new Map();
 let nextConnectionID = 1;
+let nextStreamID = 1;
 export const readyState = {
     CONNECTING: 0,
     OPEN: 1,
@@ -43,6 +39,23 @@ function authScopeHash(headers) {
         .join("\n");
     return crypto.createHash("sha256").update(auth).digest("hex");
 }
+function accountFingerprint(headers) {
+    const account = headers["ChatGPT-Account-Id"] ?? headers["chatgpt-account-id"] ?? "";
+    if (account) {
+        return crypto.createHash("sha256").update(`acct:${account}`).digest("hex").slice(0, 32);
+    }
+    const auth = headers.Authorization ?? headers.authorization ?? "";
+    return crypto.createHash("sha256").update(`auth:${auth}`).digest("hex").slice(0, 32);
+}
+function breakerDomainKey(provider, origin, accountFp) {
+    return crypto.createHash("sha256").update(`${provider}\n${origin}\n${accountFp}`).digest("hex");
+}
+function providerForUrl(wsUrl) {
+    return wsUrl === CODEX_WS_URL || wsUrl.includes("chatgpt.com/backend-api/codex") ? "codex" : "openai";
+}
+function endpointKey(wsUrl) {
+    return canonicalWebSocketOrigin(wsUrl);
+}
 function scopeKey(wsUrl, headers) {
     return `${wsUrl}::${authScopeHash(headers)}`;
 }
@@ -110,6 +123,82 @@ function finalizePending(pending) {
     pending.onFinalize?.();
     pending.onFinalize = undefined;
 }
+function transportError(options) {
+    return new WebSocketTransportError({
+        code: options.code,
+        phase: options.phase,
+        message: options.message,
+        fallbackEligible: options.fallbackEligible,
+        breakerEligible: options.breakerEligible ?? false,
+        safeToReplay: options.safeToReplay ?? options.fallbackEligible,
+        cause: options.cause,
+    });
+}
+function boundAuthEndpoints() {
+    const max = transportConfig.maxAccountingEntries;
+    while (authEndpoints.size > max) {
+        const oldest = authEndpoints.keys().next().value;
+        if (oldest === undefined)
+            break;
+        authEndpoints.delete(oldest);
+    }
+}
+function bindAuthGeneration(endpoint, hash) {
+    let state = authEndpoints.get(endpoint);
+    if (!state) {
+        state = { currentGeneration: 1, currentHash: hash, bindings: new Map([[hash, 1]]), order: [hash] };
+        authEndpoints.set(endpoint, state);
+        boundAuthEndpoints();
+        return 1;
+    }
+    if (hash === state.currentHash)
+        return state.currentGeneration;
+    // ABA-safe: a remembered non-current binding must never become current.
+    const remembered = state.bindings.get(hash);
+    if (remembered !== undefined)
+        return remembered;
+    state.currentGeneration += 1;
+    state.currentHash = hash;
+    state.bindings.set(hash, state.currentGeneration);
+    state.order.push(hash);
+    const max = transportConfig.authGenerationMaxBindings;
+    while (state.order.length > max) {
+        const oldest = state.order.shift();
+        if (!oldest || oldest === state.currentHash) {
+            if (oldest)
+                state.order.push(oldest);
+            break;
+        }
+        state.bindings.delete(oldest);
+    }
+    return state.currentGeneration;
+}
+function currentAuthGeneration(endpoint) {
+    return authEndpoints.get(endpoint)?.currentGeneration ?? 0;
+}
+function isCurrentAuth(conn) {
+    return conn.authGeneration === currentAuthGeneration(conn.endpointKey);
+}
+function finishConnectPermit(conn, result) {
+    if (!conn.connectPermit || conn.connectFinished)
+        return;
+    conn.connectFinished = true;
+    getTransportCoordinator().finishConnect(conn.connectPermit, result);
+    conn.connectPermit = null;
+}
+function releaseSocketAccounting(conn) {
+    if (!conn.socketReserved || conn.socketReleased)
+        return;
+    conn.socketReleased = true;
+    getTransportCoordinator().releaseSocket({ accountFp: conn.accountFp, provider: conn.provider });
+    getTransportCoordinator().noteSocketClosed(Math.max(0, Date.now() - conn.createdAt), conn.turnCount);
+}
+function releaseSessionAccounting(conn) {
+    if (!conn.sessionCounted)
+        return;
+    conn.sessionCounted = false;
+    getTransportCoordinator().adjustSessions(-1);
+}
 function detach(conn) {
     if (conn.detach) {
         conn.detach();
@@ -127,6 +216,9 @@ function remove(conn) {
     if (index >= 0)
         connectionPool.splice(index, 1);
     detach(conn);
+    finishConnectPermit(conn, { success: false, breakerEligible: false });
+    releaseSocketAccounting(conn);
+    releaseSessionAccounting(conn);
 }
 function retryDelay(attempt, retryAfterMs) {
     if (retryAfterMs !== undefined)
@@ -147,16 +239,8 @@ function closeSocket(conn, code, reason) {
     }
     catch { }
 }
-function terminalRelease(conn) {
-    release(conn);
-    drainQueue(conn.scopeKey);
-}
-function removeAndDrain(conn) {
-    remove(conn);
-    drainQueue(conn.scopeKey);
-}
 export function closeConnection(conn, reason = "connection closed", graceful = false) {
-    removeAndDrain(conn);
+    remove(conn);
     if (graceful) {
         try {
             conn.ws?.close(1000, reason);
@@ -178,16 +262,22 @@ function release(conn) {
     conn.frameCarryover = "";
     clearTimer(conn.idleTimer);
     conn.idleTimer = null;
-    if (conn.staleAuth) {
-        removeAndDrain(conn);
+    if (conn.staleAuth || !isCurrentAuth(conn)) {
+        remove(conn);
         closeSocket(conn, 1000, "auth changed");
         return;
     }
+    if (Date.now() >= conn.expiresAt) {
+        getTransportCoordinator().noteMaxAgeRetire();
+        remove(conn);
+        closeSocket(conn, 1000, "max age");
+        return;
+    }
     if (!conn.warm) {
         conn.idleTimer = unrefTimer(setTimeout(() => {
             conn.idleTimer = null;
             if (!conn.busy) {
-                removeAndDrain(conn);
+                remove(conn);
                 try {
                     conn.ws?.close(1000, "idle eviction");
                 }
@@ -231,7 +321,7 @@ function fail(conn, error, shouldCloseSocket) {
         else {
             finalizePending(pending);
             try {
-                pending.controller.error(error);
+                pending.sink.error(error);
             }
             catch { }
         }
@@ -241,12 +331,9 @@ function fail(conn, error, shouldCloseSocket) {
     conn.activeSessionID = undefined;
     conn.activeAgent = undefined;
     if (shouldCloseSocket) {
-        removeAndDrain(conn);
+        remove(conn);
         closeSocket(conn, 1000, "aborted");
     }
-    else {
-        drainQueue(conn.scopeKey);
-    }
 }
 function isTerminalEvent(eventType) {
     return ["response.completed", "response.failed", "response.incomplete"].includes(eventType);
@@ -277,7 +364,12 @@ function schedulePendingIdleTimeout(conn, reason) {
         current.idleTimer = null;
         conn.lastCloseCode = 1006;
         conn.lastCloseReason = "idle timeout waiting for websocket";
-        fail(conn, new Error(formatFailureMessage(conn, `idle timeout waiting for websocket after ${reason}`)), true);
+        fail(conn, transportError({
+            code: "active_socket_loss",
+            phase: "active",
+            message: formatFailureMessage(conn, `idle timeout waiting for websocket after ${reason}`),
+            fallbackEligible: false,
+        }), true);
     }, transportConfig.streamIdleTimeoutMs));
 }
 function decodeFrameData(data) {
@@ -366,15 +458,63 @@ function messageFromError(error) {
     }
     return error !== undefined && error !== null ? String(error) : undefined;
 }
-function wrappedWebSocketError(frame) {
+function websocketErrorCode(frame) {
+    const error = frame.error && typeof frame.error === "object" ? frame.error : {};
+    return typeof error.code === "string" ? error.code : typeof frame.code === "string" ? frame.code : undefined;
+}
+function hasReplaySafeInput(body) {
+    const input = body.input;
+    if (typeof input === "string")
+        return input.length > 0;
+    if (!Array.isArray(input))
+        return false;
+    return (input.length > 0 &&
+        input.every((item) => {
+            if (!item || typeof item !== "object" || Array.isArray(item))
+                return false;
+            const value = item;
+            return value.type === "message";
+        }));
+}
+function wrappedProviderRejection(frame, pending) {
     if (frame.type !== "error")
         return undefined;
+    const code = websocketErrorCode(frame);
     const error = frame.error && typeof frame.error === "object" ? frame.error : {};
-    const code = typeof error.code === "string" ? error.code : typeof frame.code === "string" ? frame.code : undefined;
     const message = typeof error.message === "string" ? error.message : typeof frame.message === "string" ? frame.message : code;
+    if (code === "previous_response_not_found") {
+        pending.metadata.responseId = undefined;
+        const replaySafe = hasReplaySafeInput(pending.body) && !pending.framesReceived;
+        return transportError({
+            code: "previous_response_not_found",
+            phase: pending.framesReceived ? "active" : "pre_send",
+            message: replaySafe
+                ? message ?? "Previous response not found"
+                : "OpenAI WebSocket previous_response_not_found; cannot safely retry without previous_response_id because request input does not contain replayable message context",
+            fallbackEligible: replaySafe,
+            safeToReplay: replaySafe,
+            breakerEligible: false,
+        });
+    }
     if (code === "websocket_connection_limit_reached") {
-        return new Error(message ?? "Responses websocket connection limit reached (60 minutes). Create a new websocket connection to continue.");
+        return transportError({
+            code: "provider_connection_limit",
+            phase: pending.framesReceived ? "active" : "pre_send",
+            message: message ??
+                "Responses websocket connection limit reached (60 minutes). Create a new websocket connection to continue.",
+            fallbackEligible: !pending.framesReceived,
+            safeToReplay: !pending.framesReceived,
+            breakerEligible: false,
+        });
     }
+    return undefined;
+}
+function wrappedWebSocketError(frame) {
+    if (frame.type !== "error")
+        return undefined;
+    const error = frame.error && typeof frame.error === "object" ? frame.error : {};
+    const code = typeof error.code === "string" ? error.code : typeof frame.code === "string" ? frame.code : undefined;
+    const message = typeof error.message === "string" ? error.message : typeof frame.message === "string" ? frame.message : code;
     const status = numberFrom(frame.status) ??
         numberFrom(frame.status_code) ??
         numberFrom(error.status) ??
@@ -385,7 +525,7 @@ function wrappedWebSocketError(frame) {
     return new Error(`OpenAI WebSocket error${status !== undefined ? ` ${status}` : ""}${code ? ` ${code}` : ""}${message ? `: ${message}` : ""}`);
 }
 function isCodexConnection(conn) {
-    return conn.wsUrl === CODEX_WS_URL || conn.wsUrl.includes("chatgpt.com/backend-api/codex");
+    return conn.provider === "codex";
 }
 function shouldSendResponseProcessed(conn) {
     if (process.env[RESPONSE_PROCESSED_DISABLE_ENV] === "1")
@@ -409,23 +549,6 @@ function sendResponseProcessed(conn, pending, eventType) {
         conn.lastErrorMessage = error instanceof Error ? error.message : String(error);
     }
 }
-function websocketErrorCode(frame) {
-    const error = frame.error && typeof frame.error === "object" ? frame.error : {};
-    return typeof error.code === "string" ? error.code : typeof frame.code === "string" ? frame.code : undefined;
-}
-function hasReplaySafeInput(body) {
-    const input = body.input;
-    if (typeof input === "string")
-        return input.length > 0;
-    if (!Array.isArray(input))
-        return false;
-    return input.length > 0 && input.every((item) => {
-        if (!item || typeof item !== "object" || Array.isArray(item))
-            return false;
-        const value = item;
-        return value.type === "message";
-    });
-}
 function clearLastResponseID(conn) {
     conn.lastResponseID = undefined;
     lastResponseIDByContext.delete(conn.contextKey);
@@ -458,30 +581,25 @@ function cacheResponseMetadata(conn, pending, responseID) {
 function isStaleResponseFrame(pending, responseID) {
     return Boolean(responseID && pending.metadata.activeResponseId && responseID !== pending.metadata.activeResponseId);
 }
-function handlePreviousResponseNotFound(conn, pending) {
-    clearLastResponseID(conn);
-    pending.metadata.responseId = undefined;
-    if (pending.previousResponseNotFoundRetried) {
-        fail(conn, new Error("OpenAI WebSocket previous_response_not_found after retrying without previous_response_id"), true);
-        return true;
+function sweepScopeCooldowns(now) {
+    for (const [key, until] of scopeCooldowns) {
+        if (until <= now)
+            scopeCooldowns.delete(key);
     }
-    if (!hasReplaySafeInput(pending.body)) {
-        fail(conn, new Error("OpenAI WebSocket previous_response_not_found; cannot safely retry without previous_response_id because request input does not contain replayable message context"), true);
-        return true;
-    }
-    pending.previousResponseNotFoundRetried = true;
-    pending.body.previous_response_id = null;
-    pending.sent = false;
-    pending.writeCommitted = false;
-    pending.framesReceived = false;
-    pending.finalMessageOutputReceived = false;
-    pending.processedAckSent = false;
-    conn.frameCarryover = "";
-    clearPendingTimer(pending);
-    if (conn.ws?.readyState !== readyState.OPEN || !sendPending(conn)) {
-        fail(conn, new Error("OpenAI WebSocket previous_response_not_found; retry without previous_response_id could not be sent"), true);
+    const max = transportConfig.maxAccountingEntries;
+    while (scopeCooldowns.size > max) {
+        const oldest = scopeCooldowns.keys().next().value;
+        if (oldest === undefined)
+            break;
+        scopeCooldowns.delete(oldest);
     }
-    return true;
+}
+function setScopeCooldown(scopeKeyValue) {
+    const now = Date.now();
+    sweepScopeCooldowns(now);
+    scopeCooldowns.set(scopeKeyValue, now + transportConfig.sessionCooldownMs);
+    sweepScopeCooldowns(now);
+    getTransportCoordinator().noteCooldown();
 }
 function enqueueSSE(conn, frame) {
     const pending = conn.pending;
@@ -491,24 +609,36 @@ function enqueueSSE(conn, frame) {
     const eventType = typeof frame.type === "string" ? frame.type : "message";
     if (eventType !== "response.created" && isStaleResponseFrame(pending, responseID))
         return;
-    pending.writeCommitted = true;
-    pending.framesReceived = true;
-    cacheResponseMetadata(conn, pending, responseID);
-    if (isFinalMessageOutputItem(frame))
-        pending.finalMessageOutputReceived = true;
+    const providerRejection = wrappedProviderRejection(frame, pending);
+    if (providerRejection) {
+        if (providerRejection.code === "previous_response_not_found")
+            clearLastResponseID(conn);
+        if (providerRejection.code === "provider_connection_limit")
+            setScopeCooldown(conn.scopeKey);
+        fail(conn, providerRejection, true);
+        return;
+    }
     const mappedError = wrappedWebSocketError(frame);
     if (mappedError) {
-        if (websocketErrorCode(frame) === "previous_response_not_found" && handlePreviousResponseNotFound(conn, pending))
-            return;
         clearLastResponseID(conn);
         fail(conn, mappedError, true);
         return;
     }
+    pending.writeCommitted = true;
+    pending.framesReceived = true;
+    cacheResponseMetadata(conn, pending, responseID);
+    if (isFinalMessageOutputItem(frame))
+        pending.finalMessageOutputReceived = true;
     const encoded = new TextEncoder().encode(`event: ${eventType}\ndata: ${JSON.stringify(frame)}\n\n`);
     try {
-        pending.controller.enqueue(encoded);
+        pending.sink.enqueue(encoded);
     }
-    catch {
+    catch (error) {
+        if (isWebSocketTransportError(error) && error.code === "queue_overflow") {
+            fail(conn, error, true);
+            return;
+        }
+        fail(conn, error instanceof Error ? error : new Error(String(error)), true);
         return;
     }
     if (!isTerminalEvent(eventType))
@@ -518,23 +648,22 @@ function enqueueSSE(conn, frame) {
         pending.done = true;
         sendResponseProcessed(conn, pending, eventType);
         try {
-            pending.controller.close();
+            pending.sink.close();
         }
         catch { }
-        if (pending.metadata.responseId) {
+        if (pending.metadata.responseId)
             persistLastResponseID(conn, pending.metadata.responseId);
-        }
-        else {
+        else
             clearLastResponseID(conn);
-        }
-        terminalRelease(conn);
+        conn.pending = null;
+        release(conn);
     }
 }
 function finishAfterFinalOutputSocketClose(conn, pending) {
     finalizePending(pending);
     pending.done = true;
     try {
-        pending.controller.close();
+        pending.sink.close();
     }
     catch { }
     if (pending.metadata.responseId)
@@ -545,7 +674,7 @@ function finishAfterFinalOutputSocketClose(conn, pending) {
     conn.busy = false;
     conn.activeSessionID = undefined;
     conn.activeAgent = undefined;
-    removeAndDrain(conn);
+    remove(conn);
 }
 export function sendPending(conn) {
     const pending = conn.pending;
@@ -554,6 +683,17 @@ export function sendPending(conn) {
     const ws = conn.ws;
     if (!ws || ws.readyState !== readyState.OPEN)
         return false;
+    if (!isCurrentAuth(conn) || conn.staleAuth) {
+        getTransportCoordinator().noteAuthStale();
+        fail(conn, transportError({
+            code: "stale_auth",
+            phase: "pre_send",
+            message: "OpenAI WebSocket auth generation is stale; refusing response.create",
+            fallbackEligible: true,
+            safeToReplay: true,
+        }), true);
+        return false;
+    }
     const generation = conn.generation;
     try {
         const body = { ...pending.body };
@@ -625,7 +765,36 @@ function parseRetryAfterMs(source) {
         return Math.max(0, date - Date.now());
     return undefined;
 }
+function beginHandshake(conn) {
+    const coordinator = getTransportCoordinator();
+    const started = coordinator.startConnect({
+        intent: conn.intent,
+        provider: conn.provider,
+        origin: conn.origin,
+        accountFp: conn.accountFp,
+        scopeKey: conn.breakerDomain,
+    });
+    if (!started.ok) {
+        coordinator.noteAdmissionMiss(started.reason);
+        fail(conn, transportError({
+            code: started.reason,
+            phase: "handshake",
+            message: `OpenAI WebSocket handshake admission denied: ${started.reason}`,
+            fallbackEligible: true,
+            breakerEligible: started.reason === "provider_breaker",
+        }), true);
+        return false;
+    }
+    conn.connectPermit = started.permit;
+    conn.connectFinished = false;
+    return true;
+}
 function connect(conn) {
+    // Initial create pre-reserves a permit; each bounded pre-send reconnect takes a fresh one.
+    if (!conn.connectPermit || conn.connectFinished) {
+        if (!beginHandshake(conn))
+            return;
+    }
     const generation = ++conn.generation;
     conn.frameCarryover = "";
     clearTimer(conn.retryTimer);
@@ -636,6 +805,7 @@ function connect(conn) {
             return;
         conn.lastCloseCode = 1006;
         conn.lastCloseReason = "connection timed out";
+        finishConnectPermit(conn, { success: false, breakerEligible: true, timeout: true });
         handleSocketLoss(conn);
     }, transportConfig.connectTimeoutMs);
     conn.connectTimer = unrefTimer(connectTimer);
@@ -645,6 +815,7 @@ function connect(conn) {
         clearTimer(conn.connectTimer);
         conn.connectTimer = null;
         conn.lastActivityAt = Date.now();
+        finishConnectPermit(conn, { success: true });
         sendPending(conn);
     };
     const handleUpgrade = (response) => {
@@ -676,6 +847,7 @@ function connect(conn) {
         if (generation !== conn.generation)
             return;
         conn.lastErrorMessage = messageFromError(error) ?? "unknown websocket error";
+        finishConnectPermit(conn, { success: false, breakerEligible: true });
         handleSocketLoss(conn);
     };
     const handleClose = (codeOrEvent, reason) => {
@@ -685,8 +857,10 @@ function connect(conn) {
         const normalizedReason = closeReasonFrom(codeOrEvent, reason);
         if (normalizedReason !== undefined)
             conn.lastCloseReason = normalizedReason;
-        else if (conn.lastCloseReason === undefined && closeCodeFrom(codeOrEvent) === undefined)
+        else if (conn.lastCloseReason === undefined && closeCodeFrom(codeOrEvent) === undefined) {
             conn.lastCloseReason = "socket closed without close code";
+        }
+        finishConnectPermit(conn, { success: false, breakerEligible: true });
         handleSocketLoss(conn);
     };
     const handleUnexpectedResponse = (_request, response) => {
@@ -697,6 +871,7 @@ function connect(conn) {
             conn.lastCloseCode = status;
         conn.retryAfterMs = parseRetryAfterMs(response);
         conn.lastCloseReason = `websocket handshake failed${status !== undefined ? ` with status ${status}` : ""}`;
+        finishConnectPermit(conn, { success: false, breakerEligible: true });
         handleSocketLoss(conn);
     };
     const attachUpgrade = supportsUpgradeEvent(WebSocketImpl);
@@ -714,6 +889,7 @@ function connect(conn) {
     }
     catch (error) {
         conn.lastErrorMessage = messageFromError(error) ?? "websocket constructor failed";
+        finishConnectPermit(conn, { success: false, breakerEligible: true });
         queueMicrotask(() => handleSocketLoss(conn));
         return;
     }
@@ -745,7 +921,7 @@ function handleSocketLoss(conn) {
     const pending = conn.pending;
     if (!pending || pending.done) {
         finalizePending(pending);
-        removeAndDrain(conn);
+        remove(conn);
         closeSocket(conn, 1000, "socket lost");
         return;
     }
@@ -753,8 +929,13 @@ function handleSocketLoss(conn) {
         finishAfterFinalOutputSocketClose(conn, pending);
         return;
     }
-    if (pending.writeCommitted) {
-        fail(conn, new Error(formatFailureMessage(conn, "response.create was already sent")), true);
+    if (pending.framesReceived || pending.writeCommitted) {
+        fail(conn, transportError({
+            code: "active_socket_loss",
+            phase: "active",
+            message: formatFailureMessage(conn, "response.create was already sent"),
+            fallbackEligible: false,
+        }), true);
         return;
     }
     const canRetry = conn.reconnectAttempts < transportConfig.maxReconnectAttempts;
@@ -780,17 +961,34 @@ function handleSocketLoss(conn) {
         conn.ws = null;
         conn.retryTimer = unrefTimer(setTimeout(() => {
             conn.retryTimer = null;
-            if (!connectionPool.includes(conn) || !conn.pending || conn.pending.done || conn.pending.sent || conn.pending.writeCommitted)
+            if (!connectionPool.includes(conn) || !conn.pending || conn.pending.done || conn.pending.sent || conn.pending.writeCommitted) {
                 return;
+            }
             connect(conn);
         }, retryDelay(conn.reconnectAttempts, retryAfterMs)));
         return;
     }
-    fail(conn, new WebSocketPreStreamTransportError(formatFailureMessage(conn, "retry limit reached before response.create was sent")), true);
-}
-function create(wsUrl, headers, context = {}, warm = false) {
+    fail(conn, transportError({
+        code: "connect_failure",
+        phase: "handshake",
+        message: formatFailureMessage(conn, "retry limit reached before response.create was sent"),
+        fallbackEligible: true,
+        breakerEligible: true,
+        safeToReplay: true,
+    }), true);
+}
+function computeExpiresAt(now) {
+    const jitter = Math.floor(Math.random() * (transportConfig.connectionMaxAgeJitterMs + 1));
+    return now + transportConfig.connectionMaxAgeMs - jitter;
+}
+function create(wsUrl, headers, context = {}, warm = false, permit) {
     const hash = authScopeHash(headers);
     const key = contextScopeKey(wsUrl, headers, context);
+    const endpoint = endpointKey(wsUrl);
+    const provider = providerForUrl(wsUrl);
+    const origin = canonicalWebSocketOrigin(wsUrl);
+    const accountFp = accountFingerprint(headers);
+    const now = Date.now();
     const conn = {
         id: `ws-${nextConnectionID++}`,
         ws: null,
@@ -799,6 +997,11 @@ function create(wsUrl, headers, context = {}, warm = false) {
         scopeKey: key,
         scopeHash: hash,
         contextKey: key,
+        endpointKey: endpoint,
+        accountFp,
+        provider,
+        origin,
+        authGeneration: bindAuthGeneration(endpoint, hash),
         busy: false,
         warm,
         staleAuth: false,
@@ -806,20 +1009,30 @@ function create(wsUrl, headers, context = {}, warm = false) {
         lastResponseID: lastResponseIDByContext.get(key),
         generation: 0,
         reconnectAttempts: 0,
-        createdAt: Date.now(),
-        lastActivityAt: Date.now(),
+        createdAt: now,
+        expiresAt: computeExpiresAt(now),
+        lastActivityAt: now,
         idleTimer: null,
         connectTimer: null,
         retryTimer: null,
         frameCarryover: "",
         detach: null,
+        socketReserved: true,
+        socketReleased: false,
+        sessionCounted: true,
+        connectPermit: permit,
+        connectFinished: false,
+        turnCount: 0,
+        intent: warm ? "prewarm" : "demand",
+        breakerDomain: breakerDomainKey(provider, origin, accountFp),
     };
     connectionPool.push(conn);
+    getTransportCoordinator().adjustSessions(1);
     connect(conn);
     return conn;
 }
 function isReusable(conn, key, context, now) {
-    if (conn.staleAuth)
+    if (conn.staleAuth || !isCurrentAuth(conn))
         return false;
     if (conn.busy)
         return false;
@@ -829,7 +1042,7 @@ function isReusable(conn, key, context, now) {
         return false;
     if (now - conn.lastActivityAt > transportConfig.staleReuseMs)
         return false;
-    if (now - conn.createdAt > transportConfig.connectionMaxAgeMs)
+    if (now >= conn.expiresAt)
         return false;
     if (context.sessionID && conn.lastSessionID && conn.lastSessionID !== context.sessionID)
         return false;
@@ -837,129 +1050,162 @@ function isReusable(conn, key, context, now) {
         return false;
     return true;
 }
-function activeCount(key) {
-    return connectionPool.filter((conn) => conn.scopeKey === key && (conn.busy || conn.ws?.readyState === readyState.CONNECTING)).length;
+function activeBusy(key) {
+    return connectionPool.some((conn) => conn.scopeKey === key && conn.busy);
 }
 export function invalidateStaleAuthConnections(wsUrl, headers) {
-    const currentHash = authScopeHash(headers);
+    const endpoint = endpointKey(wsUrl);
+    const hash = authScopeHash(headers);
+    const state = authEndpoints.get(endpoint);
+    // ABA: presenting an old remembered binding must not become current or stale newer sockets.
+    if (state && hash !== state.currentHash && state.bindings.has(hash))
+        return;
+    const generation = bindAuthGeneration(endpoint, hash);
+    const keepHash = authEndpoints.get(endpoint)?.currentHash ?? hash;
+    const keepGen = authEndpoints.get(endpoint)?.currentGeneration ?? generation;
     for (const conn of [...connectionPool]) {
-        if (conn.wsUrl !== wsUrl || conn.scopeHash === currentHash)
+        if (conn.wsUrl !== wsUrl)
+            continue;
+        if (conn.scopeHash === keepHash && conn.authGeneration === keepGen)
             continue;
         conn.staleAuth = true;
         if (conn.busy)
             continue;
-        removeAndDrain(conn);
+        remove(conn);
         closeSocket(conn, 1000, "auth changed");
     }
 }
-function cleanupStaleConnections(key, now) {
+function cleanupExpiredIdle(now) {
+    sweepScopeCooldowns(now);
     for (const candidate of [...connectionPool]) {
-        if (candidate.busy || candidate.scopeKey !== key)
+        if (candidate.busy)
             continue;
-        if (candidate.ws?.readyState === readyState.OPEN &&
-            (now - candidate.lastActivityAt > transportConfig.staleReuseMs ||
-                now - candidate.createdAt > transportConfig.connectionMaxAgeMs)) {
-            remove(candidate);
-            try {
-                candidate.ws?.close(1000, "stale idle");
-            }
-            catch { }
+        const state = candidate.ws?.readyState;
+        if (state !== readyState.OPEN && state !== readyState.CONNECTING)
+            continue;
+        const maxAgeExpired = now >= candidate.expiresAt;
+        const staleIdle = now - candidate.lastActivityAt > transportConfig.staleReuseMs;
+        if (!maxAgeExpired && !staleIdle)
+            continue;
+        // Max-age retirement is only for jittered expiry, never inactivity alone.
+        if (maxAgeExpired)
+            getTransportCoordinator().noteMaxAgeRetire();
+        remove(candidate);
+        try {
+            candidate.ws?.close(1000, maxAgeExpired ? "max age" : "stale idle");
         }
+        catch { }
     }
 }
+function admitMiss(code, message) {
+    getTransportCoordinator().noteAdmissionMiss(code);
+    throw transportError({
+        code,
+        phase: "admission",
+        message,
+        fallbackEligible: true,
+        breakerEligible: code === "provider_breaker",
+        safeToReplay: true,
+    });
+}
 function reserveConnection(wsUrl, headers, context) {
+    const coordinator = getTransportCoordinator();
+    coordinator.noteLeaseAttempt();
     invalidateStaleAuthConnections(wsUrl, headers);
     const key = contextScopeKey(wsUrl, headers, context);
     const now = Date.now();
-    cleanupStaleConnections(key, now);
+    cleanupExpiredIdle(now);
+    const cooldownUntil = scopeCooldowns.get(key);
+    if (cooldownUntil && now < cooldownUntil) {
+        admitMiss("session_cooldown", `OpenAI WebSocket session cooldown active for ${Math.max(0, cooldownUntil - now)}ms`);
+    }
+    if (activeBusy(key)) {
+        admitMiss("session_busy", "OpenAI WebSocket session already has an active turn");
+    }
+    const endpoint = endpointKey(wsUrl);
+    const hash = authScopeHash(headers);
+    const generation = bindAuthGeneration(endpoint, hash);
+    if (generation !== currentAuthGeneration(endpoint)) {
+        coordinator.noteAuthStale();
+        admitMiss("stale_auth", "OpenAI WebSocket auth generation is stale");
+    }
     const reusable = connectionPool.find((conn) => isReusable(conn, key, context, now));
     if (reusable) {
         clearTimer(reusable.idleTimer);
         reusable.idleTimer = null;
         reusable.busy = true;
         reusable.warm = false;
+        reusable.intent = "demand";
+        reusable.turnCount += 1;
+        coordinator.noteLeaseAdmission();
         return reusable;
     }
-    if (activeCount(key) >= transportConfig.maxConnectionsPerScope)
-        return null;
-    const conn = create(wsUrl, headers, context);
-    conn.busy = true;
-    return conn;
-}
-function queueAcquire(wsUrl, headers, context, signal) {
-    const key = contextScopeKey(wsUrl, headers, context);
-    return new Promise((resolve, reject) => {
-        const entry = {
-            wsUrl,
-            headers,
-            context,
-            resolve,
-            reject,
-            signal,
-            onAbort: () => {
-                const queue = acquisitionQueues.get(key);
-                if (queue) {
-                    const index = queue.indexOf(entry);
-                    if (index >= 0)
-                        queue.splice(index, 1);
-                    if (queue.length === 0)
-                        acquisitionQueues.delete(key);
-                }
-                reject(signal?.reason instanceof Error ? signal.reason : new DOMException("Aborted", "AbortError"));
-            },
-        };
-        if (signal?.aborted) {
-            entry.onAbort();
-            return;
-        }
-        signal?.addEventListener("abort", entry.onAbort, { once: true });
-        const queue = acquisitionQueues.get(key) ?? [];
-        queue.push(entry);
-        acquisitionQueues.set(key, queue);
+    const accountFp = accountFingerprint(headers);
+    const provider = providerForUrl(wsUrl);
+    const origin = canonicalWebSocketOrigin(wsUrl);
+    const reserved = coordinator.reserveSocket({ accountFp, provider, intent: "demand" });
+    if (!reserved.ok) {
+        admitMiss(reserved.reason, `OpenAI WebSocket socket admission denied: ${reserved.reason}`);
+    }
+    const started = coordinator.startConnect({
+        intent: "demand",
+        provider,
+        origin,
+        accountFp,
+        scopeKey: breakerDomainKey(provider, origin, accountFp),
     });
-}
-function drainQueue(key) {
-    const queue = acquisitionQueues.get(key);
-    if (!queue?.length)
-        return;
-    while (queue.length) {
-        const entry = queue[0];
-        if (entry.signal?.aborted) {
-            queue.shift();
-            entry.onAbort();
-            continue;
-        }
-        const conn = reserveConnection(entry.wsUrl, entry.headers, entry.context);
-        if (!conn)
-            break;
-        queue.shift();
-        entry.signal?.removeEventListener("abort", entry.onAbort);
-        entry.resolve(conn);
+    if (!started.ok) {
+        coordinator.releaseSocket({ accountFp, provider });
+        admitMiss(started.reason, `OpenAI WebSocket connect admission denied: ${started.reason}`);
     }
-    if (queue.length === 0)
-        acquisitionQueues.delete(key);
+    const conn = create(wsUrl, headers, context, false, started.permit);
+    conn.busy = true;
+    conn.turnCount += 1;
+    coordinator.noteLeaseAdmission();
+    return conn;
 }
-export function acquireConnection(wsUrl, headers, context, signal) {
-    const conn = reserveConnection(wsUrl, headers, context);
-    if (conn)
-        return conn;
-    return queueAcquire(wsUrl, headers, context, signal);
+export function acquireConnection(wsUrl, headers, context, _signal) {
+    return reserveConnection(wsUrl, headers, context);
 }
 export function ensureWarmConnection(wsUrl, headers) {
+    const coordinator = getTransportCoordinator();
+    coordinator.notePrewarmAttempt();
     invalidateStaleAuthConnections(wsUrl, headers);
     const key = contextScopeKey(wsUrl, headers, {});
     const now = Date.now();
-    cleanupStaleConnections(key, now);
-    const existing = connectionPool.find((conn) => conn.scopeKey === key && !conn.busy && conn.ws?.readyState === readyState.OPEN);
+    cleanupExpiredIdle(now);
+    const existing = connectionPool.find((conn) => conn.scopeKey === key &&
+        !conn.busy &&
+        !conn.staleAuth &&
+        isCurrentAuth(conn) &&
+        (conn.ws?.readyState === readyState.OPEN || conn.ws?.readyState === readyState.CONNECTING));
     if (existing) {
         existing.warm = true;
         clearTimer(existing.idleTimer);
         existing.idleTimer = null;
         return existing;
     }
-    if (activeCount(key) >= transportConfig.maxConnectionsPerScope)
+    const accountFp = accountFingerprint(headers);
+    const provider = providerForUrl(wsUrl);
+    const origin = canonicalWebSocketOrigin(wsUrl);
+    const reserved = coordinator.reserveSocket({ accountFp, provider, intent: "prewarm" });
+    if (!reserved.ok) {
+        coordinator.notePrewarmDeferred();
         return undefined;
-    return create(wsUrl, headers, {}, true);
+    }
+    const started = coordinator.startConnect({
+        intent: "prewarm",
+        provider,
+        origin,
+        accountFp,
+        scopeKey: breakerDomainKey(provider, origin, accountFp),
+    });
+    if (!started.ok) {
+        coordinator.releaseSocket({ accountFp, provider });
+        coordinator.notePrewarmDeferred();
+        return undefined;
+    }
+    return create(wsUrl, headers, {}, true, started.permit);
 }
 export function closeConnections(predicate = () => true, message = "Session disposed") {
     for (const conn of [...connectionPool]) {
@@ -968,6 +1214,45 @@ export function closeConnections(predicate = () => true, message = "Session disp
         fail(conn, new Error(message), true);
     }
 }
+export function nextStreamKeyForTesting() {
+    return `stream-${nextStreamID++}`;
+}
+export function allocateStreamKey() {
+    return `stream-${nextStreamID++}`;
+}
+export function syncCoordinatorFromTransportConfig() {
+    configureTransportCoordinator({
+        processMaxSockets: transportConfig.processMaxSockets,
+        maxSocketsPerProvider: transportConfig.maxSocketsPerProvider,
+        maxSocketsPerAccount: transportConfig.maxSocketsPerAccount,
+        maxConnecting: transportConfig.maxConnecting,
+        prewarmMaxConnecting: transportConfig.prewarmMaxConnecting,
+        prewarmDemandReserve: transportConfig.prewarmDemandReserve,
+        connectRateProcessPerMin: transportConfig.connectRateProcessPerMin,
+        connectRateProviderPerMin: transportConfig.connectRateProviderPerMin,
+        connectRateOriginPerMin: transportConfig.connectRateOriginPerMin,
+        connectRateAccountPerMin: transportConfig.connectRateAccountPerMin,
+        maxAccountingEntries: transportConfig.maxAccountingEntries,
+        queueMaxBytesPerStream: transportConfig.queueMaxBytesPerStream,
+        queueMaxBytesTotal: transportConfig.queueMaxBytesTotal,
+        maxSessions: transportConfig.shedMaxSessions,
+        eventLoopLagMs: transportConfig.shedLagMs,
+        rssMb: transportConfig.shedRssMb,
+        breaker: createTransportBreaker({
+            windowMs: transportConfig.breakerWindowMs,
+            minSamples: transportConfig.breakerMinSamples,
+            failurePercent: Math.round(transportConfig.breakerFailureRatio * 100),
+            openMs: transportConfig.breakerOpenMs,
+            jitterMs: transportConfig.breakerJitterMs,
+            halfOpenSuccesses: transportConfig.breakerHalfOpenSuccesses,
+            maxEntries: transportConfig.breakerMaxEntries,
+            enabled: transportConfig.breakerEnabled,
+        }),
+    });
+}
+export function getTransportSnapshotForTesting() {
+    return getTransportCoordinator().snapshot();
+}
 export function resetPoolForTesting() {
     for (const conn of [...connectionPool]) {
         try {
@@ -980,15 +1265,13 @@ export function resetPoolForTesting() {
         catch { }
         remove(conn);
     }
-    for (const queue of acquisitionQueues.values()) {
-        for (const entry of queue) {
-            entry.signal?.removeEventListener("abort", entry.onAbort);
-            entry.reject(new Error("Pool reset"));
-        }
-    }
-    acquisitionQueues.clear();
     turnStateByContext.clear();
     lastResponseIDByContext.clear();
+    scopeCooldowns.clear();
+    authEndpoints.clear();
+    nextStreamID = 1;
+    resetTransportCoordinatorForTesting();
+    syncCoordinatorFromTransportConfig();
 }
 export function setWebSocketConstructorForTesting(ctor) {
     WebSocketImpl = ctor;
@@ -996,4 +1279,6 @@ export function setWebSocketConstructorForTesting(ctor) {
 export function resetWebSocketConstructorForTesting() {
     WebSocketImpl = loadDefaultWebSocketConstructor();
 }
+// Initialize coordinator against boot-latched config.
+syncCoordinatorFromTransportConfig();
 //# sourceMappingURL=pool.js.map