openai-ws-opencode 0.1.28 → 0.1.30

package/dist/transport/pool.js

@@ -9,10 +9,14 @@ let WebSocketImpl = loadDefaultWebSocketConstructor();
 export const connectionPool = [];
 const turnStateByContext = new Map();
 const lastResponseIDByContext = new Map();
+const contextEpochByKey = new Map();
+const contextOwnerByKey = new Map();
 const scopeCooldowns = new Map();
 const authEndpoints = new Map();
+const OAUTH_MISSING_ACCOUNT_SEED = "codex-oauth-missing-account";
 let nextConnectionID = 1;
 let nextStreamID = 1;
+let contextEpochClock = 1;
 export const readyState = {
     CONNECTING: 0,
     OPEN: 1,
@@ -39,14 +43,25 @@ function authScopeHash(headers) {
         .join("\n");
     return crypto.createHash("sha256").update(auth).digest("hex");
 }
-function accountFingerprint(headers) {
+function accountFingerprint(headers, wsUrl) {
     const account = headers["ChatGPT-Account-ID"] ?? headers["ChatGPT-Account-Id"] ?? headers["chatgpt-account-id"] ?? "";
     if (account) {
         return crypto.createHash("sha256").update(`acct:${account}`).digest("hex").slice(0, 32);
     }
+    // Codex OAuth without account id: stable shared sentinel so bearer rotation cannot bypass account caps.
+    if (providerForUrl(wsUrl) === "codex") {
+        return crypto.createHash("sha256").update(`acct:${OAUTH_MISSING_ACCOUNT_SEED}`).digest("hex").slice(0, 32);
+    }
+    // Public API keys: fingerprint by auth material.
     const auth = headers.Authorization ?? headers.authorization ?? "";
     return crypto.createHash("sha256").update(`auth:${auth}`).digest("hex").slice(0, 32);
 }
+function authGenerationKey(endpoint, accountFp) {
+    return `${endpoint}::${accountFp}`;
+}
+function hashIdentity(kind, value) {
+    return crypto.createHash("sha256").update(`${kind}:${value}`).digest("hex").slice(0, 32);
+}
 function breakerDomainKey(provider, origin, accountFp) {
     return crypto.createHash("sha256").update(`${provider}\n${origin}\n${accountFp}`).digest("hex");
 }
@@ -60,7 +75,92 @@ function scopeKey(wsUrl, headers) {
     return `${wsUrl}::${authScopeHash(headers)}`;
 }
 function contextScopeKey(wsUrl, headers, context) {
-    return `${scopeKey(wsUrl, headers)}::session:${context.sessionID ?? ""}::agent:${context.agent ?? ""}`;
+    const sessionHash = context.sessionID ? hashIdentity("session", context.sessionID) : "";
+    const agentHash = context.agent ? hashIdentity("agent", context.agent) : "";
+    return `${scopeKey(wsUrl, headers)}::ctx:${sessionHash}::agt:${agentHash}`;
+}
+function contextKeyMatchesSession(contextKey, sessionID) {
+    const sessionHash = hashIdentity("session", sessionID);
+    return contextKey.includes(`::ctx:${sessionHash}::`);
+}
+function contextEntryCount() {
+    const keys = new Set();
+    for (const key of turnStateByContext.keys())
+        keys.add(key);
+    for (const key of lastResponseIDByContext.keys())
+        keys.add(key);
+    for (const key of contextEpochByKey.keys())
+        keys.add(key);
+    for (const key of contextOwnerByKey.keys())
+        keys.add(key);
+    return keys.size;
+}
+function scrubIdleConnectionContext(contextKey) {
+    for (const conn of connectionPool) {
+        if (conn.contextKey !== contextKey || conn.busy)
+            continue;
+        conn.lastResponseID = undefined;
+        conn.turnState = undefined;
+    }
+}
+function boundContextMaps() {
+    const max = transportConfig.maxAccountingEntries;
+    while (contextEntryCount() > max) {
+        const oldest = contextEpochByKey.keys().next().value ??
+            turnStateByContext.keys().next().value ??
+            lastResponseIDByContext.keys().next().value ??
+            contextOwnerByKey.keys().next().value;
+        if (oldest === undefined)
+            break;
+        turnStateByContext.delete(oldest);
+        lastResponseIDByContext.delete(oldest);
+        contextEpochByKey.delete(oldest);
+        contextOwnerByKey.delete(oldest);
+        // Evicted map keys must not be reintroduced from idle local connection state.
+        scrubIdleConnectionContext(oldest);
+    }
+}
+function currentContextEpoch(contextKey) {
+    return contextEpochByKey.get(contextKey) ?? 0;
+}
+function bumpContextEpoch(contextKey) {
+    const next = Math.max(contextEpochClock, currentContextEpoch(contextKey) + 1);
+    contextEpochClock = next + 1;
+    contextEpochByKey.delete(contextKey);
+    contextEpochByKey.set(contextKey, next);
+    boundContextMaps();
+    return next;
+}
+function setContextMapValue(map, contextKey, value) {
+    map.delete(contextKey);
+    map.set(contextKey, value);
+    if (!contextEpochByKey.has(contextKey)) {
+        contextEpochByKey.set(contextKey, currentContextEpoch(contextKey));
+    }
+    else {
+        const epoch = contextEpochByKey.get(contextKey);
+        contextEpochByKey.delete(contextKey);
+        contextEpochByKey.set(contextKey, epoch);
+    }
+    boundContextMaps();
+}
+function clearContextAccounting(contextKey, options = {}) {
+    turnStateByContext.delete(contextKey);
+    lastResponseIDByContext.delete(contextKey);
+    contextOwnerByKey.delete(contextKey);
+    if (options.bumpEpoch !== false)
+        bumpContextEpoch(contextKey);
+    else
+        boundContextMaps();
+}
+function canPublishContextState(conn) {
+    if (conn.staleAuth || !isCurrentAuth(conn))
+        return false;
+    return conn.contextEpoch === currentContextEpoch(conn.contextKey);
+}
+function admitContextTurn(conn) {
+    conn.contextEpoch = currentContextEpoch(conn.contextKey);
+    setContextMapValue(contextOwnerByKey, conn.contextKey, conn.id);
 }
 function headersForConnection(wsUrl, baseHeaders, context, key) {
     const headers = { ...baseHeaders };
@@ -143,11 +243,12 @@ function boundAuthEndpoints() {
         authEndpoints.delete(oldest);
     }
 }
-function bindAuthGeneration(endpoint, hash) {
-    let state = authEndpoints.get(endpoint);
+function bindAuthGeneration(endpoint, accountFp, hash) {
+    const key = authGenerationKey(endpoint, accountFp);
+    let state = authEndpoints.get(key);
     if (!state) {
         state = { currentGeneration: 1, currentHash: hash, bindings: new Map([[hash, 1]]), order: [hash] };
-        authEndpoints.set(endpoint, state);
+        authEndpoints.set(key, state);
         boundAuthEndpoints();
         return 1;
     }
@@ -171,13 +272,17 @@ function bindAuthGeneration(endpoint, hash) {
         }
         state.bindings.delete(oldest);
     }
+    // Refresh map insertion order for bounded eviction fairness.
+    authEndpoints.delete(key);
+    authEndpoints.set(key, state);
+    boundAuthEndpoints();
     return state.currentGeneration;
 }
-function currentAuthGeneration(endpoint) {
-    return authEndpoints.get(endpoint)?.currentGeneration ?? 0;
+function currentAuthGeneration(endpoint, accountFp) {
+    return authEndpoints.get(authGenerationKey(endpoint, accountFp))?.currentGeneration ?? 0;
 }
 function isCurrentAuth(conn) {
-    return conn.authGeneration === currentAuthGeneration(conn.endpointKey);
+    return conn.authGeneration === currentAuthGeneration(conn.endpointKey, conn.accountFp);
 }
 function finishConnectPermit(conn, result) {
     if (!conn.connectPermit || conn.connectFinished)
@@ -554,8 +659,10 @@ function clearLastResponseID(conn) {
     lastResponseIDByContext.delete(conn.contextKey);
 }
 function persistLastResponseID(conn, responseID) {
+    if (!canPublishContextState(conn))
+        return;
     conn.lastResponseID = responseID;
-    lastResponseIDByContext.set(conn.contextKey, responseID);
+    setContextMapValue(lastResponseIDByContext, conn.contextKey, responseID);
 }
 function frameResponseID(frame) {
     let responseID;
@@ -805,6 +912,7 @@ function connect(conn) {
             return;
         conn.lastCloseCode = 1006;
         conn.lastCloseReason = "connection timed out";
+        conn.sawConnectTimeout = true;
         finishConnectPermit(conn, { success: false, breakerEligible: true, timeout: true });
         handleSocketLoss(conn);
     }, transportConfig.connectTimeoutMs);
@@ -822,14 +930,32 @@ function connect(conn) {
         if (generation !== conn.generation)
             return;
         const turnState = headerValue(response, X_CODEX_TURN_STATE_HEADER);
-        if (turnState) {
+        if (turnState && canPublishContextState(conn)) {
             conn.turnState = turnState;
-            turnStateByContext.set(conn.contextKey, turnState);
+            setContextMapValue(turnStateByContext, 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 rejectInboundOverflow = (message, probeBytes) => {
+        const streamKey = conn.pending?.streamKey ?? `overflow:${conn.id}`;
+        // Non-mutating reject path: oversized probe increments queueOverflows and retains zero bytes.
+        getTransportCoordinator().adjustQueue({
+            provider: conn.provider,
+            streamKey,
+            bytes: probeBytes,
+            messages: 1,
+        });
+        fail(conn, transportError({
+            code: "queue_overflow",
+            phase: "active",
+            message,
+            fallbackEligible: false,
+            breakerEligible: false,
+            safeToReplay: false,
+        }), true);
+    };
     const handleMessage = (data, isBinary) => {
         if (generation !== conn.generation)
             return;
@@ -838,7 +964,23 @@ function connect(conn) {
             fail(conn, new Error("unexpected binary websocket event"), true);
             return;
         }
+        const decoded = decodeFrameData(data);
+        const maxBytes = transportConfig.queueMaxBytesPerStream;
+        const incomingBytes = Buffer.byteLength(decoded, "utf8");
+        if (incomingBytes > maxBytes) {
+            rejectInboundOverflow("OpenAI WebSocket inbound frame queue overflow", incomingBytes);
+            return;
+        }
+        const carryBytes = Buffer.byteLength(conn.frameCarryover, "utf8");
+        if (carryBytes + incomingBytes > maxBytes) {
+            rejectInboundOverflow("OpenAI WebSocket inbound carryover queue overflow", carryBytes + incomingBytes);
+            return;
+        }
         const parsed = parseFrames(data, conn.frameCarryover);
+        if (Buffer.byteLength(parsed.carryover, "utf8") > maxBytes) {
+            rejectInboundOverflow("OpenAI WebSocket inbound carryover queue overflow", Buffer.byteLength(parsed.carryover, "utf8"));
+            return;
+        }
         conn.frameCarryover = parsed.carryover;
         for (const frame of parsed.frames)
             enqueueSSE(conn, frame);
@@ -847,6 +989,7 @@ function connect(conn) {
         if (generation !== conn.generation)
             return;
         conn.lastErrorMessage = messageFromError(error) ?? "unknown websocket error";
+        conn.sawConnectNonTimeout = true;
         finishConnectPermit(conn, { success: false, breakerEligible: true });
         handleSocketLoss(conn);
     };
@@ -860,6 +1003,8 @@ function connect(conn) {
         else if (conn.lastCloseReason === undefined && closeCodeFrom(codeOrEvent) === undefined) {
             conn.lastCloseReason = "socket closed without close code";
         }
+        if (conn.lastCloseReason !== "connection timed out")
+            conn.sawConnectNonTimeout = true;
         finishConnectPermit(conn, { success: false, breakerEligible: true });
         handleSocketLoss(conn);
     };
@@ -871,6 +1016,7 @@ function connect(conn) {
             conn.lastCloseCode = status;
         conn.retryAfterMs = parseRetryAfterMs(response);
         conn.lastCloseReason = `websocket handshake failed${status !== undefined ? ` with status ${status}` : ""}`;
+        conn.sawConnectNonTimeout = true;
         finishConnectPermit(conn, { success: false, breakerEligible: true });
         handleSocketLoss(conn);
     };
@@ -879,7 +1025,7 @@ function connect(conn) {
     try {
         ws = new WebSocketImpl(conn.wsUrl, {
             headers: conn.headers,
-            perMessageDeflate: true,
+            perMessageDeflate: false,
             finishRequest(request) {
                 if (attachUpgrade)
                     request.on?.("upgrade", handleUpgrade);
@@ -889,6 +1035,7 @@ function connect(conn) {
     }
     catch (error) {
         conn.lastErrorMessage = messageFromError(error) ?? "websocket constructor failed";
+        conn.sawConnectNonTimeout = true;
         finishConnectPermit(conn, { success: false, breakerEligible: true });
         queueMicrotask(() => handleSocketLoss(conn));
         return;
@@ -911,6 +1058,10 @@ function connect(conn) {
         off(ws, "close", handleClose);
         if (attachUpgrade)
             off(ws, "unexpected-response", handleUnexpectedResponse);
+        // Keep one inert terminal listener on the detached socket so a late EventEmitter
+        // 'error' after terminate/close (common while CONNECTING) cannot throw unhandled.
+        // Retry disposal calls detach() directly before closing the prior socket.
+        on(ws, "error", () => { });
     };
     if (ws.readyState === readyState.OPEN)
         queueMicrotask(handleOpen);
@@ -964,12 +1115,24 @@ function handleSocketLoss(conn) {
             if (!connectionPool.includes(conn) || !conn.pending || conn.pending.done || conn.pending.sent || conn.pending.writeCommitted) {
                 return;
             }
+            if (conn.staleAuth || !isCurrentAuth(conn)) {
+                getTransportCoordinator().noteAuthStale();
+                fail(conn, transportError({
+                    code: "stale_auth",
+                    phase: "pre_send",
+                    message: "OpenAI WebSocket auth generation is stale; refusing reconnect",
+                    fallbackEligible: true,
+                    safeToReplay: true,
+                }), true);
+                return;
+            }
             connect(conn);
         }, retryDelay(conn.reconnectAttempts, retryAfterMs)));
         return;
     }
+    const allTimeouts = conn.sawConnectTimeout && !conn.sawConnectNonTimeout;
     fail(conn, transportError({
-        code: "connect_failure",
+        code: allTimeouts ? "handshake_timeout" : "connect_failure",
         phase: "handshake",
         message: formatFailureMessage(conn, "retry limit reached before response.create was sent"),
         fallbackEligible: true,
@@ -987,7 +1150,7 @@ function create(wsUrl, headers, context = {}, warm = false, permit) {
     const endpoint = endpointKey(wsUrl);
     const provider = providerForUrl(wsUrl);
     const origin = canonicalWebSocketOrigin(wsUrl);
-    const accountFp = accountFingerprint(headers);
+    const accountFp = accountFingerprint(headers, wsUrl);
     const now = Date.now();
     const conn = {
         id: `ws-${nextConnectionID++}`,
@@ -1001,7 +1164,7 @@ function create(wsUrl, headers, context = {}, warm = false, permit) {
         accountFp,
         provider,
         origin,
-        authGeneration: bindAuthGeneration(endpoint, hash),
+        authGeneration: bindAuthGeneration(endpoint, accountFp, hash),
         busy: false,
         warm,
         staleAuth: false,
@@ -1025,6 +1188,9 @@ function create(wsUrl, headers, context = {}, warm = false, permit) {
         turnCount: 0,
         intent: warm ? "prewarm" : "demand",
         breakerDomain: breakerDomainKey(provider, origin, accountFp),
+        contextEpoch: currentContextEpoch(key),
+        sawConnectTimeout: false,
+        sawConnectNonTimeout: false,
     };
     connectionPool.push(conn);
     getTransportCoordinator().adjustSessions(1);
@@ -1055,20 +1221,25 @@ function activeBusy(key) {
 }
 export function invalidateStaleAuthConnections(wsUrl, headers) {
     const endpoint = endpointKey(wsUrl);
+    const accountFp = accountFingerprint(headers, wsUrl);
     const hash = authScopeHash(headers);
-    const state = authEndpoints.get(endpoint);
+    const authKey = authGenerationKey(endpoint, accountFp);
+    const state = authEndpoints.get(authKey);
     // 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;
+    const generation = bindAuthGeneration(endpoint, accountFp, hash);
+    const keepHash = authEndpoints.get(authKey)?.currentHash ?? hash;
+    const keepGen = authEndpoints.get(authKey)?.currentGeneration ?? generation;
     for (const conn of [...connectionPool]) {
         if (conn.wsUrl !== wsUrl)
             continue;
+        if (conn.accountFp !== accountFp)
+            continue;
         if (conn.scopeHash === keepHash && conn.authGeneration === keepGen)
             continue;
         conn.staleAuth = true;
+        clearContextAccounting(conn.contextKey);
         if (conn.busy)
             continue;
         remove(conn);
@@ -1124,8 +1295,9 @@ function reserveConnection(wsUrl, headers, context) {
     }
     const endpoint = endpointKey(wsUrl);
     const hash = authScopeHash(headers);
-    const generation = bindAuthGeneration(endpoint, hash);
-    if (generation !== currentAuthGeneration(endpoint)) {
+    const accountFp = accountFingerprint(headers, wsUrl);
+    const generation = bindAuthGeneration(endpoint, accountFp, hash);
+    if (generation !== currentAuthGeneration(endpoint, accountFp)) {
         coordinator.noteAuthStale();
         admitMiss("stale_auth", "OpenAI WebSocket auth generation is stale");
     }
@@ -1137,10 +1309,13 @@ function reserveConnection(wsUrl, headers, context) {
         reusable.warm = false;
         reusable.intent = "demand";
         reusable.turnCount += 1;
+        // Always take the bounded map as source of truth, including absences after clear/eviction.
+        reusable.lastResponseID = lastResponseIDByContext.get(key);
+        reusable.turnState = turnStateByContext.get(key);
+        admitContextTurn(reusable);
         coordinator.noteLeaseAdmission();
         return reusable;
     }
-    const accountFp = accountFingerprint(headers);
     const provider = providerForUrl(wsUrl);
     const origin = canonicalWebSocketOrigin(wsUrl);
     const reserved = coordinator.reserveSocket({ accountFp, provider, intent: "demand" });
@@ -1161,17 +1336,18 @@ function reserveConnection(wsUrl, headers, context) {
     const conn = create(wsUrl, headers, context, false, started.permit);
     conn.busy = true;
     conn.turnCount += 1;
+    admitContextTurn(conn);
     coordinator.noteLeaseAdmission();
     return conn;
 }
 export function acquireConnection(wsUrl, headers, context, _signal) {
     return reserveConnection(wsUrl, headers, context);
 }
-export function ensureWarmConnection(wsUrl, headers) {
+export function ensureWarmConnection(wsUrl, headers, context = {}) {
     const coordinator = getTransportCoordinator();
     coordinator.notePrewarmAttempt();
     invalidateStaleAuthConnections(wsUrl, headers);
-    const key = contextScopeKey(wsUrl, headers, {});
+    const key = contextScopeKey(wsUrl, headers, context);
     const now = Date.now();
     cleanupExpiredIdle(now);
     const existing = connectionPool.find((conn) => conn.scopeKey === key &&
@@ -1185,7 +1361,7 @@ export function ensureWarmConnection(wsUrl, headers) {
         existing.idleTimer = null;
         return existing;
     }
-    const accountFp = accountFingerprint(headers);
+    const accountFp = accountFingerprint(headers, wsUrl);
     const provider = providerForUrl(wsUrl);
     const origin = canonicalWebSocketOrigin(wsUrl);
     const reserved = coordinator.reserveSocket({ accountFp, provider, intent: "prewarm" });
@@ -1205,7 +1381,66 @@ export function ensureWarmConnection(wsUrl, headers) {
         coordinator.notePrewarmDeferred();
         return undefined;
     }
-    return create(wsUrl, headers, {}, true, started.permit);
+    return create(wsUrl, headers, context, true, started.permit);
+}
+export function clearTransportContextState(wsUrl, headers, context) {
+    const key = contextScopeKey(wsUrl, headers, context);
+    clearContextAccounting(key);
+    for (const conn of connectionPool) {
+        if (conn.contextKey !== key)
+            continue;
+        conn.lastResponseID = undefined;
+        conn.turnState = undefined;
+    }
+}
+export function clearSessionTransportState(sessionID) {
+    const keys = new Set();
+    for (const key of turnStateByContext.keys()) {
+        if (contextKeyMatchesSession(key, sessionID))
+            keys.add(key);
+    }
+    for (const key of lastResponseIDByContext.keys()) {
+        if (contextKeyMatchesSession(key, sessionID))
+            keys.add(key);
+    }
+    for (const key of contextEpochByKey.keys()) {
+        if (contextKeyMatchesSession(key, sessionID))
+            keys.add(key);
+    }
+    for (const key of contextOwnerByKey.keys()) {
+        if (contextKeyMatchesSession(key, sessionID))
+            keys.add(key);
+    }
+    for (const key of scopeCooldowns.keys()) {
+        if (contextKeyMatchesSession(key, sessionID))
+            scopeCooldowns.delete(key);
+    }
+    for (const key of keys)
+        clearContextAccounting(key);
+    for (const conn of connectionPool) {
+        if (!contextKeyMatchesSession(conn.contextKey, sessionID))
+            continue;
+        conn.lastResponseID = undefined;
+        conn.turnState = undefined;
+    }
+}
+export function clearAllTransportState() {
+    const keys = new Set([
+        ...turnStateByContext.keys(),
+        ...lastResponseIDByContext.keys(),
+        ...contextEpochByKey.keys(),
+        ...contextOwnerByKey.keys(),
+    ]);
+    for (const key of keys)
+        clearContextAccounting(key);
+    turnStateByContext.clear();
+    lastResponseIDByContext.clear();
+    contextOwnerByKey.clear();
+    // Keep bumped epochs so in-flight completions cannot republish under a recycled 0 epoch.
+    for (const conn of connectionPool) {
+        conn.lastResponseID = undefined;
+        conn.turnState = undefined;
+    }
 }
 export function closeConnections(predicate = () => true, message = "Session disposed") {
     for (const conn of [...connectionPool]) {
@@ -1251,7 +1486,10 @@ export function syncCoordinatorFromTransportConfig() {
     });
 }
 export function getTransportSnapshotForTesting() {
-    return getTransportCoordinator().snapshot();
+    return {
+        ...getTransportCoordinator().snapshot(),
+        contextEntries: contextEntryCount(),
+    };
 }
 export function resetPoolForTesting() {
     for (const conn of [...connectionPool]) {
@@ -1267,8 +1505,11 @@ export function resetPoolForTesting() {
     }
     turnStateByContext.clear();
     lastResponseIDByContext.clear();
+    contextEpochByKey.clear();
+    contextOwnerByKey.clear();
     scopeCooldowns.clear();
     authEndpoints.clear();
+    contextEpochClock = 1;
     nextStreamID = 1;
     resetTransportCoordinatorForTesting();
     syncCoordinatorFromTransportConfig();