codex-multi-auth 2.19.0 → 2.20.0

package/dist/lib/runtime/luna-reserve-usage.js

@@ -0,0 +1,68 @@
+import { AccountManager } from "../accounts.js";
+import { LUNA_RESERVE_MODEL } from "../constants.js";
+import { parseLunaReserveRateLimits, } from "../luna-reserve.js";
+import { codexCliAccountIdFor } from "../auth/token-utils.js";
+import { isRecord } from "../utils.js";
+import { workspaceModelScopes } from "./workspace-model-scopes.js";
+import { nativeRateLimitsRpc } from "./native-rate-limits.js";
+import { ensureFreshAccessToken } from "./rotation-token-refresh.js";
+/**
+ * Read Luna Reserve usage through the same isolated native app-server bridge
+ * used for reset credits. Failures are per-account: one stale/revoked account
+ * never prevents other rows from reporting their Reserve percentage.
+ */
+export async function refreshLunaReserveUsage(storage, now = Date.now) {
+    const manager = new AccountManager(undefined, storage);
+    const result = {};
+    try {
+        for (let index = 0; index < storage.accounts.length; index += 1) {
+            const stored = storage.accounts[index];
+            const account = manager.getAccountByIndex(index);
+            if (!stored || !account || account.enabled === false)
+                continue;
+            const scopes = workspaceModelScopes(account);
+            const targetScope = account.workspaces?.length
+                ? scopes.find((scope) => scope.selected && scope.routable)
+                : scopes.find((scope) => scope.bound && scope.routable);
+            if (!targetScope)
+                continue;
+            try {
+                const fresh = await ensureFreshAccessToken({
+                    accountManager: manager,
+                    account,
+                    family: "gpt-5.2",
+                    model: LUNA_RESERVE_MODEL,
+                    now: now(),
+                    tokenRefreshSkewMs: 60_000,
+                    tokenInvalidationCooldownMs: 300_000,
+                });
+                if (!fresh.ok)
+                    continue;
+                const auth = {
+                    accessToken: fresh.accessToken,
+                    accountId: targetScope.accountId,
+                    expiresAt: fresh.account.expires ?? 0,
+                    codexCliMirror: account.codexCliMirror,
+                };
+                const sentAccountId = codexCliAccountIdFor(auth, fresh.accessToken) ?? targetScope.accountId;
+                const reply = await nativeRateLimitsRpc(auth, "account/rateLimits/read", {
+                    supportsLunaReserve: true,
+                    excludeResetCreditDetails: true,
+                });
+                if (isRecord(reply) &&
+                    typeof reply.accountId === "string" &&
+                    reply.accountId !== sentAccountId) {
+                    continue;
+                }
+                result[index] = parseLunaReserveRateLimits(reply, now());
+            }
+            catch {
+                // Best-effort usage reporting; callers still emit normal quota.
+            }
+        }
+        return result;
+    }
+    finally {
+        await manager.flushPendingSave();
+    }
+}

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { type AccountStorageV3 } from "../storage.js";
-import { type ApiRouteCredential, updateApiModelDiscovery } from "../api-route-store.js";
+import { type AccountStorageV3, loadAccounts } from "../storage.js";
+import { type ApiRouteCredential, loadApiRoutes, updateApiModelDiscovery } from "../api-route-store.js";
 declare const schema: z.ZodObject<{
     apiConfigurationUnavailable: z.ZodOptional<z.ZodBoolean>;
     version: z.ZodLiteral<1>;
@@ -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;
@@ -90,9 +90,13 @@ export declare function refreshAndPrintModelInventory(log: (message: string) =>
     }>;
     fetchImpl?: typeof fetch;
     loadInventory?: typeof loadModelInventory;
+    loadAccounts?: typeof loadAccounts;
+    loadApiRoutes?: typeof loadApiRoutes;
     now?: () => number;
     /** Only an explicit `check capabilities` bypasses the 15-minute probe cache. */
     forceProbes?: boolean;
+    /** Installed `codex --version` probe, used when the inventory stores no clientVersion. */
+    detectClientVersion?: () => Promise<string | null>;
 }): Promise<boolean>;
 /** Compare stable credential/workspace scopes, keeping the last successful baseline through outages. */
 export declare function withInventoryChanges(current: ModelInventory, previous: ModelInventory | null): ModelInventory;

package/dist/lib/runtime/model-discovery-status.js

@@ -15,6 +15,7 @@ import { loadApiRoutes, updateApiModelDiscovery, } from "../api-route-store.js";
 import { ApiModelRuntime, boundedJson } from "./api-model-runtime.js";
 import { AccountModelCatalog } from "./account-model-catalog.js";
 import { ensureFreshAccessToken } from "./rotation-token-refresh.js";
+import { CLIENT_VERSION_PATTERN, detectInstalledCodexCliVersion, } from "../codex-cli/version.js";
 import { createCodexHeaders } from "../request/headers.js";
 import { CODEX_BASE_URL } from "../constants.js";
 import { getCodexMultiAuthDir } from "../runtime-paths.js";
@@ -103,7 +104,7 @@ export async function discoverModelInventory(storage, routes, options = {}) {
             throw Error("Identity unavailable");
         const url = new URL(`${CODEX_BASE_URL}/codex/models`);
         const version = options.clientVersion;
-        if (version && /^[0-9A-Za-z.+_-]{1,80}$/.test(version))
+        if (version && CLIENT_VERSION_PATTERN.test(version))
             url.searchParams.set("client_version", version);
         const response = await fetcher(url, {
             headers: createCodexHeaders({
@@ -250,6 +251,11 @@ export async function refreshAndPrintModelInventory(log, deps = {}) {
     try {
         const load = deps.loadInventory ?? loadModelInventory;
         const previous = await load();
+        // The catalog requires client_version (issue #733): the stored inventory
+        // version wins, otherwise probe the installed `codex --version` so a fresh
+        // inventory seeds one and saves it for the next check.
+        const detectClientVersion = async () => (await (deps.detectClientVersion ?? detectInstalledCodexCliVersion)().catch(() => null)) ?? undefined;
+        const clientVersion = previous?.clientVersion;
         const binding = await (deps.getBinding ?? getAppBindStatus)();
         if (binding.running && binding.state?.nativeOpenai) {
             const started = (deps.now ?? Date.now)();
@@ -266,8 +272,9 @@ export async function refreshAndPrintModelInventory(log, deps = {}) {
             url.searchParams.set("refresh_capabilities", "1");
             if (deps.forceProbes)
                 url.searchParams.set("force_probes", "1");
-            if (previous?.clientVersion)
-                url.searchParams.set("client_version", previous.clientVersion);
+            const proxyClientVersion = clientVersion ?? (await detectClientVersion());
+            if (proxyClientVersion)
+                url.searchParams.set("client_version", proxyClientVersion);
             const clientApiKey = binding.state.clientApiKey;
             const current = await withCheckProgress("Refreshing workspace catalogs and API/ZDR probes", async () => {
                 const response = await (deps.fetchImpl ?? fetch)(url, {
@@ -294,8 +301,9 @@ export async function refreshAndPrintModelInventory(log, deps = {}) {
         }
         const value = await withCheckProgress("Discovering workspace models and API/ZDR capabilities", async () => {
             let apiConfigurationUnavailable = false;
-            const value = await discoverModelInventory(await loadAccounts(), await loadApiRoutes().catch(() => { apiConfigurationUnavailable = true; log("API configuration unavailable; checking subscription models only."); return []; }), {
-                clientVersion: previous?.clientVersion,
+            const value = await discoverModelInventory(await (deps.loadAccounts ?? loadAccounts)(), await (deps.loadApiRoutes ?? loadApiRoutes)().catch(() => { apiConfigurationUnavailable = true; log("API configuration unavailable; checking subscription models only."); return []; }), {
+                clientVersion: clientVersion ?? (await detectClientVersion()),
+                fetchImpl: deps.fetchImpl,
                 updateApiDiscovery: updateApiModelDiscovery,
                 forceProbes: deps.forceProbes === true,
                 persistProbes: true,

package/dist/lib/runtime/reset-credit-routing.js

@@ -1,9 +1,10 @@
 import { extractAccountId } from '../accounts.js';
+import { LUNA_RESERVE_MODEL } from '../constants.js';
 import { parseModelRoute } from '../model-route-policy.js';
 import { subscriptionQuotaPreference } from './subscription-quota-order.js';
 import { resetSnapshotQuota } from './reset-credits.js';
 export async function recoverResetQuota(options) {
-    if (!options.native || options.pinned || parseModelRoute(options.model).kind !== 'oauth')
+    if (options.model === LUNA_RESERVE_MODEL || !options.native || options.pinned || parseModelRoute(options.model).kind !== 'oauth')
         return false;
     const family = options.family ?? 'codex';
     const candidates = [...options.scopes].flatMap(([index, scopes]) => { const account = options.manager.getAccountByIndex(index); return account && !account.authInvalidatedAt ? scopes.map(scope => ({ account, scope })) : []; });
@@ -50,6 +51,8 @@ export async function recoverResetQuota(options) {
 }
 /** Apply a confirmed earned reset once per workspace/model observation. */
 export function applyConfirmedReset(options) {
+    if (options.model === LUNA_RESERVE_MODEL)
+        return false;
     const s = options.snapshot;
     if (!s || options.lastRedemptionAt === undefined || s.updatedAt < options.lastRedemptionAt || s.ordinaryUsageAllowed !== true || s.updatedAt <= (options.previous?.updatedAt ?? 0) || options.now - s.updatedAt > 60000 || s.updatedAt > options.now)
         return false;

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/rotation-server-types.d.ts

@@ -26,6 +26,8 @@ export interface RuntimeRotationProxyStatus {
     totalRequests: number;
     upstreamRequests: number;
     retries: number;
+    /** Number of ordinary GPT-6 Luna requests retried through Luna Reserve. */
+    lunaReserveFallbacks?: number;
     rotations: number;
     streamsStarted: number;
     lastError: string | null;

package/dist/lib/runtime/runtime-observability.d.ts

@@ -35,6 +35,8 @@ export interface RuntimeObservabilitySnapshot {
     responsesRequests: number;
     authRefreshRequests: number;
     diagnosticProbeRequests: number;
+    /** Number of ordinary Luna requests that switched to the separately metered Reserve model. */
+    lunaReserveFallbacks: number;
     poolExhaustionCooldownUntil: number | null;
     serverBurstCooldownUntil: number | null;
     lastAccountIndex?: number | null;

package/dist/lib/runtime/runtime-observability.js

@@ -27,6 +27,7 @@ function createDefaultSnapshot() {
         responsesRequests: 0,
         authRefreshRequests: 0,
         diagnosticProbeRequests: 0,
+        lunaReserveFallbacks: 0,
         poolExhaustionCooldownUntil: null,
         serverBurstCooldownUntil: null,
         lastAccountIndex: null,

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;
 }[];