codex-multi-auth 2.18.0 → 2.19.1

package/dist/lib/quota-cache.d.ts

@@ -4,6 +4,10 @@ export interface QuotaCacheWindow {
     resetAtMs?: number;
 }
 export interface QuotaCacheEntry {
+    primingCompleted?: boolean;
+    /** Completion/failure time, independent of the quota header observation. */
+    primingObservedAt?: number;
+    primingFailure?: "timed out" | "stream ended early" | "upstream failed" | "response too large" | "network error";
     updatedAt: number;
     status: number;
     model: string;
@@ -47,6 +51,8 @@ export declare function getQuotaCachePath(): string;
  *          will be empty if the on-disk file is absent, malformed, or could not be read.
  */
 export declare function loadQuotaCache(): Promise<QuotaCacheData>;
+/** Merge quota and priming evidence independently; subsequent quota retires old outcomes. */
+export declare function mergeQuotaCacheEntry(latest: QuotaCacheEntry | undefined, update: QuotaCacheEntry): QuotaCacheEntry;
 /**
  * Persist the quota cache to the on-disk JSON file used by the multi-auth runtime.
  *

package/dist/lib/quota-cache.js

@@ -58,6 +58,9 @@ function normalizeEntry(value) {
         return null;
     }
     return {
+        ...(value.primingCompleted === true ? { primingCompleted: true } : {}),
+        ...(typeof value.primingFailure === "string" && ["timed out", "stream ended early", "upstream failed", "response too large", "network error"].includes(value.primingFailure) ? { primingFailure: value.primingFailure } : {}),
+        ...(normalizeNumber(value.primingObservedAt) !== undefined ? { primingObservedAt: normalizeNumber(value.primingObservedAt) } : {}),
         updatedAt,
         status,
         model: model.trim(),
@@ -158,6 +161,32 @@ async function readQuotaCache() {
         ...(parsed.byWorkspace ? { byWorkspace: normalizeEntryMap(parsed.byWorkspace) } : {}),
     };
 }
+/** Merge quota and priming evidence independently; subsequent quota retires old outcomes. */
+export function mergeQuotaCacheEntry(latest, update) {
+    if (!latest)
+        return update;
+    const quota = update.updatedAt >= latest.updatedAt ? update : latest;
+    const outcomeTime = (entry) => entry.primingCompleted || entry.primingFailure
+        ? entry.primingObservedAt ?? entry.updatedAt : -Infinity;
+    // A timeout does not undo a completion from an overlapping attempt.
+    // Only completions at/after the newest quota observation remain relevant.
+    const completion = [update, latest].filter(entry => entry.primingCompleted && outcomeTime(entry) >= quota.updatedAt)
+        .sort((a, b) => outcomeTime(b) - outcomeTime(a))[0];
+    const evidence = completion ?? (outcomeTime(update) >= outcomeTime(latest) ? update : latest);
+    const result = { ...quota };
+    delete result.primingCompleted;
+    delete result.primingFailure;
+    delete result.primingObservedAt;
+    if (outcomeTime(evidence) >= quota.updatedAt) {
+        if (evidence.primingCompleted)
+            result.primingCompleted = true;
+        else if (evidence.primingFailure)
+            result.primingFailure = evidence.primingFailure;
+        if (evidence.primingObservedAt !== undefined)
+            result.primingObservedAt = evidence.primingObservedAt;
+    }
+    return result;
+}
 /** Reapply this run's changed entries, preserving unrelated or newer concurrent observations. */
 function mergeQuotaChanges(current, proposed, baseline) {
     const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
@@ -168,24 +197,12 @@ function mergeQuotaChanges(current, proposed, baseline) {
                 continue;
             const latest = current[namespace]?.[key], update = next[key];
             if (update) {
-                if (!latest || update.updatedAt >= latest.updatedAt) {
-                    current[namespace] ??= {};
-                    current[namespace][key] = update;
-                }
-                else if (same(latest, before[key])) {
-                    // The on-disk entry is still exactly the one this caller's
-                    // baseline saw, so nothing concurrent touched this key:
-                    // `update` is a deliberate write whose lower stamp can only
-                    // come from a backward clock jump on this writer. Re-stamp
-                    // it just ahead instead of silently losing it. A raced key
-                    // (`!same`) falls through and keeps the on-disk entry: its
-                    // higher stamp marks a newer observation, and bumping an
-                    // older one past it would let stale quota data overwrite
-                    // fresher data.
+                if (latest && update.updatedAt < latest.updatedAt && same(latest, before[key])) {
+                    // Preserve the existing backward-clock handling for an unraced write.
                     update.updatedAt = latest.updatedAt + 1;
-                    current[namespace] ??= {};
-                    current[namespace][key] = update;
                 }
+                current[namespace] ??= {};
+                current[namespace][key] = mergeQuotaCacheEntry(latest, update);
             }
             else if (same(latest, before[key])) {
                 delete current[namespace]?.[key];

package/dist/lib/quota-probe.d.ts

@@ -26,7 +26,10 @@ export interface CodexQuotaWindow {
     resetAtMs?: number;
 }
 export interface CodexQuotaSnapshot {
+    /** Time quota headers were observed, before consuming the response stream. */
+    observedAt?: number;
     primingCompleted?: boolean;
+    primingObservedAt?: number;
     primingFailure?: FirstUseProbeError["reason"];
     status: number;
     planType?: string;

package/dist/lib/quota-probe.js

@@ -382,15 +382,16 @@ export async function fetchCodexQuotaSnapshot(options) {
             }
             const snapshotBase = parseQuotaSnapshotBase(response.headers, response.status);
             if (snapshotBase) {
-                if (options.primeUnusedSubscription && needsSubscriptionFirstUse(snapshotBase, Date.now())) {
+                const observedAt = Date.now();
+                if (options.primeUnusedSubscription && needsSubscriptionFirstUse(snapshotBase, observedAt)) {
                     try {
                         await finishSubscriptionFirstUse(response, timeoutMs);
-                        return { ...snapshotBase, model, primingCompleted: true };
+                        return { ...snapshotBase, observedAt, model, primingObservedAt: Date.now(), primingCompleted: true };
                     }
                     catch (error) {
                         // Keep valid quota data without retrying an accepted inference.
                         if (error instanceof FirstUseProbeError)
-                            return { ...snapshotBase, model, primingFailure: error.reason };
+                            return { ...snapshotBase, observedAt, model, primingObservedAt: Date.now(), primingFailure: error.reason };
                         throw error;
                     }
                 }
@@ -400,7 +401,7 @@ export async function fetchCodexQuotaSnapshot(options) {
                 catch {
                     // Best effort cancellation.
                 }
-                return { ...snapshotBase, model };
+                return { ...snapshotBase, observedAt, model };
             }
             if (!response.ok) {
                 const bodyText = await response.text().catch(() => "");

package/dist/lib/quota-readiness.d.ts

@@ -1,6 +1,6 @@
 import type { QuotaCacheData, QuotaCacheEntry } from "./quota-cache.js";
 import type { AccountMetadataV3 } from "./storage.js";
-export type QuotaCacheAccountRef = Pick<AccountMetadataV3, "accountId" | "email" | "recordId" | "workspaces" | "currentWorkspaceIndex"> & Partial<Pick<AccountMetadataV3, "refreshToken" | "addedAt">>;
+export type QuotaCacheAccountRef = Pick<AccountMetadataV3, "accountId" | "email" | "recordId" | "workspaces" | "currentWorkspaceIndex"> & Partial<Pick<AccountMetadataV3, "refreshToken" | "addedAt" | "accessToken">>;
 export declare function normalizeQuotaAccountId(value: string | undefined): string | null;
 export declare function normalizeQuotaEmail(value: string | undefined): string | null;
 export declare function hasUniqueQuotaAccountId(accounts: readonly QuotaCacheAccountRef[], account: QuotaCacheAccountRef): boolean;
@@ -12,9 +12,9 @@ export declare function buildQuotaEmailFallbackState(accounts: readonly QuotaCac
 export declare function hasSafeQuotaEmailFallback(emailFallbackState: ReadonlyMap<string, QuotaEmailFallbackState>, account: QuotaCacheAccountRef): boolean;
 export declare function quotaLeftPercentFromUsed(usedPercent: number | undefined): number | undefined;
 export declare function quotaUsedPercentIsExhausted(usedPercent: number | undefined): boolean;
-export declare function isQuotaCacheEntryExhausted(entry: Pick<QuotaCacheEntry, "primary" | "secondary"> & {
+export declare function isQuotaCacheEntryExhausted(entry: (Pick<QuotaCacheEntry, "primary" | "secondary"> & {
     updatedAt?: number;
-} | null | undefined, now?: number): boolean;
+}) | null | undefined, now?: number): boolean;
 /** Cache identity includes the credential record, so shared organization IDs cannot collide. */
 export declare function quotaWorkspaceKey(account: QuotaCacheAccountRef, workspaceId: string): string | undefined;
 /** Display the selected workspace; callers routing another scope must pass that exact workspace. */

package/dist/lib/quota-readiness.js

@@ -1,3 +1,4 @@
+import { extractAccountId } from "./auth/token-utils.js";
 import { createHash } from "node:crypto";
 import { resolveAccountRecordId } from "./storage/record-identity.js";
 export function normalizeQuotaAccountId(value) {
@@ -101,7 +102,7 @@ export function quotaWorkspaceKey(account, workspaceId) {
 export function quotaWorkspaceId(account) {
     return account.workspaces?.length
         ? account.workspaces[account.currentWorkspaceIndex ?? 0]?.id.trim()
-        : account.accountId?.trim();
+        : account.accountId?.trim() || extractAccountId(account.accessToken);
 }
 /** Read exact-workspace quota, using legacy binding entries only for that binding. */
 export function findQuotaCacheEntryForAccount(cache, account, accounts, emailFallbackState = buildQuotaEmailFallbackState(accounts), workspaceId = quotaWorkspaceId(account)) {
@@ -110,7 +111,10 @@ export function findQuotaCacheEntryForAccount(cache, account, accounts, emailFal
     const key = workspaceId && quotaWorkspaceKey(account, workspaceId);
     const scoped = key ? cache.byWorkspace?.[key] : undefined;
     // Legacy entries describe only the stored binding, never a sibling workspace.
-    if (normalizeQuotaAccountId(workspaceId) !== normalizeQuotaAccountId(account.accountId))
+    // A workspaces-bearing account whose selection does not resolve (invalid index
+    // or blank id) has no valid binding at all — never fall back to legacy keys.
+    if (normalizeQuotaAccountId(workspaceId) !== normalizeQuotaAccountId(account.accountId) ||
+        (account.workspaces?.length && !normalizeQuotaAccountId(workspaceId)))
         return scoped ?? null;
     const accountId = normalizeQuotaAccountId(account.accountId);
     const newer = (legacy) => scoped && (!legacy || scoped.updatedAt >= legacy.updatedAt) ? scoped : legacy ?? null;

package/dist/lib/request/url-rewriting.js

@@ -121,7 +121,9 @@ function getSharedProxyDispatcher(proxyUrl) {
     if (existing) {
         return existing;
     }
-    const dispatcher = new ProxyAgent(proxyUrl);
+    // undici 8 enables H2 on TLS ALPN; keep HTTP/1.1 so upstream protocol
+    // behavior matches the 6.x line this pin replaces.
+    const dispatcher = new ProxyAgent({ uri: proxyUrl, allowH2: false });
     sharedProxyDispatchers.set(proxyUrl, dispatcher);
     return dispatcher;
 }

package/dist/lib/runtime/account-model-catalog.d.ts

@@ -46,17 +46,17 @@ export declare class AccountModelCatalog {
         checkedAt: number;
         models: string[];
         entitlements: {
+            model: string;
+            checkedAt?: number | undefined;
+            probes?: {
+                [k: string]: "downgraded" | "unsupported" | "unverified" | "verified";
+            } | undefined;
             serviceTiers: {
                 id: string;
                 name: string;
             }[];
             reasoningLevels: string[];
             accessPrograms: string[];
-            probes?: {
-                [k: string]: "verified" | "unsupported" | "unverified" | "downgraded";
-            } | undefined;
-            checkedAt?: number | undefined;
-            model: string;
         }[];
         error: boolean;
     };

package/dist/lib/runtime/account-reset-credits.d.ts

@@ -6,7 +6,7 @@ export declare function isResetTargetEnabled(account: AccountMetadataV3, target:
 export declare function createResetCreditService(manager?: AccountManager): ResetCreditService;
 export declare function loadResetCreditState(): Promise<{
     version: 1;
-    policy: "manual" | "last-resort";
+    policy: "last-resort" | "manual";
     snapshots: Record<string, {
         updatedAt: number;
         availableCount: number | null;
@@ -32,7 +32,7 @@ export declare function loadResetCreditState(): Promise<{
     lastRedemption?: {
         key: string;
         at: number;
-        outcome: "reset" | "nothingToReset" | "noCredit" | "alreadyRedeemed";
+        outcome: "alreadyRedeemed" | "noCredit" | "nothingToReset" | "reset";
         automatic: boolean;
     } | undefined;
 }>;

package/dist/lib/runtime/model-discovery-status.d.ts

@@ -23,10 +23,10 @@ declare const schema: z.ZodObject<{
                 model: z.ZodString;
                 checkedAt: z.ZodOptional<z.ZodNumber>;
                 probes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                    downgraded: "downgraded";
                     unsupported: "unsupported";
-                    verified: "verified";
                     unverified: "unverified";
-                    downgraded: "downgraded";
+                    verified: "verified";
                 }>>>;
                 serviceTiers: z.ZodArray<z.ZodObject<{
                     id: z.ZodString;
@@ -38,8 +38,8 @@ declare const schema: z.ZodObject<{
         }, z.core.$strip>>;
         label: z.ZodString;
         kind: z.ZodEnum<{
-            oauth: "oauth";
             api: "api";
+            oauth: "oauth";
             zdr: "zdr";
         }>;
         enabled: z.ZodBoolean;
@@ -51,10 +51,10 @@ declare const schema: z.ZodObject<{
             model: z.ZodString;
             checkedAt: z.ZodOptional<z.ZodNumber>;
             probes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                downgraded: "downgraded";
                 unsupported: "unsupported";
-                verified: "verified";
                 unverified: "unverified";
-                downgraded: "downgraded";
+                verified: "verified";
             }>>>;
             serviceTiers: z.ZodArray<z.ZodObject<{
                 id: z.ZodString;

package/dist/lib/runtime/reset-credits.d.ts

@@ -24,8 +24,8 @@ export type ResetSnapshot = z.infer<typeof snapshotSchema>;
 declare const stateSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     policy: z.ZodDefault<z.ZodEnum<{
-        manual: "manual";
         "last-resort": "last-resort";
+        manual: "manual";
     }>>;
     snapshots: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         updatedAt: z.ZodNumber;
@@ -53,10 +53,10 @@ declare const stateSchema: z.ZodObject<{
         key: z.ZodString;
         at: z.ZodNumber;
         outcome: z.ZodEnum<{
-            reset: "reset";
-            nothingToReset: "nothingToReset";
-            noCredit: "noCredit";
             alreadyRedeemed: "alreadyRedeemed";
+            noCredit: "noCredit";
+            nothingToReset: "nothingToReset";
+            reset: "reset";
         }>;
         automatic: z.ZodBoolean;
     }, z.core.$strip>>;
@@ -64,10 +64,10 @@ declare const stateSchema: z.ZodObject<{
 type State = z.infer<typeof stateSchema>;
 declare const outcomeSchema: z.ZodObject<{
     outcome: z.ZodEnum<{
-        reset: "reset";
-        nothingToReset: "nothingToReset";
-        noCredit: "noCredit";
         alreadyRedeemed: "alreadyRedeemed";
+        noCredit: "noCredit";
+        nothingToReset: "nothingToReset";
+        reset: "reset";
     }>;
 }, z.core.$strip>;
 export type ResetOutcome = z.infer<typeof outcomeSchema>['outcome'];

package/dist/lib/runtime/resume-picker.js

@@ -104,7 +104,7 @@ function displayText(value) {
     // Session titles and directory names are untrusted terminal output.
     return String(value).replace(/[\x00-\x1f\x7f-\x9f]/g, " ").slice(0, 180);
 }
-export async function pickResumeThread(options, deps = { createCatalog: createResumeCatalog, select: (select) }) {
+export async function pickResumeThread(options, deps = { createCatalog: createResumeCatalog, select: select }) {
     const catalog = deps.createCatalog(options);
     const pages = [];
     let pageIndex = 0;

package/dist/lib/runtime/subscription-first-use.js

@@ -2,7 +2,7 @@ import { createUsageStreamScanner } from "../usage/usage-extraction.js";
 import { isRecord } from "../utils.js";
 /** Only personal included subscriptions may receive an automatic first-use probe. */
 export function needsSubscriptionFirstUse(snapshot, now) {
-    if (snapshot.status !== 200 || !["plus", "pro", "prolite"].includes(snapshot.planType?.toLowerCase() ?? ""))
+    if (snapshot.status !== 200 || !["plus", "pro", "prolite", "promax"].includes(snapshot.planType?.toLowerCase() ?? ""))
         return false;
     const allWindows = [snapshot.primary, snapshot.secondary];
     if (allWindows.some(window => typeof window.usedPercent === "number" && window.usedPercent !== 0))

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

@@ -2,13 +2,13 @@ import { type ManagedAccount } from "../accounts.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;
     id: string;
     accountIndex: number;
     routable: boolean;
     bound: boolean;
     selected: boolean;
     label: string;
-    accountId: string;
-    workspaceIndex: number;
-    enabled: boolean;
 }[];