codex-multi-auth 2.15.0 → 2.17.0

package/dist/lib/ui/ui-copy.js

@@ -144,8 +144,8 @@ export const UI_COPY = {
     fallback: {
         addAnotherTip: "Tip: Use private mode or sign out before adding another account.",
         addAnotherQuestion: (count) => `Add another account? (${count} added) (y/n): `,
-        selectModePrompt: "(a) add, (c) check, (b) best, fi(x), (s) settings, (d) deep, (g) problem, (f) fresh, (q) back [a/c/b/x/s/d/g/f/q]: ",
-        invalidModePrompt: "Use one of: a, c, b, x, s, d, g, f, q.",
+        selectModePrompt: "(api) API models, (a) add, (c) check, (b) best, fi(x), (s) settings, (d) deep, (g) problem, (f) fresh, (q) back [api/a/c/b/x/s/d/g/f/q]: ",
+        invalidModePrompt: "Use one of: api, a, c, b, x, s, d, g, f, q.",
     },
 };
 /**

package/dist/lib/usage/pricing.d.ts

@@ -12,14 +12,31 @@ export interface UsageModelPricing {
      * row under-counts it by half and lets a `maxCostUsd` cap overrun.
      *
      * A tier absent from this map is deliberately NOT approximated from the
-     * standard rate. Only Astra's Fast multiplier is published; inventing one for
+     * standard rate. Only the GPT-6 Fast rates are published; inventing one for
      * the rest would move a budget's trip point on a guess, which is the failure
      * this file exists to avoid. `estimateUsageCostUsd` reports an unlisted tier
      * as unknown cost instead, so a budget fails closed the same way it does for
      * an unpriced model.
      */
     serviceTiers?: Partial<Record<UsageServiceTier, UsageModelPricing>>;
+    /**
+     * Rates once a response's input exceeds `SHORT_CONTEXT_MAX_INPUT_TOKENS`.
+     *
+     * OpenAI bills a GPT-6 request whose context crosses 272K at a separate,
+     * higher rate. A row that declares this block (every tier inside it too) is
+     * priced from it past the threshold. A row that declares it but whose
+     * resolved service tier does not reports unknown cost there instead of the
+     * cheaper short-context figure, for the same fail-closed reason as an
+     * unlisted tier. Rows with no long-context data at all are unchanged.
+     */
+    longContext?: UsageModelPricing;
 }
+/**
+ * Largest input still billed at the short-context rate. OpenAI's GPT-6 model
+ * pages say "Prompts with more than 272K input tokens are priced at 2x input
+ * and cache rates", so exactly 272,000 is short and 272,001 is long.
+ */
+export declare const SHORT_CONTEXT_MAX_INPUT_TOKENS = 272000;
 /**
  * Models the router can normalize to that have no published rate here yet.
  *
@@ -34,7 +51,7 @@ export interface UsageModelPricing {
  * `test/usage-pricing-coverage.test.ts` fails if a NEW routable model appears
  * in neither list.
  */
-export declare const UNPRICED_ROUTABLE_MODELS: readonly ["gpt-6-astra-aeon", "gpt-daybreak-blue-latest", "gpt-daybreak-red-latest", "gpt-5.1", "gpt-5.2-pro", "gpt-5.4-mini", "gpt-5.4-nano", "gpt-5.4-pro", "gpt-5.5-pro", "gpt-5-mini", "gpt-5-nano"];
+export declare const UNPRICED_ROUTABLE_MODELS: readonly ["gpt-6-astra-aeon", "gpt-daybreak-blue-latest", "gpt-daybreak-red-latest", "gpt-5.5-pro"];
 export declare function getUsageModelPricing(model: string | null | undefined): UsageModelPricing | null;
 export declare function estimateUsageCostUsd(model: string | null | undefined, tokens: UsageTokenCounts): number | null;
 export declare function listUsageModelPricing(): Record<string, UsageModelPricing>;

package/dist/lib/usage/pricing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pricing.d.ts","sourceRoot":"","sources":["../../../lib/usage/pricing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAErE,MAAM,WAAW,iBAAiB;IACjC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;;;;;;;;;;;OAaG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC,CAAC;CACpE;AAyFD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,0MAkB3B,CAAC;AAOX,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC9B,iBAAiB,GAAG,IAAI,CAiB1B;AAmBD,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,MAAM,EAAE,gBAAgB,GACtB,MAAM,GAAG,IAAI,CA8Bf;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAEzE"}
+{"version":3,"file":"pricing.d.ts","sourceRoot":"","sources":["../../../lib/usage/pricing.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAErE,MAAM,WAAW,iBAAiB;IACjC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;;;;;;;;;;;OAaG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC,CAAC;IACpE;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAC;CAChC;AAED;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,SAAU,CAAC;AA8HtD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,qGAW3B,CAAC;AAOX,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC9B,iBAAiB,GAAG,IAAI,CA0B1B;AAmCD,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,MAAM,EAAE,gBAAgB,GACtB,MAAM,GAAG,IAAI,CAsCf;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAEzE"}

package/dist/lib/usage/pricing.js

@@ -1,3 +1,10 @@
+import { RETIRED_MODEL_REPLACEMENTS } from "../request/helpers/model-map.js";
+/**
+ * Largest input still billed at the short-context rate. OpenAI's GPT-6 model
+ * pages say "Prompts with more than 272K input tokens are priced at 2x input
+ * and cache rates", so exactly 272,000 is short and 272,001 is long.
+ */
+export const SHORT_CONTEXT_MAX_INPUT_TOKENS = 272_000;
 const MODEL_PRICING = {
     // GPT-6 Astra, published at the 2026-09-03 launch: $10 / 1M input,
     // $50 / 1M output on the standard service tier, and $20 / $100 on Fast,
@@ -16,48 +23,85 @@ const MODEL_PRICING = {
         outputUsdPerMillion: 50,
         cachedInputUsdPerMillion: 1,
         reasoningUsdPerMillion: 50,
+        // Long-context rows from the same page (read 2026-09-23).
+        longContext: {
+            inputUsdPerMillion: 20,
+            outputUsdPerMillion: 75,
+            cachedInputUsdPerMillion: 2,
+            reasoningUsdPerMillion: 75,
+        },
         serviceTiers: {
             // Published at launch alongside the standard rate: Fast mode is up to
-            // 2.5x the speed at 2x the price, $20 / $100 per 1M. This is the only
-            // tier multiplier OpenAI has published for any model in this table,
-            // which is why it is the only one listed anywhere in this file.
+            // 2.5x the speed at 2x the price, $20 / $100 per 1M. Only the GPT-6
+            // rows list a Fast tier, because only GPT-6 has a published Fast rate.
             priority: {
                 inputUsdPerMillion: 20,
                 outputUsdPerMillion: 100,
                 cachedInputUsdPerMillion: 2,
                 reasoningUsdPerMillion: 100,
+                longContext: {
+                    inputUsdPerMillion: 40,
+                    outputUsdPerMillion: 150,
+                    cachedInputUsdPerMillion: 4,
+                    reasoningUsdPerMillion: 150,
+                },
             },
         },
     },
-    "gpt-5-codex": {
-        inputUsdPerMillion: 1.25,
-        outputUsdPerMillion: 10,
-        cachedInputUsdPerMillion: 0.125,
-        reasoningUsdPerMillion: 10,
-    },
-    "gpt-5.1-codex": {
-        inputUsdPerMillion: 1.25,
-        outputUsdPerMillion: 10,
-        cachedInputUsdPerMillion: 0.125,
-        reasoningUsdPerMillion: 10,
-    },
-    "gpt-5.2": {
-        inputUsdPerMillion: 1.25,
-        outputUsdPerMillion: 10,
-        cachedInputUsdPerMillion: 0.125,
-        reasoningUsdPerMillion: 10,
-    },
-    "gpt-5.3-codex": {
-        inputUsdPerMillion: 1.25,
+    // GPT-6 Sol and Luna, from the OpenAI API pricing page (read 2026-09-23;
+    // short- and long-context rows). Both publish a Fast tier at exactly 2x,
+    // like Astra.
+    "gpt-6-sol": {
+        inputUsdPerMillion: 2,
         outputUsdPerMillion: 10,
-        cachedInputUsdPerMillion: 0.125,
+        cachedInputUsdPerMillion: 0.2,
         reasoningUsdPerMillion: 10,
+        longContext: {
+            inputUsdPerMillion: 4,
+            outputUsdPerMillion: 15,
+            cachedInputUsdPerMillion: 0.4,
+            reasoningUsdPerMillion: 15,
+        },
+        serviceTiers: {
+            priority: {
+                inputUsdPerMillion: 4,
+                outputUsdPerMillion: 20,
+                cachedInputUsdPerMillion: 0.4,
+                reasoningUsdPerMillion: 20,
+                longContext: {
+                    inputUsdPerMillion: 8,
+                    outputUsdPerMillion: 30,
+                    cachedInputUsdPerMillion: 0.8,
+                    reasoningUsdPerMillion: 30,
+                },
+            },
+        },
     },
-    "gpt-5.4": {
-        inputUsdPerMillion: 2,
-        outputUsdPerMillion: 12,
-        cachedInputUsdPerMillion: 0.2,
-        reasoningUsdPerMillion: 12,
+    "gpt-6-luna": {
+        inputUsdPerMillion: 0.1,
+        outputUsdPerMillion: 0.5,
+        cachedInputUsdPerMillion: 0.01,
+        reasoningUsdPerMillion: 0.5,
+        longContext: {
+            inputUsdPerMillion: 0.2,
+            outputUsdPerMillion: 0.75,
+            cachedInputUsdPerMillion: 0.02,
+            reasoningUsdPerMillion: 0.75,
+        },
+        serviceTiers: {
+            priority: {
+                inputUsdPerMillion: 0.2,
+                outputUsdPerMillion: 1,
+                cachedInputUsdPerMillion: 0.02,
+                reasoningUsdPerMillion: 1,
+                longContext: {
+                    inputUsdPerMillion: 0.4,
+                    outputUsdPerMillion: 1.5,
+                    cachedInputUsdPerMillion: 0.04,
+                    reasoningUsdPerMillion: 1.5,
+                },
+            },
+        },
     },
     "gpt-5.5": {
         inputUsdPerMillion: 2,
@@ -108,21 +152,14 @@ export const UNPRICED_ROUTABLE_MODELS = [
     "gpt-6-astra-aeon",
     "gpt-daybreak-blue-latest",
     "gpt-daybreak-red-latest",
-    "gpt-5.1",
-    "gpt-5.2-pro",
-    "gpt-5.4-mini",
-    "gpt-5.4-nano",
-    "gpt-5.4-pro",
     "gpt-5.5-pro",
-    "gpt-5-mini",
-    "gpt-5-nano",
 ];
 function normalizeModelName(model) {
     const trimmed = model?.trim().toLowerCase();
     return trimmed && trimmed.length > 0 ? trimmed : null;
 }
 export function getUsageModelPricing(model) {
-    const normalized = normalizeModelName(model);
+    const normalized = normalizeModelName(model?.replace(/^(api|zdr)\//, ""));
     if (!normalized) {
         return null;
     }
@@ -134,10 +171,19 @@ export function getUsageModelPricing(model) {
     // `NaN` instead of `null`. A NaN cost is worse than an unknown one, because
     // `NaN >= limit` is false, so it silently makes a `maxCostUsd` budget
     // unenforceable rather than failing closed the way an unpriced model does.
-    if (!Object.hasOwn(MODEL_PRICING, normalized)) {
+    //
+    // A retired id is priced as the model it now runs on. The proxy records the
+    // raw client model string, so a new `gpt-5-codex` row is really a
+    // `gpt-5.6-sol` request; pricing it at the retired model's old rate would
+    // under-count a `maxCostUsd` budget. Rows already on disk are unaffected:
+    // the ledger stores `costUsd` when a row is written and never re-prices it.
+    const effective = !/^(api|zdr)\//.test(model ?? "") && Object.hasOwn(RETIRED_MODEL_REPLACEMENTS, normalized)
+        ? RETIRED_MODEL_REPLACEMENTS[normalized]
+        : normalized;
+    if (!effective || !Object.hasOwn(MODEL_PRICING, effective)) {
         return null;
     }
-    return MODEL_PRICING[normalized] ?? null;
+    return MODEL_PRICING[effective] ?? null;
 }
 /**
  * Pick the rate that applies to a response's service tier.
@@ -152,6 +198,17 @@ function resolveServiceTierPricing(pricing, serviceTier) {
     }
     return pricing.serviceTiers?.[serviceTier] ?? null;
 }
+function resolveContextLengthPricing(basePricing, tierPricing, inputTokens) {
+    if (inputTokens <= SHORT_CONTEXT_MAX_INPUT_TOKENS) {
+        return tierPricing;
+    }
+    if (tierPricing.longContext) {
+        return tierPricing.longContext;
+    }
+    // The model has long-context rates but not for this tier: unknown, never
+    // the cheaper short-context rate.
+    return basePricing.longContext ? null : tierPricing;
+}
 export function estimateUsageCostUsd(model, tokens) {
     const basePricing = getUsageModelPricing(model);
     if (!basePricing) {
@@ -161,7 +218,11 @@ export function estimateUsageCostUsd(model, tokens) {
     // table has no rate for must report unknown cost, not a standard-tier
     // figure: under-counting is what lets a `maxCostUsd` cap overrun, and
     // `evaluateBudgetGuard` already knows how to fail closed on `null`.
-    const pricing = resolveServiceTierPricing(basePricing, tokens.serviceTier);
+    const tierPricing = resolveServiceTierPricing(basePricing, tokens.serviceTier);
+    if (!tierPricing) {
+        return null;
+    }
+    const pricing = resolveContextLengthPricing(basePricing, tierPricing, tokens.inputTokens);
     if (!pricing) {
         return null;
     }

package/dist/lib/usage/usage-extraction.d.ts

@@ -30,7 +30,7 @@ export interface UsageStreamScanner {
 /**
  * Observe a forwarded response body and recover its token counts.
  *
- * SSE bodies are scanned line by line so only the current partial line is
+ * SSE bodies are scanned frame by frame so only the current bounded event is
  * retained; a full response can be gigabytes of deltas and must never be
  * buffered. Non-SSE JSON bodies have no incremental structure to exploit, so
  * they are accumulated up to `MAX_BUFFERED_BYTES` and parsed at the end —
@@ -39,5 +39,7 @@ export interface UsageStreamScanner {
  */
 export declare function createUsageStreamScanner(options: {
     contentType?: string | null;
+    /** Observe parsed upstream events without reparsing the stream. */
+    onEvent?: (event: unknown) => void;
 }): UsageStreamScanner;
 //# sourceMappingURL=usage-extraction.d.ts.map

package/dist/lib/usage/usage-extraction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usage-extraction.d.ts","sourceRoot":"","sources":["../../../lib/usage/usage-extraction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AA+BrE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CACtC,KAAK,EAAE,OAAO,GACZ,gBAAgB,GAAG,IAAI,CA+BzB;AAoCD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,gBAAgB,GAAG,IAAI,CAa/E;AAED,MAAM,WAAW,kBAAkB;IAClC,8CAA8C;IAC9C,IAAI,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAClC,2EAA2E;IAC3E,MAAM,EAAE,MAAM,gBAAgB,GAAG,IAAI,CAAC;CACtC;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IACjD,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,GAAG,kBAAkB,CA6ErB"}
+{"version":3,"file":"usage-extraction.d.ts","sourceRoot":"","sources":["../../../lib/usage/usage-extraction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AA+BrE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CACtC,KAAK,EAAE,OAAO,GACZ,gBAAgB,GAAG,IAAI,CA+BzB;AAoCD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,gBAAgB,GAAG,IAAI,CAa/E;AAED,MAAM,WAAW,kBAAkB;IAClC,8CAA8C;IAC9C,IAAI,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAClC,2EAA2E;IAC3E,MAAM,EAAE,MAAM,gBAAgB,GAAG,IAAI,CAAC;CACtC;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IACjD,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,mEAAmE;IACnE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACnC,GAAG,kBAAkB,CAmGrB"}

package/dist/lib/usage/usage-extraction.js

@@ -124,7 +124,7 @@ export function extractResponsesUsage(payload) {
 /**
  * Observe a forwarded response body and recover its token counts.
  *
- * SSE bodies are scanned line by line so only the current partial line is
+ * SSE bodies are scanned frame by frame so only the current bounded event is
  * retained; a full response can be gigabytes of deltas and must never be
  * buffered. Non-SSE JSON bodies have no incremental structure to exploit, so
  * they are accumulated up to `MAX_BUFFERED_BYTES` and parsed at the end —
@@ -138,11 +138,20 @@ export function createUsageStreamScanner(options) {
     let bufferedBytes = 0;
     let overflowed = false;
     let latest = null;
-    const consumeLine = (line) => {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("data:"))
+    let eventData = [];
+    let eventSize = 0;
+    let droppingEvent = false;
+    let droppingLine = false;
+    const consumeEvent = () => {
+        if (droppingEvent) {
+            droppingEvent = false;
+            eventData = [];
+            eventSize = 0;
             return;
-        const payload = trimmed.slice("data:".length).trim();
+        }
+        const payload = eventData.join("\n");
+        eventData = [];
+        eventSize = 0;
         if (payload.length === 0 || payload === "[DONE]")
             return;
         let parsed;
@@ -152,6 +161,7 @@ export function createUsageStreamScanner(options) {
         catch {
             return;
         }
+        options.onEvent?.(parsed);
         // Prefer terminal events, which carry the authoritative totals, but fall
         // back to any event that reports usage so a stream that ends on a
         // non-standard terminal type still records something.
@@ -162,6 +172,24 @@ export function createUsageStreamScanner(options) {
             latest = counts;
         }
     };
+    const consumeLine = (raw) => {
+        const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+        if (line.length === 0) {
+            consumeEvent();
+            return;
+        }
+        if (droppingEvent || !line.startsWith("data:"))
+            return;
+        const value = line.slice(5).replace(/^ /, "");
+        eventSize += value.length + 1;
+        if (eventSize > MAX_BUFFERED_BYTES) {
+            droppingEvent = true;
+            eventData = [];
+            eventSize = 0;
+            return;
+        }
+        eventData.push(value);
+    };
     return {
         push: (chunk) => {
             try {
@@ -178,14 +206,20 @@ export function createUsageStreamScanner(options) {
                 }
                 let newlineAt = pending.indexOf("\n");
                 while (newlineAt !== -1) {
-                    consumeLine(pending.slice(0, newlineAt));
+                    if (droppingLine)
+                        droppingLine = false;
+                    else
+                        consumeLine(pending.slice(0, newlineAt));
                     pending = pending.slice(newlineAt + 1);
                     newlineAt = pending.indexOf("\n");
                 }
                 // A single unterminated line this long is not SSE any more; stop
                 // retaining it rather than growing the buffer for the whole body.
-                if (pending.length > MAX_BUFFERED_BYTES) {
-                    overflowed = true;
+                if (pending.length > MAX_BUFFERED_BYTES || droppingLine) {
+                    droppingEvent = true;
+                    droppingLine = true;
+                    eventData = [];
+                    eventSize = 0;
                     pending = "";
                 }
             }
@@ -202,13 +236,16 @@ export function createUsageStreamScanner(options) {
                     if (pending.length > 0)
                         consumeLine(pending);
                     pending = "";
+                    consumeEvent();
                     return latest;
                 }
                 if (pending.trim().length === 0)
                     return latest;
                 const parsed = JSON.parse(pending);
                 pending = "";
-                return extractResponsesUsage(parsed) ?? latest;
+                options.onEvent?.(parsed);
+                latest = extractResponsesUsage(parsed) ?? latest;
+                return latest;
             }
             catch {
                 return latest;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "codex-multi-auth",
-	"version": "2.15.0",
+	"version": "2.17.0",
 	"description": "Codex CLI multi-account OAuth manager with account switching, health checks, runtime rotation, diagnostics, and recovery tools for @openai/codex",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -157,6 +157,7 @@
 	},
 	"devDependencies": {
 		"@types/node": "^20.19.42",
+		"@types/ws": "8.18.1",
 		"@typescript-eslint/eslint-plugin": "^8.56.0",
 		"@typescript-eslint/parser": "^8.56.0",
 		"@vitest/coverage-v8": "^4.1.8",
@@ -174,12 +175,13 @@
 	"dependencies": {
 		"@codex-ai/plugin": "file:vendor/codex-ai-plugin",
 		"@codex-ai/sdk": "file:vendor/codex-ai-sdk",
-		"hono": "4.12.33",
+		"hono": "4.13.9",
 		"undici": "6.28.0",
+		"ws": "8.21.3",
 		"zod": "4.4.3"
 	},
 	"overrides": {
-		"hono": "4.12.33",
+		"hono": "4.13.9",
 		"flatted": "3.4.2",
 		"minimatch": "10.2.4",
 		"picomatch": "4.0.4",
@@ -192,6 +194,7 @@
 			"minimatch": "9.0.9"
 		},
 		"brace-expansion": "5.0.9",
-		"postcss": "8.5.25"
+		"postcss": "8.5.25",
+		"nanoid": "3.3.18"
 	}
 }

package/scripts/codex-app-router.js

@@ -177,11 +177,16 @@ function createStatusPayload({
 		baseUrl: proxyServer?.baseUrl ?? stateRecord?.baseUrl ?? null,
 		totalRequests: proxyStatus.totalRequests ?? 0,
 		upstreamRequests: proxyStatus.upstreamRequests ?? 0,
+		websocketConnections: proxyStatus.websocketConnections ?? 0,
+		websocketUpstreamRequests: proxyStatus.websocketUpstreamRequests ?? 0,
+		streamQuotaUpdates: proxyStatus.streamQuotaUpdates ?? 0,
+		lastStreamQuotaUpdateAt: proxyStatus.lastStreamQuotaUpdateAt ?? null,
 		retries: proxyStatus.retries ?? 0,
 		rotations: proxyStatus.rotations ?? 0,
 		lastAccountIndex,
 		lastAccountLabel,
 		lastAccountId: proxyStatus.lastAccountId ?? null,
+		lastRequestedWorkspaceId: proxyStatus.lastRequestedWorkspaceId ?? null,
 		lastAccountUpdatedAt: proxyStatus.lastAccountUpdatedAt ?? null,
 		lastError: error ? (error instanceof Error ? error.message : String(error)) : proxyStatus.lastError ?? null,
 	};
@@ -323,6 +328,8 @@ async function main() {
 	try {
 		const proxyModule = await import("../dist/lib/runtime-rotation-proxy.js");
 		proxyServer = await proxyModule.startRuntimeRotationProxy({
+			nativeOpenai: stateRecord?.nativeOpenai === true,
+			catalogAccount: stateRecord?.catalogAccount,
 			host,
 			port,
 			clientApiKey,

package/scripts/codex-bin-resolver.js

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
-import { basename, delimiter, dirname, extname, isAbsolute, join, relative } from "node:path";
+import { basename, dirname, extname, isAbsolute, join, posix, relative, win32 } from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
 
@@ -55,6 +55,29 @@ function defaultResolvePackageBin(moduleUrl) {
 	}
 }
 
+// spawn() without a shell cannot run these on Windows: `.cmd`/`.bat` are
+// EINVAL, `.ps1` is not an executable image, and an extensionless file
+// (npm's `#!/bin/sh` shim) is ENOENT even when it is a real PE image. Going through cmd.exe instead would put every
+// forwarded argument through cmd's quoting rules.
+export function isWindowsShimPath(candidatePath) {
+	const extension = win32.extname(candidatePath).toLowerCase();
+	return extension === "" || extension === ".cmd" || extension === ".bat" || extension === ".ps1";
+}
+
+// npm's Windows shims sit in the prefix dir and run
+// `<prefix>\node_modules\@openai\codex\bin\codex.js`.
+export function resolveWindowsShimPackageEntry(shimPath, existsSyncImpl = existsSync) {
+	const entry = win32.join(
+		win32.dirname(shimPath),
+		"node_modules",
+		"@openai",
+		"codex",
+		"bin",
+		"codex.js",
+	);
+	return existsSyncImpl(entry) ? entry : null;
+}
+
 function resolveWindowsCmdPath(env) {
 	const comSpec = (env.ComSpec ?? env.COMSPEC ?? "").trim();
 	if (comSpec.length > 0) return comSpec;
@@ -67,12 +90,12 @@ function resolveWindowsCmdPath(env) {
 	return "cmd.exe";
 }
 
-export function splitPathEntries(pathValue) {
+export function splitPathEntries(pathValue, platform = process.platform) {
 	if (typeof pathValue !== "string" || pathValue.trim().length === 0) {
 		return [];
 	}
 	return pathValue
-		.split(delimiter)
+		.split(platform === "win32" ? ";" : ":")
 		.map((entry) => entry.trim())
 		.filter((entry) => entry.length > 0);
 }
@@ -85,7 +108,12 @@ function resolveCandidateExecutableNames(platform) {
 	if (platform !== "win32") {
 		return [resolvePathExecutableName(platform)];
 	}
-	return ["codex.exe", "codex"];
+	// npm on Windows puts `codex.cmd` plus an extensionless `#!/bin/sh` shim in
+	// the prefix dir and the package under `<prefix>\node_modules`. Neither shim
+	// can be spawned without a shell (`.cmd` is EINVAL, the sh script ENOENT),
+	// so launch the package entry the shims point at before falling back to an
+	// extensionless `codex`.
+	return ["codex.exe", win32.join("node_modules", "@openai", "codex", "bin", "codex.js"), "codex"];
 }
 
 function resolveCodexExecutableFromPath(
@@ -97,7 +125,7 @@ function resolveCodexExecutableFromPath(
 ) {
 	for (const entry of pathEntries) {
 		for (const executableName of resolveCandidateExecutableNames(platform)) {
-			const candidate = join(entry, executableName);
+			const candidate = (platform === "win32" ? win32 : posix).join(entry, executableName);
 			if (!existsSyncImpl(candidate)) {
 				continue;
 			}
@@ -134,7 +162,7 @@ function resolveCodexExecutableFromSystemPath(
 	selfScriptPath,
 	realpathSyncImpl,
 ) {
-	const pathEntries = splitPathEntries(env.PATH ?? env.Path ?? "");
+	const pathEntries = splitPathEntries(env.PATH ?? env.Path ?? "", platform);
 	const fromEnvPath = resolveCodexExecutableFromPath(
 		pathEntries,
 		platform,
@@ -207,8 +235,12 @@ export function resolveRealCodexBin(options = {}) {
 
 	const override = (env.CODEX_MULTI_AUTH_REAL_CODEX_BIN ?? "").trim();
 	if (override.length > 0) {
-		if (existsSyncImpl(override)) return createResolvedCodexBin(override);
-		return null;
+		if (!existsSyncImpl(override)) return null;
+		if (platform === "win32" && isWindowsShimPath(override)) {
+			const entry = resolveWindowsShimPackageEntry(override, existsSyncImpl);
+			return entry ? createResolvedCodexBin(entry) : null;
+		}
+		return createResolvedCodexBin(override);
 	}
 
 	const resolved = resolvePackageBin(moduleUrl);

package/scripts/codex-routing.js

@@ -10,6 +10,7 @@ const AUTH_SUBCOMMANDS = new Set([
 	"check",
 	"features",
 	"usage",
+	"resets",
 	"verify-flagged",
 	"verify",
 	"forecast",