openai-ws-opencode 0.1.6 → 0.1.8

package/dist/transport/pool.js

@@ -1,14 +1,13 @@
 import crypto from "node:crypto";
-import WebSocket from "ws";
-const DEFAULT_CONNECT_TIMEOUT_MS = 10_000;
-const MAX_RECONNECT_ATTEMPTS = 3;
-const RECONNECT_DELAY_MS = 100;
-const IDLE_EVICT_MS = 120_000;
-const STALE_REUSE_MS = 60_000;
-const HEARTBEAT_INTERVAL_MS = 30_000;
-const PONG_TIMEOUT_MS = 10_000;
-let WebSocketImpl = WebSocket;
+import { OPENAI_MODEL_HEADER, OPENAI_WS_INSTALLATION_ID_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 { transportConfig } from "./config.js";
+let WebSocketImpl = loadDefaultWebSocketConstructor();
 export const connectionPool = [];
+const acquisitionQueues = new Map();
+const turnStateByContext = new Map();
+const lastResponseIDByContext = new Map();
+let nextConnectionID = 1;
 export const readyState = {
     CONNECTING: 0,
     OPEN: 1,
@@ -27,13 +26,53 @@ function off(ws, event, listener) {
     else
         ws.removeEventListener?.(event, listener);
 }
-function scopeKey(wsUrl, headers) {
+function authScopeHash(headers) {
     const auth = Object.entries(headers)
         .filter(([key]) => ["authorization", "chatgpt-account-id", "originator", "openai-beta"].includes(key.toLowerCase()))
         .sort(([a], [b]) => a.localeCompare(b))
         .map(([key, value]) => `${key}:${value}`)
         .join("\n");
-    return `${wsUrl}::${crypto.createHash("sha256").update(auth).digest("hex")}`;
+    return crypto.createHash("sha256").update(auth).digest("hex");
+}
+function scopeKey(wsUrl, headers) {
+    return `${wsUrl}::${authScopeHash(headers)}`;
+}
+function contextScopeKey(wsUrl, headers, context) {
+    return `${scopeKey(wsUrl, headers)}::session:${context.sessionID ?? ""}::agent:${context.agent ?? ""}`;
+}
+function headersForConnection(wsUrl, baseHeaders, context, key) {
+    const headers = { ...baseHeaders };
+    if (context.sessionID) {
+        headers.session_id = context.sessionID;
+        headers["session-id"] = context.sessionID;
+        headers.thread_id = context.sessionID;
+        headers["thread-id"] = context.sessionID;
+        headers["x-client-request-id"] = crypto.createHash("sha256").update(`${wsUrl}:${context.sessionID}`).digest("hex").slice(0, 32);
+        headers[X_CODEX_WINDOW_ID_HEADER] = context.sessionID;
+    }
+    if (context.agent && context.agent !== "primary")
+        headers[X_OPENAI_SUBAGENT_HEADER] = context.agent;
+    const installationID = process.env[OPENAI_WS_INSTALLATION_ID_ENV];
+    if (installationID)
+        headers[X_CODEX_INSTALLATION_ID_HEADER] = installationID;
+    const turnState = turnStateByContext.get(key);
+    if (turnState)
+        headers[X_CODEX_TURN_STATE_HEADER] = turnState;
+    return headers;
+}
+function headerValue(source, name) {
+    const headers = source?.headers;
+    if (!headers)
+        return undefined;
+    if (headers instanceof Headers)
+        return headers.get(name) ?? undefined;
+    if (typeof headers.get === "function") {
+        const value = headers.get(name);
+        return Array.isArray(value) ? String(value[0]) : value === undefined || value === null ? undefined : String(value);
+    }
+    const record = headers;
+    const value = record[name] ?? record[name.toLowerCase()];
+    return Array.isArray(value) ? String(value[0]) : value === undefined || value === null ? undefined : String(value);
 }
 function clearTimer(timer) {
     if (timer)
@@ -52,6 +91,19 @@ function clearHeartbeat(conn) {
     conn.heartbeatTimer = null;
     conn.pongTimer = null;
 }
+function clearPendingTimer(pending) {
+    if (!pending)
+        return;
+    clearTimer(pending.idleTimer);
+    pending.idleTimer = null;
+}
+function finalizePending(pending) {
+    if (!pending)
+        return;
+    clearPendingTimer(pending);
+    pending.onFinalize?.();
+    pending.onFinalize = undefined;
+}
 function detach(conn) {
     if (conn.detach) {
         conn.detach();
@@ -71,10 +123,40 @@ function remove(conn) {
         connectionPool.splice(index, 1);
     detach(conn);
 }
+function retryDelay(attempt) {
+    const exponential = Math.min(transportConfig.reconnectMaxDelayMs, transportConfig.reconnectBaseDelayMs * 2 ** Math.max(0, attempt - 1));
+    return exponential;
+}
+function closeSocket(conn, code, reason) {
+    try {
+        conn.ws?.terminate?.();
+    }
+    catch { }
+    try {
+        conn.ws?.close(code, reason);
+    }
+    catch { }
+}
+function terminalRelease(conn) {
+    if (conn.turnState) {
+        finalizePending(conn.pending);
+        conn.pending = null;
+        conn.activeSessionID = undefined;
+        conn.activeAgent = undefined;
+        conn.busy = false;
+        removeAndDrain(conn);
+        closeSocket(conn, 1000, "turn complete");
+        return;
+    }
+    release(conn);
+    drainQueue(conn.scopeKey);
+}
+function removeAndDrain(conn) {
+    remove(conn);
+    drainQueue(conn.scopeKey);
+}
 function scheduleHeartbeat(conn) {
     clearHeartbeat(conn);
-    if (conn.busy || conn.pending)
-        return;
     const ws = conn.ws;
     if (!ws || ws.readyState !== readyState.OPEN)
         return;
@@ -83,7 +165,7 @@ function scheduleHeartbeat(conn) {
     const generation = conn.generation;
     conn.heartbeatTimer = unrefTimer(setTimeout(() => {
         conn.heartbeatTimer = null;
-        if (generation !== conn.generation || conn.busy || !conn.ws)
+        if (generation !== conn.generation || !conn.ws)
             return;
         if (conn.ws.readyState !== readyState.OPEN)
             return;
@@ -91,47 +173,42 @@ function scheduleHeartbeat(conn) {
             conn.ws.ping?.();
         }
         catch {
-            remove(conn);
-            try {
-                conn.ws?.terminate?.();
-            }
-            catch { }
+            handleSocketLoss(conn);
             return;
         }
         conn.pongTimer = unrefTimer(setTimeout(() => {
             conn.pongTimer = null;
-            if (generation !== conn.generation || conn.busy)
+            if (generation !== conn.generation)
                 return;
-            remove(conn);
-            try {
-                conn.ws?.terminate?.();
-            }
-            catch { }
-            try {
-                conn.ws?.close(1001, "pong timeout");
-            }
-            catch { }
-        }, PONG_TIMEOUT_MS));
-    }, HEARTBEAT_INTERVAL_MS));
+            conn.lastCloseCode = 1006;
+            conn.lastCloseReason = "pong timeout";
+            handleSocketLoss(conn);
+        }, transportConfig.pongTimeoutMs));
+    }, transportConfig.heartbeatIntervalMs));
 }
 function release(conn) {
     conn.lastSessionID = conn.activeSessionID;
     conn.lastAgent = conn.activeAgent;
+    finalizePending(conn.pending);
     conn.pending = null;
     conn.activeSessionID = undefined;
     conn.activeAgent = undefined;
     conn.busy = false;
     conn.reconnectAttempts = 0;
-    conn.idleTimer = unrefTimer(setTimeout(() => {
-        conn.idleTimer = null;
-        if (!conn.busy) {
-            remove(conn);
-            try {
-                conn.ws?.close(1000, "idle eviction");
+    clearTimer(conn.idleTimer);
+    conn.idleTimer = null;
+    if (!conn.warm) {
+        conn.idleTimer = unrefTimer(setTimeout(() => {
+            conn.idleTimer = null;
+            if (!conn.busy) {
+                removeAndDrain(conn);
+                try {
+                    conn.ws?.close(1000, "idle eviction");
+                }
+                catch { }
             }
-            catch { }
-        }
-    }, IDLE_EVICT_MS));
+        }, transportConfig.idleEvictMs));
+    }
     scheduleHeartbeat(conn);
 }
 function formatFailureMessage(conn, reason) {
@@ -139,13 +216,14 @@ function formatFailureMessage(conn, reason) {
     const closeReason = JSON.stringify(conn.lastCloseReason ?? "");
     const lastError = conn.lastErrorMessage ? JSON.stringify(conn.lastErrorMessage) : "none";
     return (`WebSocket closed before response completed; cannot retry because ${reason}; ` +
-        `reconnectAttempts=${conn.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS}; ` +
+        `reconnectAttempts=${conn.reconnectAttempts}/${transportConfig.maxReconnectAttempts}; ` +
         `closeCode=${code}; closeReason=${closeReason}; lastError=${lastError}`);
 }
-function fail(conn, error, closeSocket) {
+function fail(conn, error, shouldCloseSocket) {
     const pending = conn.pending;
     if (pending && !pending.done) {
         pending.done = true;
+        finalizePending(pending);
         try {
             pending.controller.error(error);
         }
@@ -155,17 +233,44 @@ function fail(conn, error, closeSocket) {
     conn.busy = false;
     conn.activeSessionID = undefined;
     conn.activeAgent = undefined;
-    if (closeSocket) {
-        remove(conn);
-        try {
-            conn.ws?.terminate?.();
-        }
-        catch { }
-        try {
-            conn.ws?.close(1000, "aborted");
-        }
-        catch { }
+    if (shouldCloseSocket) {
+        removeAndDrain(conn);
+        closeSocket(conn, 1000, "aborted");
+    }
+    else {
+        drainQueue(conn.scopeKey);
+    }
+}
+function cacheResponseMetadata(pending, frame) {
+    const response = frame.response;
+    if (response && typeof response === "object") {
+        const value = response;
+        if (typeof value.id === "string")
+            pending.metadata.responseId = value.id;
     }
+    if (typeof frame.response_id === "string")
+        pending.metadata.responseId = frame.response_id;
+}
+function isTerminalEvent(eventType) {
+    return ["response.completed", "response.failed", "response.incomplete"].includes(eventType);
+}
+function schedulePendingIdleTimeout(conn, reason) {
+    const pending = conn.pending;
+    if (!pending || pending.done)
+        return;
+    clearPendingTimer(pending);
+    const generation = conn.generation;
+    pending.idleTimer = unrefTimer(setTimeout(() => {
+        if (generation !== conn.generation)
+            return;
+        const current = conn.pending;
+        if (!current || current !== pending || current.done)
+            return;
+        current.idleTimer = null;
+        conn.lastCloseCode = 1006;
+        conn.lastCloseReason = "response idle timeout";
+        fail(conn, new Error(formatFailureMessage(conn, `response idle timeout after ${reason}`)), true);
+    }, transportConfig.responseIdleTimeoutMs));
 }
 function parseFrames(data) {
     const text = typeof data === "string" ? data : Buffer.isBuffer(data) ? data.toString("utf8") : String(data);
@@ -185,11 +290,56 @@ function parseFrames(data) {
     }
     return frames;
 }
+function numberFrom(value) {
+    if (typeof value === "number")
+        return value;
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    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;
+    if (code === "websocket_connection_limit_reached") {
+        return new Error(message ?? "Responses websocket connection limit reached (60 minutes). Create a new websocket connection to continue.");
+    }
+    const status = numberFrom(frame.status) ?? numberFrom(frame.status_code) ?? numberFrom(error.status) ?? numberFrom(error.status_code);
+    if (status !== undefined && status >= 200 && status < 300)
+        return undefined;
+    return new Error(`OpenAI WebSocket error${status !== undefined ? ` ${status}` : ""}${code ? ` ${code}` : ""}${message ? `: ${message}` : ""}`);
+}
+function sendResponseProcessed(conn, pending, eventType) {
+    if (eventType !== "response.completed")
+        return;
+    if (process.env[RESPONSE_PROCESSED_ENV] !== "1")
+        return;
+    if (pending.processedAckSent || !pending.metadata.responseId)
+        return;
+    try {
+        conn.ws?.send(JSON.stringify({ type: "response.processed", response_id: pending.metadata.responseId }));
+        pending.processedAckSent = true;
+    }
+    catch (error) {
+        conn.lastErrorMessage = error instanceof Error ? error.message : String(error);
+    }
+}
 function enqueueSSE(conn, frame) {
     const pending = conn.pending;
     if (!pending || pending.done)
         return;
     const eventType = typeof frame.type === "string" ? frame.type : "message";
+    cacheResponseMetadata(pending, frame);
+    const mappedError = wrappedWebSocketError(frame);
+    if (mappedError) {
+        fail(conn, mappedError, true);
+        return;
+    }
     const encoded = new TextEncoder().encode(`event: ${eventType}\ndata: ${JSON.stringify(frame)}\n\n`);
     try {
         pending.controller.enqueue(encoded);
@@ -197,14 +347,21 @@ function enqueueSSE(conn, frame) {
     catch {
         return;
     }
-    pending.forwarded = true;
-    if (["response.completed", "response.failed", "response.incomplete", "error"].includes(eventType)) {
+    if (!isTerminalEvent(eventType))
+        schedulePendingIdleTimeout(conn, eventType);
+    if (isTerminalEvent(eventType)) {
+        finalizePending(pending);
         pending.done = true;
+        sendResponseProcessed(conn, pending, eventType);
         try {
             pending.controller.close();
         }
         catch { }
-        release(conn);
+        if (pending.metadata.responseId) {
+            conn.lastResponseID = pending.metadata.responseId;
+            lastResponseIDByContext.set(conn.contextKey, pending.metadata.responseId);
+        }
+        terminalRelease(conn);
     }
 }
 export function sendPending(conn) {
@@ -215,7 +372,10 @@ export function sendPending(conn) {
     if (!ws || ws.readyState !== readyState.OPEN)
         return false;
     try {
-        ws.send(JSON.stringify({ type: "response.create", ...pending.body }));
+        const body = { ...pending.body };
+        if (body.previous_response_id === undefined && conn.lastResponseID)
+            body.previous_response_id = conn.lastResponseID;
+        ws.send(JSON.stringify({ ...body, type: "response.create" }));
     }
     catch (error) {
         conn.lastErrorMessage = error instanceof Error ? error.message : String(error);
@@ -223,6 +383,7 @@ export function sendPending(conn) {
         return false;
     }
     pending.sent = true;
+    schedulePendingIdleTimeout(conn, "response.create");
     return true;
 }
 function normalizeCloseReason(reason) {
@@ -238,17 +399,17 @@ function normalizeCloseReason(reason) {
 }
 function connect(conn) {
     clearHeartbeat(conn);
-    const ws = new WebSocketImpl(conn.wsUrl, { headers: conn.headers });
     const generation = ++conn.generation;
-    conn.ws = ws;
     clearTimer(conn.retryTimer);
     conn.retryTimer = null;
     clearTimer(conn.connectTimer);
     const connectTimer = setTimeout(() => {
-        if (generation !== conn.generation || ws.readyState === readyState.OPEN)
+        if (generation !== conn.generation || conn.ws?.readyState === readyState.OPEN)
             return;
-        fail(conn, new Error("WebSocket connection timed out"), true);
-    }, DEFAULT_CONNECT_TIMEOUT_MS);
+        conn.lastCloseCode = 1006;
+        conn.lastCloseReason = "connection timed out";
+        handleSocketLoss(conn);
+    }, transportConfig.connectTimeoutMs);
     conn.connectTimer = unrefTimer(connectTimer);
     const handleOpen = () => {
         if (generation !== conn.generation)
@@ -256,12 +417,29 @@ function connect(conn) {
         clearTimer(conn.connectTimer);
         conn.connectTimer = null;
         conn.lastActivityAt = Date.now();
+        scheduleHeartbeat(conn);
         sendPending(conn);
     };
-    const handleMessage = (data) => {
+    const handleUpgrade = (response) => {
+        if (generation !== conn.generation)
+            return;
+        const turnState = headerValue(response, X_CODEX_TURN_STATE_HEADER);
+        if (turnState) {
+            conn.turnState = turnState;
+            turnStateByContext.set(conn.contextKey, turnState);
+        }
+        conn.serverReasoningIncluded = headerValue(response, X_REASONING_INCLUDED_HEADER) !== undefined;
+        conn.modelsEtag = headerValue(response, X_MODELS_ETAG_HEADER);
+        conn.serverModel = headerValue(response, OPENAI_MODEL_HEADER);
+    };
+    const handleMessage = (data, isBinary) => {
         if (generation !== conn.generation)
             return;
         conn.lastActivityAt = Date.now();
+        if (isBinary) {
+            fail(conn, new Error("unexpected binary websocket event"), true);
+            return;
+        }
         for (const frame of parseFrames(data))
             enqueueSSE(conn, frame);
     };
@@ -271,8 +449,7 @@ function connect(conn) {
         conn.lastActivityAt = Date.now();
         clearTimer(conn.pongTimer);
         conn.pongTimer = null;
-        if (!conn.busy && !conn.pending)
-            scheduleHeartbeat(conn);
+        scheduleHeartbeat(conn);
     };
     const handleError = (error) => {
         if (generation !== conn.generation)
@@ -291,18 +468,31 @@ function connect(conn) {
             conn.lastCloseReason = normalizedReason;
         handleSocketLoss(conn);
     };
+    const ws = new WebSocketImpl(conn.wsUrl, {
+        headers: conn.headers,
+        perMessageDeflate: true,
+        finishRequest(request) {
+            request.on?.("upgrade", handleUpgrade);
+            request.end?.();
+        },
+    });
+    conn.ws = ws;
     on(ws, "open", handleOpen);
+    on(ws, "upgrade", handleUpgrade);
     on(ws, "message", handleMessage);
     on(ws, "pong", handlePong);
     on(ws, "error", handleError);
     on(ws, "close", handleClose);
     conn.detach = () => {
         off(ws, "open", handleOpen);
+        off(ws, "upgrade", handleUpgrade);
         off(ws, "message", handleMessage);
         off(ws, "pong", handlePong);
         off(ws, "error", handleError);
         off(ws, "close", handleClose);
     };
+    if (ws.readyState === readyState.OPEN)
+        queueMicrotask(handleOpen);
 }
 function handleSocketLoss(conn) {
     clearTimer(conn.connectTimer);
@@ -310,17 +500,18 @@ function handleSocketLoss(conn) {
     clearHeartbeat(conn);
     const pending = conn.pending;
     if (!pending || pending.done) {
-        remove(conn);
-        try {
-            conn.ws?.terminate?.();
-        }
-        catch { }
+        finalizePending(pending);
+        removeAndDrain(conn);
+        closeSocket(conn, 1000, "socket lost");
         return;
     }
-    const canRetry = !pending.forwarded && conn.reconnectAttempts < MAX_RECONNECT_ATTEMPTS;
+    if (pending.sent) {
+        fail(conn, new Error(formatFailureMessage(conn, "response.create was already sent")), true);
+        return;
+    }
+    const canRetry = conn.reconnectAttempts < transportConfig.maxReconnectAttempts;
     if (canRetry) {
         conn.reconnectAttempts++;
-        pending.sent = false;
         const priorWs = conn.ws;
         detach(conn);
         try {
@@ -334,27 +525,32 @@ function handleSocketLoss(conn) {
         conn.ws = null;
         conn.retryTimer = unrefTimer(setTimeout(() => {
             conn.retryTimer = null;
-            if (!connectionPool.includes(conn) || !conn.pending || conn.pending.done || conn.pending.forwarded)
+            if (!connectionPool.includes(conn) || !conn.pending || conn.pending.done || conn.pending.sent)
                 return;
             connect(conn);
-        }, RECONNECT_DELAY_MS));
+        }, retryDelay(conn.reconnectAttempts)));
         return;
     }
-    const reason = pending.forwarded
-        ? "stream already forwarded data"
-        : "retry limit reached before any frame was forwarded";
-    fail(conn, new Error(formatFailureMessage(conn, reason)), true);
+    fail(conn, new Error(formatFailureMessage(conn, "retry limit reached before response.create was sent")), true);
 }
-function create(wsUrl, headers) {
+function create(wsUrl, headers, context = {}, warm = false) {
+    const hash = authScopeHash(headers);
+    const key = contextScopeKey(wsUrl, headers, context);
     const conn = {
+        id: `ws-${nextConnectionID++}`,
         ws: null,
         wsUrl,
-        headers,
-        scopeKey: scopeKey(wsUrl, headers),
+        headers: headersForConnection(wsUrl, headers, context, key),
+        scopeKey: key,
+        scopeHash: hash,
+        contextKey: key,
         busy: false,
+        warm,
         pending: null,
+        lastResponseID: lastResponseIDByContext.get(key),
         generation: 0,
         reconnectAttempts: 0,
+        createdAt: Date.now(),
         lastActivityAt: Date.now(),
         idleTimer: null,
         connectTimer: null,
@@ -372,9 +568,11 @@ function isReusable(conn, key, context, now) {
         return false;
     if (conn.scopeKey !== key)
         return false;
-    if (conn.ws?.readyState !== readyState.OPEN)
+    if (conn.ws?.readyState !== readyState.OPEN && conn.ws?.readyState !== readyState.CONNECTING)
         return false;
-    if (now - conn.lastActivityAt > STALE_REUSE_MS)
+    if (now - conn.lastActivityAt > transportConfig.staleReuseMs)
+        return false;
+    if (now - conn.createdAt > transportConfig.connectionMaxAgeMs)
         return false;
     if (context.sessionID && conn.lastSessionID && conn.lastSessionID !== context.sessionID)
         return false;
@@ -382,13 +580,16 @@ function isReusable(conn, key, context, now) {
         return false;
     return true;
 }
-export function acquireConnection(wsUrl, headers, context) {
-    const key = scopeKey(wsUrl, headers);
-    const now = Date.now();
+function activeCount(key) {
+    return connectionPool.filter((conn) => conn.scopeKey === key && (conn.busy || conn.ws?.readyState === readyState.CONNECTING)).length;
+}
+function cleanupStaleConnections(key, now) {
     for (const candidate of [...connectionPool]) {
         if (candidate.busy || candidate.scopeKey !== key)
             continue;
-        if (candidate.ws?.readyState === readyState.OPEN && now - candidate.lastActivityAt > STALE_REUSE_MS) {
+        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");
@@ -396,34 +597,134 @@ export function acquireConnection(wsUrl, headers, context) {
             catch { }
         }
     }
+}
+function reserveConnection(wsUrl, headers, context) {
+    const key = contextScopeKey(wsUrl, headers, context);
+    const now = Date.now();
+    cleanupStaleConnections(key, now);
     const reusable = connectionPool.find((conn) => isReusable(conn, key, context, now));
-    const conn = reusable ?? create(wsUrl, headers);
-    clearTimer(conn.idleTimer);
-    conn.idleTimer = null;
-    clearHeartbeat(conn);
+    if (reusable) {
+        clearTimer(reusable.idleTimer);
+        reusable.idleTimer = null;
+        clearHeartbeat(reusable);
+        reusable.busy = true;
+        reusable.warm = false;
+        return reusable;
+    }
+    if (activeCount(key) >= transportConfig.maxConnectionsPerScope)
+        return null;
+    const conn = create(wsUrl, headers, context);
     conn.busy = true;
     return conn;
 }
-export function closeConnections(predicate = () => true) {
+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);
+    });
+}
+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 (queue.length === 0)
+        acquisitionQueues.delete(key);
+}
+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 ensureWarmConnection(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);
+    if (existing) {
+        existing.warm = true;
+        clearTimer(existing.idleTimer);
+        existing.idleTimer = null;
+        scheduleHeartbeat(existing);
+        return existing;
+    }
+    if (activeCount(key) >= transportConfig.maxConnectionsPerScope)
+        return undefined;
+    return create(wsUrl, headers, {}, true);
+}
+export function closeConnections(predicate = () => true, message = "Session disposed") {
     for (const conn of [...connectionPool]) {
         if (!predicate(conn))
             continue;
-        fail(conn, new Error("Session disposed"), true);
+        fail(conn, new Error(message), true);
     }
 }
 export function resetPoolForTesting() {
     for (const conn of [...connectionPool]) {
+        try {
+            conn.ws?.terminate?.();
+        }
+        catch { }
         try {
             conn.ws?.close(1000, "test reset");
         }
         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();
 }
 export function setWebSocketConstructorForTesting(ctor) {
     WebSocketImpl = ctor;
 }
 export function resetWebSocketConstructorForTesting() {
-    WebSocketImpl = WebSocket;
+    WebSocketImpl = loadDefaultWebSocketConstructor();
 }
 //# sourceMappingURL=pool.js.map