codex-multi-auth 2.3.0-beta.0 → 2.3.0-beta.2

package/dist/lib/config.js

@@ -2,6 +2,7 @@ import { existsSync, promises as fs, readFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
 import { parseBooleanEnv } from "./env-parsing.js";
+import { withRetry, withRetrySync } from "./fs-retry.js";
 import { logWarn } from "./logger.js";
 import { getCodexHomeDir, getCodexMultiAuthDir, getLegacyCodexDir, } from "./runtime-paths.js";
 import { getValidationErrors, PluginConfigSchema } from "./schemas.js";
@@ -32,33 +33,19 @@ const RETRYABLE_CONFIG_READ_CODES = new Set(["EBUSY", "EPERM", "EAGAIN"]);
  * attempts). ENOENT and SyntaxError are not retryable and propagate unchanged.
  */
 function readFileSyncWithConfigRetry(configPath) {
-    const maxAttempts = 5;
-    let lastError;
-    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-        try {
-            return readFileSync(configPath, "utf-8");
-        }
-        catch (error) {
-            lastError = error;
-            const code = error?.code;
-            if (typeof code === "string" &&
-                RETRYABLE_CONFIG_READ_CODES.has(code) &&
-                attempt < maxAttempts - 1) {
-                // Immediate retry — NOT a blocking sleep. loadPluginConfig() is
-                // synchronous and runs on startup, so the previous Atomics.wait froze
-                // the entire event loop for up to ~150ms on a transient Windows AV /
-                // indexer lock. An immediate re-read costs microseconds and a brief
-                // exclusive lock is typically released by the next attempt; if it
-                // genuinely persists we fail fast (the caller falls back to defaults)
-                // rather than stalling the process.
-                continue;
-            }
-            throw error;
-        }
-    }
-    // Exhausted attempts on a retryable code: surface the last error so the caller
-    // classifies it (unreadable) instead of silently returning stale/empty content.
-    throw lastError;
+    // Immediate retry (backoffMs: 0) — NOT a blocking sleep. loadPluginConfig()
+    // is synchronous and runs on startup, so the previous Atomics.wait froze the
+    // entire event loop for up to ~150ms on a transient Windows AV / indexer
+    // lock. An immediate re-read costs microseconds and a brief exclusive lock
+    // is typically released by the next attempt; if it genuinely persists we
+    // fail fast (the caller falls back to defaults) rather than stalling the
+    // process. On exhaustion the last error surfaces so the caller classifies it
+    // (unreadable) instead of silently returning stale/empty content.
+    return withRetrySync(() => readFileSync(configPath, "utf-8"), {
+        maxAttempts: 5,
+        backoffMs: 0,
+        retryableCodes: RETRYABLE_CONFIG_READ_CODES,
+    });
 }
 function logConfigWarnOnce(message) {
     if (emittedConfigWarnings.has(message)) {
@@ -332,10 +319,6 @@ function stripUtf8Bom(content) {
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function isRetryableFsError(error) {
-    const code = error?.code;
-    return typeof code === "string" && RETRYABLE_FS_CODES.has(code);
-}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -344,30 +327,24 @@ async function getConfigFileMtimeMs(filePath) {
     // run on the Windows-sensitive save path, where a transient EBUSY/EPERM/EAGAIN
     // from an AV/indexer lock on a single fs.stat would abort the entire save.
     // Mirror readConfigRecordForSave's bounded transient-FS retry (same code set,
-    // same backoff, 5 attempts). ENOENT still returns null immediately.
-    let lastError;
-    for (let attempt = 0; attempt < 5; attempt += 1) {
+    // same backoff, 5 attempts). ENOENT still returns null immediately. On
+    // exhaustion the last failure surfaces so the caller treats it as a real
+    // save error rather than a phantom missing file.
+    return withRetry(async () => {
         try {
             return (await fs.stat(filePath)).mtimeMs;
         }
         catch (error) {
-            const code = error?.code;
-            if (code === "ENOENT") {
+            if (error?.code === "ENOENT") {
                 return null;
             }
-            lastError = error;
-            if (typeof code === "string" &&
-                RETRYABLE_CONFIG_READ_CODES.has(code) &&
-                attempt < 4) {
-                await sleep(10 * 2 ** attempt);
-                continue;
-            }
             throw error;
         }
-    }
-    // Exhausted retries on a transient code: surface the last failure so the caller
-    // treats it as a real save error rather than a phantom missing file.
-    throw lastError;
+    }, {
+        maxAttempts: 5,
+        backoffMs: (attempt) => 10 * 2 ** (attempt - 1),
+        retryableCodes: RETRYABLE_CONFIG_READ_CODES,
+    });
 }
 async function writeJsonFileAtomicWithRetry(filePath, payload, options) {
     const tempPath = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`;
@@ -386,19 +363,12 @@ async function writeJsonFileAtomicWithRetry(filePath, payload, options) {
                 throw staleError;
             }
         }
-        for (let attempt = 0; attempt < 5; attempt += 1) {
-            try {
-                await fs.rename(tempPath, filePath);
-                renamed = true;
-                return;
-            }
-            catch (error) {
-                if (!isRetryableFsError(error) || attempt >= 4) {
-                    throw error;
-                }
-                await sleep(10 * 2 ** attempt);
-            }
-        }
+        await withRetry(() => fs.rename(tempPath, filePath), {
+            maxAttempts: 5,
+            backoffMs: (attempt) => 10 * 2 ** (attempt - 1),
+            retryableCodes: RETRYABLE_FS_CODES,
+        });
+        renamed = true;
     }
     finally {
         if (!renamed) {
@@ -438,25 +408,17 @@ const CONFIG_LOCK_TTL_MS = 10_000;
 const CONFIG_LOCK_WAIT_TIMEOUT_MS = 10_000;
 const CONFIG_LOCK_POLL_MS = 50;
 async function unlinkConfigLockWithRetry(lockPath) {
-    for (let attempt = 0; attempt < 5; attempt += 1) {
-        try {
-            await fs.unlink(lockPath);
-            return;
-        }
-        catch (error) {
-            const code = error?.code;
-            if (code === "ENOENT")
-                return;
-            if (typeof code === "string" &&
-                RETRYABLE_FS_CODES.has(code) &&
-                attempt < 4) {
-                await sleep(10 * 2 ** attempt);
-                continue;
-            }
-            // Best-effort release: a leftover lockfile is recovered as stale by the
-            // next acquirer via its expiry/mtime, so never fail the save over this.
-            return;
-        }
+    try {
+        await withRetry(() => fs.unlink(lockPath), {
+            maxAttempts: 5,
+            backoffMs: (attempt) => 10 * 2 ** (attempt - 1),
+            retryableCodes: RETRYABLE_FS_CODES,
+        });
+    }
+    catch {
+        // ENOENT (already released) or best-effort release failure: a leftover
+        // lockfile is recovered as stale by the next acquirer via its
+        // expiry/mtime, so never fail the save over this.
     }
 }
 // Owner-safe release: only unlink the lockfile if it still carries OUR owner
@@ -596,8 +558,8 @@ async function readConfigRecordForSave(configPath) {
     if (!existsSync(configPath)) {
         return { status: "missing" };
     }
-    for (let attempt = 0; attempt < 5; attempt += 1) {
-        try {
+    try {
+        return await withRetry(async () => {
             const fileContent = await fs.readFile(configPath, "utf-8");
             const normalizedFileContent = stripUtf8Bom(fileContent);
             const parsed = JSON.parse(normalizedFileContent);
@@ -607,32 +569,27 @@ async function readConfigRecordForSave(configPath) {
                 return { status: "invalid", errorMessage };
             }
             return { status: "ok", record: parsed };
+        }, {
+            maxAttempts: 5,
+            backoffMs: (attempt) => 10 * 2 ** (attempt - 1),
+            retryableCodes: RETRYABLE_CONFIG_READ_CODES,
+        });
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code === "ENOENT") {
+            return { status: "missing" };
         }
-        catch (error) {
-            const code = error?.code;
-            if (code === "ENOENT") {
-                return { status: "missing" };
-            }
-            if (typeof code === "string" &&
-                RETRYABLE_CONFIG_READ_CODES.has(code) &&
-                attempt < 4) {
-                await sleep(10 * 2 ** attempt);
-                continue;
-            }
-            const errorMessage = `Failed to read config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`;
-            logConfigWarnOnce(errorMessage);
-            if (error instanceof SyntaxError) {
-                return { status: "invalid", errorMessage };
-            }
-            if (typeof code === "string") {
-                return { status: "unreadable", errorMessage };
-            }
+        const errorMessage = `Failed to read config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`;
+        logConfigWarnOnce(errorMessage);
+        if (error instanceof SyntaxError) {
             return { status: "invalid", errorMessage };
         }
+        if (typeof code === "string") {
+            return { status: "unreadable", errorMessage };
+        }
+        return { status: "invalid", errorMessage };
     }
-    const errorMessage = `Failed to read config from ${configPath}.`;
-    logConfigWarnOnce(errorMessage);
-    return { status: "unreadable", errorMessage };
 }
 function resolveStoredPluginConfigRecord() {
     // config-01: mirror loadPluginConfig()'s precedence exactly. loadPluginConfig
@@ -1728,4 +1685,3 @@ export function getPluginConfigExplainReport() {
         entries,
     };
 }
-//# sourceMappingURL=config.js.map

package/dist/lib/constants.js

@@ -78,4 +78,3 @@ export const ACCOUNT_LIMITS = {
     /** Number of consecutive auth failures before auto-removing account */
     MAX_AUTH_FAILURES_BEFORE_REMOVAL: 3,
 };
-//# sourceMappingURL=constants.js.map

package/dist/lib/context-overflow.js

@@ -139,4 +139,3 @@ export async function handleContextOverflow(response, model) {
     }
     return { handled: false };
 }
-//# sourceMappingURL=context-overflow.js.map

package/dist/lib/dashboard-settings.js

@@ -324,4 +324,3 @@ export async function saveDashboardDisplaySettings(settings) {
     const normalized = normalizeDashboardDisplaySettings(settings);
     await saveUnifiedDashboardSettings(toJsonRecord(normalized));
 }
-//# sourceMappingURL=dashboard-settings.js.map

package/dist/lib/entitlement-cache.js

@@ -149,4 +149,3 @@ export class EntitlementCache {
         return { accounts };
     }
 }
-//# sourceMappingURL=entitlement-cache.js.map

package/dist/lib/env-parsing.js

@@ -31,4 +31,3 @@ export function parseBooleanEnv(value) {
         return false;
     return undefined;
 }
-//# sourceMappingURL=env-parsing.js.map

package/dist/lib/errors.js

@@ -136,4 +136,3 @@ export function isCodexUnavailableError(error) {
     return (error instanceof Error &&
         error.code === ErrorCode.CODEX_UNAVAILABLE);
 }
-//# sourceMappingURL=errors.js.map

package/dist/lib/forecast.js

@@ -342,4 +342,3 @@ export function buildForecastExplanation(results, recommendation) {
         })),
     };
 }
-//# sourceMappingURL=forecast.js.map

package/dist/lib/fs-retry.d.ts

@@ -3,5 +3,51 @@ export declare const FILE_RETRY_MAX_ATTEMPTS = 6;
 export declare const FILE_RETRY_BASE_DELAY_MS = 25;
 export declare const FILE_RETRY_JITTER_MS = 20;
 export declare function shouldRetryFileOperation(error: unknown): boolean;
+/**
+ * Options for {@link withRetry} / {@link withRetrySync}.
+ *
+ * The shape is deliberately wide enough to express every hand-rolled
+ * file-retry loop in the codebase without changing any call site's behavior:
+ * per-site attempt counts, exponential/linear backoff schedules, optional
+ * jitter, and per-site retryable code sets are all preserved exactly.
+ */
+export interface RetryOptions {
+    /** Total number of attempts (including the first one). Must be >= 1. */
+    maxAttempts: number;
+    /**
+     * Delay before the next attempt, either a fixed number of milliseconds or
+     * a function of the 1-based index of the attempt that just failed (so the
+     * delay after the first failure is `backoffMs(1)`). A computed delay <= 0
+     * retries immediately without scheduling a timer.
+     */
+    backoffMs: number | ((attempt: number) => number);
+    /**
+     * Optional jitter: adds `Math.floor(Math.random() * jitterMs)` to each
+     * computed backoff delay.
+     */
+    jitterMs?: number;
+    /**
+     * Error codes considered transient. Defaults to {@link FILE_RETRY_CODES}.
+     * An error retries only when it carries a string `code` in this set;
+     * everything else is rethrown immediately.
+     */
+    retryableCodes?: ReadonlySet<string> | readonly string[];
+    /** Invoked after each retryable failure, before the backoff delay. */
+    onRetry?: (error: unknown, attempt: number) => void;
+}
+/**
+ * Run `operation`, retrying on transient filesystem error codes with a
+ * per-call backoff schedule. Non-retryable errors are rethrown immediately;
+ * once `maxAttempts` is exhausted the error from the final attempt is
+ * rethrown unchanged. No delay is scheduled after the final attempt.
+ */
+export declare function withRetry<T>(operation: () => Promise<T> | T, options: RetryOptions): Promise<T>;
+/**
+ * Synchronous variant of {@link withRetry} for callers that cannot await
+ * (e.g. the synchronous recovery storage paths). Delays use a bounded
+ * busy-wait, so keep per-site schedules short; a computed delay <= 0 retries
+ * immediately without spinning.
+ */
+export declare function withRetrySync<T>(operation: () => T, options: RetryOptions): T;
 export declare function withFileOperationRetry<T>(operation: () => Promise<T>): Promise<T>;
 //# sourceMappingURL=fs-retry.d.ts.map

package/dist/lib/fs-retry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fs-retry.d.ts","sourceRoot":"","sources":["../../lib/fs-retry.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,aAM3B,CAAC;AACH,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAMvC,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAOhE;AAED,wBAAsB,sBAAsB,CAAC,CAAC,EAC7C,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACzB,OAAO,CAAC,CAAC,CAAC,CAcZ"}
+{"version":3,"file":"fs-retry.d.ts","sourceRoot":"","sources":["../../lib/fs-retry.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,aAM3B,CAAC;AACH,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAMvC,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAOhE;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC5B,wEAAwE;IACxE,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,SAAS,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IAClD;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,cAAc,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,MAAM,EAAE,CAAC;IACzD,sEAAsE;IACtE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACpD;AAgCD;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAChC,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAC/B,OAAO,EAAE,YAAY,GACnB,OAAO,CAAC,CAAC,CAAC,CAkBZ;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,YAAY,GAAG,CAAC,CAqB7E;AAED,wBAAgB,sBAAsB,CAAC,CAAC,EACvC,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACzB,OAAO,CAAC,CAAC,CAAC,CAOZ"}

package/dist/lib/fs-retry.js

@@ -17,19 +17,87 @@ export function shouldRetryFileOperation(error) {
         typeof error.code === "string" &&
         FILE_RETRY_CODES.has(error.code));
 }
-export async function withFileOperationRetry(operation) {
+function getErrorCode(error) {
+    if (typeof error !== "object" || error === null)
+        return undefined;
+    const code = error.code;
+    return typeof code === "string" ? code : undefined;
+}
+function isRetryableError(error, retryableCodes) {
+    const code = getErrorCode(error);
+    if (code === undefined)
+        return false;
+    if (retryableCodes === undefined)
+        return FILE_RETRY_CODES.has(code);
+    return Array.isArray(retryableCodes)
+        ? retryableCodes.includes(code)
+        : retryableCodes.has(code);
+}
+function computeDelayMs(options, attempt) {
+    const base = typeof options.backoffMs === "function"
+        ? options.backoffMs(attempt)
+        : options.backoffMs;
+    const jitter = options.jitterMs !== undefined && options.jitterMs > 0
+        ? Math.floor(Math.random() * options.jitterMs)
+        : 0;
+    return base + jitter;
+}
+/**
+ * Run `operation`, retrying on transient filesystem error codes with a
+ * per-call backoff schedule. Non-retryable errors are rethrown immediately;
+ * once `maxAttempts` is exhausted the error from the final attempt is
+ * rethrown unchanged. No delay is scheduled after the final attempt.
+ */
+export async function withRetry(operation, options) {
     for (let attempt = 1;; attempt += 1) {
         try {
             return await operation();
         }
         catch (error) {
-            if (!shouldRetryFileOperation(error) || attempt >= FILE_RETRY_MAX_ATTEMPTS) {
+            if (!isRetryableError(error, options.retryableCodes) ||
+                attempt >= options.maxAttempts) {
                 throw error;
             }
-            const delayMs = FILE_RETRY_BASE_DELAY_MS * 2 ** (attempt - 1) +
-                Math.floor(Math.random() * FILE_RETRY_JITTER_MS);
-            await sleep(delayMs);
+            options.onRetry?.(error, attempt);
+            const delayMs = computeDelayMs(options, attempt);
+            if (delayMs > 0) {
+                await sleep(delayMs);
+            }
         }
     }
 }
-//# sourceMappingURL=fs-retry.js.map
+/**
+ * Synchronous variant of {@link withRetry} for callers that cannot await
+ * (e.g. the synchronous recovery storage paths). Delays use a bounded
+ * busy-wait, so keep per-site schedules short; a computed delay <= 0 retries
+ * immediately without spinning.
+ */
+export function withRetrySync(operation, options) {
+    for (let attempt = 1;; attempt += 1) {
+        try {
+            return operation();
+        }
+        catch (error) {
+            if (!isRetryableError(error, options.retryableCodes) ||
+                attempt >= options.maxAttempts) {
+                throw error;
+            }
+            options.onRetry?.(error, attempt);
+            const delayMs = computeDelayMs(options, attempt);
+            if (delayMs > 0) {
+                const waitUntil = Date.now() + delayMs;
+                while (Date.now() < waitUntil) {
+                    // Busy-wait within the bounded per-attempt budget.
+                }
+            }
+        }
+    }
+}
+export function withFileOperationRetry(operation) {
+    return withRetry(operation, {
+        maxAttempts: FILE_RETRY_MAX_ATTEMPTS,
+        backoffMs: (attempt) => FILE_RETRY_BASE_DELAY_MS * 2 ** (attempt - 1),
+        jitterMs: FILE_RETRY_JITTER_MS,
+        retryableCodes: FILE_RETRY_CODES,
+    });
+}

package/dist/lib/health.js

@@ -71,4 +71,3 @@ export function formatHealthReport(health) {
     }
     return lines.join("\n");
 }
-//# sourceMappingURL=health.js.map

package/dist/lib/index.js

@@ -39,4 +39,3 @@ export * from "./policy/runtime-policy.js";
 export * from "./local-bridge.js";
 export * from "./local-client-tokens.js";
 export * from "./integration-generators.js";
-//# sourceMappingURL=index.js.map

package/dist/lib/integration-generators.js

@@ -90,4 +90,3 @@ export function generateIntegrationSnippet(kind, input = {}) {
 export function generateIntegrationSnippets(kinds = ["opencode", "openclaw", "python", "curl", "env"], input = {}) {
     return kinds.map((kind) => generateIntegrationSnippet(kind, input));
 }
-//# sourceMappingURL=integration-generators.js.map

package/dist/lib/live-account-sync.js

@@ -193,4 +193,3 @@ export class LiveAccountSync {
         }
     }
 }
-//# sourceMappingURL=live-account-sync.js.map

package/dist/lib/local-bridge.js

@@ -320,4 +320,3 @@ export async function startLocalBridge(options) {
         },
     };
 }
-//# sourceMappingURL=local-bridge.js.map

package/dist/lib/local-client-tokens.js

@@ -250,4 +250,3 @@ export async function verifyLocalClientBearerToken(authorizationHeader, now = Da
 export function resetLocalClientTokenWriteQueueForTests() {
     writeQueue = Promise.resolve();
 }
-//# sourceMappingURL=local-client-tokens.js.map

package/dist/lib/logger.js

@@ -447,4 +447,3 @@ export function getRequestId() {
     return requestCounter;
 }
 export { formatDuration, maskEmail, maskString, maskToken, sanitizeValue };
-//# sourceMappingURL=logger.js.map

package/dist/lib/model-capability-matrix.js

@@ -89,4 +89,3 @@ export function buildModelCapabilityMatrix(input) {
         entries,
     };
 }
-//# sourceMappingURL=model-capability-matrix.js.map

package/dist/lib/named-backup-export.js

@@ -204,4 +204,3 @@ export async function exportNamedBackupFile(name, dependencies, options) {
         inFlightNamedBackupExports.delete(exportKey);
     }
 }
-//# sourceMappingURL=named-backup-export.js.map

package/dist/lib/oc-chatgpt-import-adapter.js

@@ -519,4 +519,3 @@ export function previewOcChatgptImportMerge(options) {
         activeSelectionBehavior: "preserve-destination",
     };
 }
-//# sourceMappingURL=oc-chatgpt-import-adapter.js.map

package/dist/lib/oc-chatgpt-orchestrator.js

@@ -186,4 +186,3 @@ export async function runNamedBackupExport(options) {
         return { kind: "error", path, error };
     }
 }
-//# sourceMappingURL=oc-chatgpt-orchestrator.js.map

package/dist/lib/oc-chatgpt-target-detection.js

@@ -324,4 +324,3 @@ export function detectOcChatgptMultiAuthTarget(options) {
         })),
     };
 }
-//# sourceMappingURL=oc-chatgpt-target-detection.js.map

package/dist/lib/parallel-probe.js

@@ -152,4 +152,3 @@ export function createProbeCandidates(accounts) {
         controller: new AbortController(),
     }));
 }
-//# sourceMappingURL=parallel-probe.js.map

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

@@ -175,4 +175,3 @@ export function createRuntimeUsageRecorder(input) {
         },
     };
 }
-//# sourceMappingURL=runtime-policy.js.map

package/dist/lib/preemptive-quota-scheduler.js

@@ -230,4 +230,3 @@ export class PreemptiveQuotaScheduler {
         return removed;
     }
 }
-//# sourceMappingURL=preemptive-quota-scheduler.js.map

package/dist/lib/proactive-refresh.js

@@ -160,4 +160,3 @@ export function applyRefreshResult(account, result) {
     }
     account.email = sanitizeEmail(extractAccountEmail(result.access)) ?? account.email;
 }
-//# sourceMappingURL=proactive-refresh.js.map

package/dist/lib/prompts/codex-host-bridge.js

@@ -166,4 +166,3 @@ export const CODEX_HOST_BRIDGE_META = {
         "Git protocols (in Codex)",
     ],
 };
-//# sourceMappingURL=codex-host-bridge.js.map

package/dist/lib/prompts/codex.d.ts

@@ -1,19 +1,11 @@
-import { type PromptModelFamily } from "../request/helpers/model-map.js";
+import { type ModelFamily } from "../request/helpers/model-map.js";
 /**
  * Clear the memory cache - exposed for testing
  * @internal
  */
 export declare function __clearCacheForTesting(): void;
-/**
- * Model family type for prompt selection
- * Maps to different system prompts in the Codex CLI
- */
-export type ModelFamily = PromptModelFamily;
-/**
- * All supported model families
- * Used for per-family account rotation and rate limit tracking
- */
-export declare const MODEL_FAMILIES: readonly ModelFamily[];
+export { MODEL_FAMILIES } from "../request/helpers/model-map.js";
+export type { ModelFamily } from "../request/helpers/model-map.js";
 /**
  * Determine the prompt family based on the effective model name.
  *

package/dist/lib/prompts/codex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../../lib/prompts/codex.ts"],"names":[],"mappings":"AAOA,OAAO,EAAkC,KAAK,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AA2EzG;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAI7C;AAWD;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,iBAAiB,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,WAAW,EAMvC,CAAC;AAyBX;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,eAAe,EAAE,MAAM,GAAG,WAAW,CAEnE;AA4ED;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACzC,eAAe,SAAgB,GAC7B,OAAO,CAAC,MAAM,CAAC,CAkHjB;AA6GD;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,GAAE,MAAM,EAAO,GAAG,IAAI,CAiBpE;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,ozGA+EV,CAAC"}
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../../lib/prompts/codex.ts"],"names":[],"mappings":"AAOA,OAAO,EAAkC,KAAK,WAAW,EAAE,MAAM,iCAAiC,CAAC;AA2EnG;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAI7C;AAcD,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,YAAY,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAyBnE;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,eAAe,EAAE,MAAM,GAAG,WAAW,CAEnE;AA4ED;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACzC,eAAe,SAAgB,GAC7B,OAAO,CAAC,MAAM,CAAC,CAkHjB;AA6GD;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,GAAE,MAAM,EAAO,GAAG,IAAI,CAiBpE;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,ozGA+EV,CAAC"}

package/dist/lib/prompts/codex.js

@@ -77,17 +77,10 @@ function setCacheEntry(key, value) {
     }
     memoryCache.set(key, value);
 }
-/**
- * All supported model families
- * Used for per-family account rotation and rate limit tracking
- */
-export const MODEL_FAMILIES = [
-    "gpt-5-codex",
-    "codex-max",
-    "codex",
-    "gpt-5.2",
-    "gpt-5.1",
-];
+// ModelFamily/MODEL_FAMILIES live in the leaf model-map module so low-level
+// modules (schemas, storage types) can use them without importing this file.
+// Re-exported here to preserve the historical import surface.
+export { MODEL_FAMILIES } from "../request/helpers/model-map.js";
 /**
  * Prompt file mapping for each model family
  * Based on codex-rs/core/src/model_family.rs logic
@@ -465,4 +458,3 @@ When hashline_read is available:
 - Never call \`request_user_input\` unless collaboration mode is explicitly Plan mode.
 </safety_rules>
 </user_instructions>`;
-//# sourceMappingURL=codex.js.map

package/dist/lib/prompts/fetch-utils.js

@@ -162,4 +162,3 @@ export async function readBodyTextGuarded(response, maxBytes = PROMPT_FETCH_MAX_
     }
     return text;
 }
-//# sourceMappingURL=fetch-utils.js.map

package/dist/lib/prompts/host-codex-prompt.js

@@ -370,4 +370,3 @@ export function prewarmHostCodexPrompt() {
         logDebug("Codex prompt prewarm failed", { error: String(error) });
     });
 }
-//# sourceMappingURL=host-codex-prompt.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"quota-cache.d.ts","sourceRoot":"","sources":["../../lib/quota-cache.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,gBAAgB;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,SAAS,EAAE,gBAAgB,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc;IAC9B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC7C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CACzC;AA2HD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,cAAc,CAAC,CA4B9D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAiExE"}
+{"version":3,"file":"quota-cache.d.ts","sourceRoot":"","sources":["../../lib/quota-cache.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,gBAAgB;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,SAAS,EAAE,gBAAgB,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc;IAC9B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC7C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CACzC;AAsGD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,cAAc,CAAC,CA4B9D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CA4DxE"}