codex-multi-auth 2.17.2 → 2.18.0

package/config/codex-legacy.json

@@ -165,8 +165,8 @@
             "store": false
           }
         },
-        "gpt-6-astra-aeon-low": {
-          "name": "GPT 6 Astra Aeon Low (OAuth)",
+        "gpt-6.1-sol-low": {
+          "name": "GPT 6.1 Sol Low (OAuth)",
           "limit": {
             "context": 272000,
             "output": 128000
@@ -190,8 +190,8 @@
             "store": false
           }
         },
-        "gpt-6-astra-aeon-medium": {
-          "name": "GPT 6 Astra Aeon Medium (OAuth)",
+        "gpt-6.1-sol-medium": {
+          "name": "GPT 6.1 Sol Medium (OAuth)",
           "limit": {
             "context": 272000,
             "output": 128000
@@ -215,8 +215,8 @@
             "store": false
           }
         },
-        "gpt-6-astra-aeon-high": {
-          "name": "GPT 6 Astra Aeon High (OAuth)",
+        "gpt-6.1-sol-high": {
+          "name": "GPT 6.1 Sol High (OAuth)",
           "limit": {
             "context": 272000,
             "output": 128000
@@ -240,8 +240,8 @@
             "store": false
           }
         },
-        "gpt-6-astra-aeon-xhigh": {
-          "name": "GPT 6 Astra Aeon Extra High (OAuth)",
+        "gpt-6.1-sol-xhigh": {
+          "name": "GPT 6.1 Sol Xhigh (OAuth)",
           "limit": {
             "context": 272000,
             "output": 128000
@@ -265,8 +265,8 @@
             "store": false
           }
         },
-        "gpt-6-astra-aeon-max": {
-          "name": "GPT 6 Astra Aeon Max (OAuth)",
+        "gpt-6.1-sol-max": {
+          "name": "GPT 6.1 Sol Max (OAuth)",
           "limit": {
             "context": 272000,
             "output": 128000
@@ -290,8 +290,8 @@
             "store": false
           }
         },
-        "gpt-6-astra-aeon-ultra": {
-          "name": "GPT 6 Astra Aeon Ultra (OAuth)",
+        "gpt-6.1-sol-ultra": {
+          "name": "GPT 6.1 Sol Ultra (OAuth)",
           "limit": {
             "context": 272000,
             "output": 128000
@@ -1014,206 +1014,6 @@
             ],
             "store": false
           }
-        },
-        "gpt-5.5-none": {
-          "name": "GPT 5.5 None (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": [
-              "text",
-              "image"
-            ],
-            "output": [
-              "text"
-            ]
-          },
-          "options": {
-            "reasoningEffort": "none",
-            "reasoningSummary": "auto",
-            "textVerbosity": "medium",
-            "include": [
-              "reasoning.encrypted_content"
-            ],
-            "store": false
-          }
-        },
-        "gpt-5.5-low": {
-          "name": "GPT 5.5 Low (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": [
-              "text",
-              "image"
-            ],
-            "output": [
-              "text"
-            ]
-          },
-          "options": {
-            "reasoningEffort": "low",
-            "reasoningSummary": "auto",
-            "textVerbosity": "medium",
-            "include": [
-              "reasoning.encrypted_content"
-            ],
-            "store": false
-          }
-        },
-        "gpt-5.5-medium": {
-          "name": "GPT 5.5 Medium (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": [
-              "text",
-              "image"
-            ],
-            "output": [
-              "text"
-            ]
-          },
-          "options": {
-            "reasoningEffort": "medium",
-            "reasoningSummary": "auto",
-            "textVerbosity": "medium",
-            "include": [
-              "reasoning.encrypted_content"
-            ],
-            "store": false
-          }
-        },
-        "gpt-5.5-high": {
-          "name": "GPT 5.5 High (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": [
-              "text",
-              "image"
-            ],
-            "output": [
-              "text"
-            ]
-          },
-          "options": {
-            "reasoningEffort": "high",
-            "reasoningSummary": "detailed",
-            "textVerbosity": "medium",
-            "include": [
-              "reasoning.encrypted_content"
-            ],
-            "store": false
-          }
-        },
-        "gpt-5.5-xhigh": {
-          "name": "GPT 5.5 Extra High (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": [
-              "text",
-              "image"
-            ],
-            "output": [
-              "text"
-            ]
-          },
-          "options": {
-            "reasoningEffort": "xhigh",
-            "reasoningSummary": "detailed",
-            "textVerbosity": "medium",
-            "include": [
-              "reasoning.encrypted_content"
-            ],
-            "store": false
-          }
-        },
-        "gpt-5.5-pro-medium": {
-          "name": "GPT 5.5 Pro Medium (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": [
-              "text",
-              "image"
-            ],
-            "output": [
-              "text"
-            ]
-          },
-          "options": {
-            "reasoningEffort": "medium",
-            "reasoningSummary": "detailed",
-            "textVerbosity": "medium",
-            "include": [
-              "reasoning.encrypted_content"
-            ],
-            "store": false
-          }
-        },
-        "gpt-5.5-pro-high": {
-          "name": "GPT 5.5 Pro High (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": [
-              "text",
-              "image"
-            ],
-            "output": [
-              "text"
-            ]
-          },
-          "options": {
-            "reasoningEffort": "high",
-            "reasoningSummary": "detailed",
-            "textVerbosity": "medium",
-            "include": [
-              "reasoning.encrypted_content"
-            ],
-            "store": false
-          }
-        },
-        "gpt-5.5-pro-xhigh": {
-          "name": "GPT 5.5 Pro Extra High (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": [
-              "text",
-              "image"
-            ],
-            "output": [
-              "text"
-            ]
-          },
-          "options": {
-            "reasoningEffort": "xhigh",
-            "reasoningSummary": "detailed",
-            "textVerbosity": "medium",
-            "include": [
-              "reasoning.encrypted_content"
-            ],
-            "store": false
-          }
         }
       }
     }

package/config/codex-modern.json

@@ -15,8 +15,8 @@
         "store": false
       },
       "models": {
-        "gpt-6-astra": {
-          "name": "GPT 6 Astra (OAuth)",
+        "gpt-6.1-sol": {
+          "name": "GPT 6.1 Sol (OAuth)",
           "limit": {
             "context": 272000,
             "output": 128000
@@ -63,8 +63,8 @@
             }
           }
         },
-        "gpt-6-astra-aeon": {
-          "name": "GPT 6 Astra Aeon (OAuth)",
+        "gpt-6-astra": {
+          "name": "GPT 6 Astra (OAuth)",
           "limit": {
             "context": 272000,
             "output": 128000
@@ -340,82 +340,6 @@
               "textVerbosity": "medium"
             }
           }
-        },
-        "gpt-5.5": {
-          "name": "GPT 5.5 (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": [
-              "text",
-              "image"
-            ],
-            "output": [
-              "text"
-            ]
-          },
-          "variants": {
-            "none": {
-              "reasoningEffort": "none",
-              "reasoningSummary": "auto",
-              "textVerbosity": "medium"
-            },
-            "low": {
-              "reasoningEffort": "low",
-              "reasoningSummary": "auto",
-              "textVerbosity": "medium"
-            },
-            "medium": {
-              "reasoningEffort": "medium",
-              "reasoningSummary": "auto",
-              "textVerbosity": "medium"
-            },
-            "high": {
-              "reasoningEffort": "high",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            },
-            "xhigh": {
-              "reasoningEffort": "xhigh",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            }
-          }
-        },
-        "gpt-5.5-pro": {
-          "name": "GPT 5.5 Pro (OAuth)",
-          "limit": {
-            "context": 272000,
-            "output": 128000
-          },
-          "modalities": {
-            "input": [
-              "text",
-              "image"
-            ],
-            "output": [
-              "text"
-            ]
-          },
-          "variants": {
-            "medium": {
-              "reasoningEffort": "medium",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            },
-            "high": {
-              "reasoningEffort": "high",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            },
-            "xhigh": {
-              "reasoningEffort": "xhigh",
-              "reasoningSummary": "detailed",
-              "textVerbosity": "medium"
-            }
-          }
         }
       }
     }

package/config/minimal-codex.json

@@ -9,7 +9,7 @@
       }
     }
   },
-  "model": "openai/gpt-5.3-codex"
+  "model": "openai/gpt-5.6-sol"
 }
 
 

package/dist/index.d.ts

@@ -42,4 +42,3 @@ import type { Plugin } from "@codex-ai/plugin";
 export declare const OpenAIOAuthPlugin: Plugin;
 export declare const OpenAIAuthPlugin: any;
 export default OpenAIOAuthPlugin;
-//# sourceMappingURL=index.d.ts.map

package/dist/lib/account-policy.d.ts

@@ -21,8 +21,24 @@ export declare function getAccountPolicyKey(account: Pick<AccountMetadataV3, "ac
     refreshToken?: string | null;
 }, _index?: number): string;
 export declare function loadAccountPolicyStore(): Promise<AccountPolicyStore>;
-export declare function saveAccountPolicyStore(store: AccountPolicyStore): Promise<void>;
+export declare function saveAccountPolicyStore(store: AccountPolicyStore, baseline?: AccountPolicyStore): Promise<void>;
+/**
+ * Run a policy-store read→mutate→write inside the write queue (in-process
+ * serialization) AND the cross-process lock directory, with mtime CAS retry:
+ * every attempt re-reads the freshest on-disk store and re-applies `mutate`
+ * before writing — so two commands editing DIFFERENT fields of the same
+ * policy (e.g. `weight` vs `tags`) both land, which the whole-record
+ * `updatedAt` merge in {@link saveAccountPolicyStore} cannot guarantee: a
+ * stale snapshot's record would either clobber a newer record wholesale or be
+ * discarded entirely. `mutate` must be re-appliable across retries (apply
+ * precomputed work onto the store it is handed, don't capture mutated state).
+ * Prefer this over load→upsert→save whenever the caller is mutating rather
+ * than importing a foreign store.
+ */
+export declare function updateAccountPolicyStore<T>(mutate: (store: AccountPolicyStore) => {
+    result: T;
+    dirty: boolean;
+}): Promise<T>;
 export declare function upsertAccountPolicy(store: AccountPolicyStore, accountKey: string, mutate: (policy: AccountPolicy) => void, now?: number): AccountPolicy;
 export declare function normalizeAccountPolicyTag(value: string): string | null;
 export declare function resetAccountPolicyWriteQueueForTests(): void;
-//# sourceMappingURL=account-policy.d.ts.map

package/dist/lib/account-policy.js

@@ -4,10 +4,9 @@ import { basename, join } from "node:path";
 import { logWarn } from "./logger.js";
 import { getCodexMultiAuthDir } from "./runtime-paths.js";
 import { isRecord, sleep } from "./utils.js";
-import { tempPathFor } from "./temp-path.js";
+import { getJsonStoreFileMtimeMs, resetJsonStoreWriteQueuesForTests, stampUpdatedAt, withJsonStoreCasRetry, withJsonStoreFileLock, withJsonStoreWriteQueue, writeJsonStoreFileAtomicWithRetry, } from "./storage/json-store-lock.js";
 const ACCOUNT_POLICY_FILE_NAME = "account-policies.json";
 const RETRYABLE_FS_CODES = new Set(["EBUSY", "EPERM"]);
-let writeQueue = Promise.resolve();
 function isRetryableFsError(error) {
     const code = error?.code;
     return typeof code === "string" && RETRYABLE_FS_CODES.has(code);
@@ -113,45 +112,103 @@ export async function loadAccountPolicyStore() {
         return emptyStore();
     }
 }
-export async function saveAccountPolicyStore(store) {
-    const path = getAccountPolicyPath();
-    const payload = normalizeStore(store);
-    const task = async () => {
-        await fs.mkdir(getCodexMultiAuthDir(), { recursive: true, mode: 0o700 });
-        const tempPath = tempPathFor(path);
-        let moved = false;
-        try {
-            await fs.writeFile(tempPath, `${JSON.stringify(payload, null, 2)}\n`, {
-                encoding: "utf8",
-                mode: 0o600,
-            });
-            for (let attempt = 0; attempt < 5; attempt += 1) {
-                try {
-                    await fs.rename(tempPath, path);
-                    moved = true;
-                    return;
-                }
-                catch (error) {
-                    if (!isRetryableFsError(error) || attempt >= 4)
-                        throw error;
-                    await sleep(10 * 2 ** attempt);
-                }
+/**
+ * Per-key merge of the caller's normalized store over the freshest on-disk
+ * store. Policies are keyed by the account's hashed identity (`sha256:`) and
+ * carry `updatedAt`; the newer entry wins per key so a save built on a stale
+ * snapshot cannot resurrect an older policy over a concurrent process's
+ * newer one. Keys the caller does not carry are preserved (upsert-only store
+ * — nothing deletes entries), matching the config save's
+ * patch-over-fresh-read semantics.
+ *
+ * When `baseline` (the caller's pre-edit snapshot) is supplied, entries
+ * identical to it are untouched carried copies and skipped entirely, so a
+ * stale snapshot row can never be re-stamped over a raced write. Entries
+ * that differ are deliberate writes and must not lose purely on timestamp:
+ * the upsert-time floor stamps against the caller's snapshot, but a
+ * concurrent writer can land a still-newer entry before this merge runs, so
+ * the merge re-stamps against the freshest on-disk entry instead of
+ * silently dropping the edit. Without a baseline every supplied entry is a
+ * plain `updatedAt >=` upsert.
+ */
+function mergeAccountPolicies(current, incoming, baseline) {
+    const merged = {
+        version: 1,
+        accounts: { ...current.accounts },
+    };
+    const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+    for (const [key, policy] of Object.entries(incoming.accounts)) {
+        const existing = merged.accounts[key];
+        if (!baseline) {
+            if (!existing || policy.updatedAt >= existing.updatedAt) {
+                merged.accounts[key] = policy;
             }
+            continue;
         }
-        finally {
-            if (!moved) {
-                try {
-                    await fs.unlink(tempPath);
-                }
-                catch {
-                    // Best-effort temp cleanup.
-                }
-            }
+        if (same(policy, baseline.accounts[key]))
+            continue;
+        policy.updatedAt = stampUpdatedAt(policy.updatedAt, existing?.updatedAt);
+        merged.accounts[key] = policy;
+    }
+    return merged;
+}
+export async function saveAccountPolicyStore(store, baseline) {
+    const path = getAccountPolicyPath();
+    const incoming = normalizeStore(store);
+    // Normalize at invocation like `incoming`: later caller-side mutation of
+    // `baseline` must not shift which entries the merge counts as deliberate.
+    const prior = baseline ? normalizeStore(baseline) : undefined;
+    // Per-path promise queue serializes writers inside THIS process; the
+    // lock directory closes the same window against OTHER processes. Inside the lock
+    // every attempt re-stats (CAS), re-reads the freshest on-disk store, and
+    // merges this call's entries over it — so a save that raced a concurrent
+    // write reloads-and-retries rather than blindly overwriting it.
+    await withJsonStoreWriteQueue(path, async () => {
+        await withJsonStoreFileLock(path, async () => {
+            await withJsonStoreCasRetry(async () => {
+                const expectedMtimeMs = await getJsonStoreFileMtimeMs(path);
+                const current = await loadAccountPolicyStore();
+                const merged = mergeAccountPolicies(current, incoming, prior);
+                await fs.mkdir(getCodexMultiAuthDir(), {
+                    recursive: true,
+                    mode: 0o700,
+                });
+                await writeJsonStoreFileAtomicWithRetry(path, merged, {
+                    expectedMtimeMs,
+                    mode: 0o600,
+                });
+            });
+        });
+    });
+}
+/**
+ * Run a policy-store read→mutate→write inside the write queue (in-process
+ * serialization) AND the cross-process lock directory, with mtime CAS retry:
+ * every attempt re-reads the freshest on-disk store and re-applies `mutate`
+ * before writing — so two commands editing DIFFERENT fields of the same
+ * policy (e.g. `weight` vs `tags`) both land, which the whole-record
+ * `updatedAt` merge in {@link saveAccountPolicyStore} cannot guarantee: a
+ * stale snapshot's record would either clobber a newer record wholesale or be
+ * discarded entirely. `mutate` must be re-appliable across retries (apply
+ * precomputed work onto the store it is handed, don't capture mutated state).
+ * Prefer this over load→upsert→save whenever the caller is mutating rather
+ * than importing a foreign store.
+ */
+export async function updateAccountPolicyStore(mutate) {
+    const path = getAccountPolicyPath();
+    return withJsonStoreWriteQueue(path, () => withJsonStoreFileLock(path, () => withJsonStoreCasRetry(async () => {
+        const expectedMtimeMs = await getJsonStoreFileMtimeMs(path);
+        const store = await loadAccountPolicyStore();
+        const { result, dirty } = mutate(store);
+        if (dirty) {
+            await fs.mkdir(getCodexMultiAuthDir(), {
+                recursive: true,
+                mode: 0o700,
+            });
+            await writeJsonStoreFileAtomicWithRetry(path, normalizeStore(store), { expectedMtimeMs, mode: 0o600 });
         }
-    };
-    const queued = writeQueue.catch(() => undefined).then(task);
-    writeQueue = queued.then(() => undefined, () => undefined);
-    await queued;
+        return result;
+    })));
 }
 /** Tiers are integers 0-9; anything else (including legacy absence) is tier 1. */
 function normalizePriority(value) {
@@ -168,7 +225,7 @@ export function upsertAccountPolicy(store, accountKey, mutate, now = Date.now())
     next.weight = normalizeWeight(next.weight);
     next.priority = normalizePriority(next.priority);
     next.autoPrime = next.autoPrime === true;
-    next.updatedAt = now;
+    next.updatedAt = stampUpdatedAt(now, store.accounts[accountKey]?.updatedAt);
     store.accounts[accountKey] = next;
     return next;
 }
@@ -176,5 +233,5 @@ export function normalizeAccountPolicyTag(value) {
     return normalizeTag(value);
 }
 export function resetAccountPolicyWriteQueueForTests() {
-    writeQueue = Promise.resolve();
+    resetJsonStoreWriteQueuesForTests(getAccountPolicyPath());
 }

package/dist/lib/accounts/rate-limits.d.ts

@@ -27,4 +27,3 @@ export declare function clearAllRateLimits(entity: RateLimitedEntity): void;
 export declare function isRateLimitedForQuotaKey(entity: RateLimitedEntity, key: QuotaKey): boolean;
 export declare function isRateLimitedForFamily(entity: RateLimitedEntity, family: ModelFamily, model?: string | null): boolean;
 export declare function formatWaitTime(ms: number): string;
-//# sourceMappingURL=rate-limits.d.ts.map

package/dist/lib/accounts.d.ts

@@ -385,4 +385,3 @@ export declare function formatCooldown(account: {
     coolingDownUntil?: number;
     cooldownReason?: string;
 }, now?: number): string | null;
-//# sourceMappingURL=accounts.d.ts.map

package/dist/lib/accounts.js

@@ -922,16 +922,15 @@ export class AccountManager {
         if (shouldConsumeToken && !tokenTracker.tryConsume(trackerKey, quotaKey)) {
             return { ok: false, reason: "token-exhausted" };
         }
-        try {
-            getCircuitBreaker(getAccountCircuitKey(account)).canExecute();
-            return { ok: true };
-        }
-        catch {
+        // Non-throwing probe keeps circuit-open storms off the exception path.
+        const admission = getCircuitBreaker(getAccountCircuitKey(account)).tryCanExecute();
+        if (!admission.ok) {
             if (shouldConsumeToken) {
                 tokenTracker.refundToken(trackerKey, quotaKey);
             }
             return { ok: false, reason: "circuit-open" };
         }
+        return { ok: true };
     }
     /**
      * Refund a token consumed within the refund window (30 seconds).

package/dist/lib/api-route-store.d.ts

@@ -21,4 +21,3 @@ export declare function loadApiRoutes(path?: string): Promise<ApiRouteCredential
 export declare function saveApiRoutes(routes: ApiRouteCredential[], path?: string, expected?: ApiRouteCredential[]): Promise<void>;
 export declare function updateApiModelDiscovery(route: ApiRouteCredential, models: string[], path?: string): Promise<ApiRouteCredential>;
 export {};
-//# sourceMappingURL=api-route-store.d.ts.map

package/dist/lib/audit.d.ts

@@ -33,4 +33,3 @@ export declare function getAuditConfig(): AuditConfig;
 export declare function auditLog(action: AuditAction, actor: string, resource: string, outcome: AuditOutcome, metadata?: Record<string, unknown>): void;
 export declare function getAuditLogPath(): string;
 export declare function listAuditLogFiles(): string[];
-//# sourceMappingURL=audit.d.ts.map