codex-multi-auth 2.22.0 → 2.24.0

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

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

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

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

package/dist/lib/runtime/rotation-proxy-state.d.ts

@@ -1,3 +1,4 @@
+import type { ResetExhaustionEvidence } from "./reset-credits.js";
 import type { NativeAccountSnapshot } from "./native-account-storage.js";
 import type { QuotaCacheData, QuotaCacheEntry } from "../quota-cache.js";
 import type { RuntimeCapabilityFailures } from "./runtime-capability-failures.js";
@@ -98,6 +99,8 @@ export interface RotationProxyState extends RotationProxyStateInit {
     catalogApiRoutes?: ApiRouteCredential[];
     catalogInventory?: ModelInventory;
     subscriptionQuotaObservations?: Map<string, QuotaCacheEntry>;
+    /** Explicit pre-inference quota rejections, scoped to immutable workspace/model identity. */
+    subscriptionQuotaRejections?: Map<string, ResetExhaustionEvidence>;
     readonly threadGoalFallbacks: Map<string, string | null>;
     lastGlobalAccountIndex: number | null;
     lastGlobalSwitchAt: number;

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

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

package/dist/lib/runtime/subscription-quota-order.d.ts

@@ -9,6 +9,7 @@ export interface SubscriptionQuotaPreference {
 }
 export declare const SUBSCRIPTION_RESERVE_PERCENT = 5;
 export declare const SUBSCRIPTION_QUOTA_MAX_AGE_MS: number;
+export declare function hasFreshOrdinaryUsagePermission(entry: QuotaCacheEntry | null | undefined, now: number): boolean;
 /** Scheduling hint only; percentages are not comparable dollar/token balances. */
 export declare function subscriptionQuotaPreference(entry: QuotaCacheEntry | null | undefined, now: number): SubscriptionQuotaPreference;
 export declare function usesSubscriptionReserve(preference: SubscriptionQuotaPreference | undefined): boolean;

package/dist/lib/runtime/subscription-quota-order.js

@@ -1,11 +1,15 @@
 import { isQuotaCacheEntryExhausted } from "../quota-readiness.js";
 export const SUBSCRIPTION_RESERVE_PERCENT = 5;
 export const SUBSCRIPTION_QUOTA_MAX_AGE_MS = 15 * 60_000;
+export function hasFreshOrdinaryUsagePermission(entry, now) {
+    const checkedAt = entry?.ordinaryUsageCheckedAt ?? entry?.updatedAt;
+    return entry?.status === 200 && entry.ordinaryUsageAllowed === true && typeof checkedAt === "number" && Number.isFinite(checkedAt) && checkedAt <= now && now - checkedAt <= 60_000;
+}
 /** Scheduling hint only; percentages are not comparable dollar/token balances. */
 export function subscriptionQuotaPreference(entry, now) {
     const planType = entry?.planType?.trim().toLowerCase();
-    const plan = planType === "free" ? "free" : ["plus", "pro", "team", "business", "enterprise", "edu"].includes(planType ?? "") ? "subscription" : "unknown";
-    const result = { plan, remainingPercent: null, resetAtMs: null, urgency: null, exhausted: isQuotaCacheEntryExhausted(entry, now), observedAt: entry?.updatedAt ?? null };
+    const plan = planType === "free" ? "free" : ["plus", "pro", "promax", "prolite", "team", "business", "self_serve_business_prolite", "enterprise", "edu", "edu_plus", "edu_pro"].includes(planType ?? "") ? "subscription" : "unknown";
+    const result = { plan, remainingPercent: null, resetAtMs: null, urgency: null, exhausted: !hasFreshOrdinaryUsagePermission(entry, now) && isQuotaCacheEntryExhausted(entry, now), observedAt: entry?.updatedAt ?? null };
     if (!entry || !Number.isFinite(entry.updatedAt) || entry.updatedAt > now || now - entry.updatedAt > SUBSCRIPTION_QUOTA_MAX_AGE_MS || entry.status !== 200)
         return result;
     const windows = [entry.primary, entry.secondary].filter(w => typeof w.usedPercent === "number" && Number.isFinite(w.usedPercent) && w.usedPercent >= 0 && w.usedPercent <= 100 && !(typeof w.resetAtMs === "number" && w.resetAtMs <= now) && !(w.resetAtMs === undefined && typeof w.windowMinutes === "number" && w.windowMinutes > 0 && now >= entry.updatedAt + w.windowMinutes * 60_000));
@@ -15,7 +19,7 @@ export function subscriptionQuotaPreference(entry, now) {
     if (!window)
         return result;
     result.remainingPercent = 100 - (window.usedPercent ?? 0);
-    result.exhausted = result.remainingPercent === 0;
+    result.exhausted = result.remainingPercent === 0 && !hasFreshOrdinaryUsagePermission(entry, now);
     if (typeof window.resetAtMs === "number" && Number.isFinite(window.resetAtMs) && window.resetAtMs > now) {
         result.resetAtMs = window.resetAtMs;
         result.urgency = result.remainingPercent / (Math.max(60_000, window.resetAtMs - now) / 3_600_000);

package/dist/lib/runtime/workspace-model-scopes.d.ts

@@ -1,10 +1,12 @@
 import { type ManagedAccount } from "../accounts.js";
+export { nativeWorkspaceIdentity } from "../auth/token-utils.js";
 export declare function modelScopeId(...parts: string[]): string;
 /** Request scopes are immutable views. Discovery must never switch a saved account. */
 export declare function workspaceModelScopes(account: ManagedAccount): {
     accountId: string;
     workspaceIndex: number;
     enabled: boolean;
+    storedWorkspaceId: string | undefined;
     id: string;
     accountIndex: number;
     routable: boolean;

package/dist/lib/runtime/workspace-model-scopes.js

@@ -1,32 +1,42 @@
 import { createHash } from "node:crypto";
 import { resolveAccountRecordId } from "../accounts.js";
-import { extractAccountId } from "../auth/token-utils.js";
+import { extractAccountId, nativeWorkspaceIdentity } from "../auth/token-utils.js";
+export { nativeWorkspaceIdentity } from "../auth/token-utils.js";
 export function modelScopeId(...parts) {
     return createHash("sha256").update(JSON.stringify(parts)).digest("hex");
 }
 /** Request scopes are immutable views. Discovery must never switch a saved account. */
 export function workspaceModelScopes(account) {
-    const boundId = account.accountId?.trim() || extractAccountId(account.access);
+    const boundId = nativeWorkspaceIdentity(account, account.accountId?.trim() || extractAccountId(account.access));
+    const selectedIndex = account.currentWorkspaceIndex ?? 0;
     const candidates = (account.workspaces ?? []).map((workspace, index) => ({
-        accountId: workspace.id.trim(), workspaceIndex: index,
+        accountId: index === selectedIndex ? nativeWorkspaceIdentity(account, workspace.id) ?? "" : workspace.id.trim(), workspaceIndex: index,
         enabled: account.enabled !== false && workspace.enabled !== false,
     }));
     if (boundId && !candidates.some(scope => scope.accountId === boundId))
         candidates.unshift({ accountId: boundId, workspaceIndex: -1, enabled: account.enabled !== false });
     if (!candidates.length)
         candidates.push({ accountId: "", workspaceIndex: -1, enabled: account.enabled !== false });
+    // A selected alias may resolve to the same identity as an earlier token entry.
+    // Keep the selected entry so its enablement and index remain authoritative.
     const seen = new Set();
     return candidates.filter(scope => {
+        if (scope.workspaceIndex !== selectedIndex && candidates.some(other => other.workspaceIndex === selectedIndex && other.accountId === scope.accountId))
+            return false;
         if (seen.has(scope.accountId))
             return false;
         seen.add(scope.accountId);
         return true;
     }).map(scope => ({
         ...scope,
+        // Keep the stored identity across async inventory syncs, including Personal aliases.
+        storedWorkspaceId: account.workspaces?.[scope.workspaceIndex]?.id,
         // Same record identity as reset-credit targets (resolveAccountRecordId), or their keys diverge.
         id: modelScopeId("oauth", resolveAccountRecordId(account), scope.accountId),
         accountIndex: account.index,
-        routable: scope.enabled && Boolean(scope.accountId),
+        routable: scope.enabled && Boolean(scope.accountId) && ((account.workspaces?.length ?? 0) > 0
+            ? scope.workspaceIndex === (account.currentWorkspaceIndex ?? 0)
+            : scope.accountId === boundId),
         bound: scope.accountId === boundId,
         selected: scope.workspaceIndex >= 0 && scope.workspaceIndex === (account.currentWorkspaceIndex ?? 0),
         label: `Account ${account.index + 1}${scope.workspaceIndex >= 0 ? ` / Workspace ${scope.workspaceIndex + 1}` : candidates.length > 1 ? " / Stored binding" : ""}`,