@love-moon/ai-sdk 0.7.4 → 0.7.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @love-moon/ai-sdk
 
+## 0.7.5
+
+### Patch Changes
+
+- f91a5df: Read Codex weekly quota from the official app-server account rate-limit RPC, ignore model-specific buckets, and invalidate legacy response-header caches.
+
 ## 0.7.4
 
 ### Patch Changes

package/dist/manager/quota/codex.d.ts

@@ -7,25 +7,28 @@ export interface GetCodexQuotaOptions {
     forceRefresh?: boolean;
     /** Request timeout in ms. */
     timeoutMs?: number;
-    /** Model name; defaults to the one in ~/.codex/config.toml, then `gpt-5`. */
+    /** @deprecated Quota is account-scoped and no longer fetched through a model response. */
     model?: string;
-    /** Override path to codex config.toml (to detect model). */
+    /** @deprecated The Codex app-server reads its own config from CODEX_HOME. */
     codexConfigPath?: string;
     /** Override cache directory (mainly for tests). */
     cacheDir?: string;
+    /** Override the app-server reader (tests only). */
+    rateLimitsReader?: (options: {
+        codexAuthPath: string;
+        timeoutMs: number;
+    }) => Promise<unknown>;
 }
-/** Exported for protocol compatibility tests. */
-export declare function parseCodexHeaders(map: Record<string, string>, extras: {
+/** Normalize Codex app-server `account/rateLimits/read` into the manager shape. */
+export declare function parseCodexRateLimitsResponse(response: unknown, extras?: {
     email?: string;
     accountId?: string;
 }): Omit<CodexQuota, "tool" | "fetchedAt" | "source">;
 export declare function getCodexQuota(opts?: GetCodexQuotaOptions): Promise<CodexQuota>;
 /**
  * Read the on-disk quota cache for a given codex auth.json without triggering
- * any network call. Returns whatever snapshot was last written (regardless of
- * age) or `null` if nothing has been cached for this identity yet. Used by the
- * daemon's `list_accounts` handler to surface "last known" quota for inactive
- * accounts so the web UI can restore them across page refreshes.
+ * any network call. Only app-server snapshots are considered; legacy caches
+ * from response headers are intentionally ignored.
  */
 export declare function readCachedCodexQuota(codexAuthPath: string, opts?: {
     cacheDir?: string;

package/dist/manager/quota/codex.js

@@ -1,77 +1,72 @@
-import { readFile } from "node:fs/promises";
+import { basename, dirname } from "node:path";
 import { parseAuthFile } from "../auth-parser.js";
-import { DEFAULT_CODEX_AUTH, DEFAULT_CODEX_CONFIG } from "../paths.js";
-import { bool, headersToMap, num, str } from "./headers.js";
+import { DEFAULT_CODEX_AUTH } from "../paths.js";
+import { CodexAppServerTransport } from "../../transports/codex-app-server-transport.js";
 import { cacheFile, fingerprintKey, isFresh, readCache, writeCache } from "./cache.js";
-/** Best-effort: read the configured model from ~/.codex/config.toml. */
-async function readConfiguredModel(path) {
-    try {
-        const raw = await readFile(path, "utf8");
-        // Minimal top-level key scan: `model = "..."` (skip lines inside [tables]).
-        let inRootTable = true;
-        for (const line of raw.split(/\r?\n/)) {
-            const trimmed = line.trim();
-            if (trimmed.startsWith("#") || trimmed === "")
-                continue;
-            if (/^\[/.test(trimmed)) {
-                inRootTable = false;
-                continue;
-            }
-            if (!inRootTable)
-                continue;
-            const m = /^model\s*=\s*"([^"]+)"/.exec(trimmed);
-            if (m)
-                return m[1];
-        }
-    }
-    catch {
-        // ignore
-    }
-    return undefined;
-}
-const RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
 const DEFAULT_TTL = 60; // seconds
 const DEFAULT_TIMEOUT_MS = 15000;
-function windowFromHeaders(map, prefix) {
-    const suffixes = [
-        "used-percent",
-        "reset-after-seconds",
-        "reset-at",
-        "window-minutes",
-    ];
-    if (!suffixes.some((suffix) => map[`${prefix}-${suffix}`] !== undefined)) {
+const WEEKLY_WINDOW_MINUTES = 7 * 24 * 60;
+// The old cache was populated from /backend-api/codex/responses headers. Keep
+// the new app-server snapshots in a separate namespace so an upgrade cannot
+// surface a model-specific response limit as the account's weekly limit.
+const CACHE_TOOL = "codex-app-server";
+function finiteNumber(value) {
+    if (typeof value !== "number" && (typeof value !== "string" || !value.trim())) {
         return undefined;
     }
-    const usedPercent = num(map, `${prefix}-used-percent`) ?? 0;
+    const parsed = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function quotaWindow(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const usedPercent = finiteNumber(value.usedPercent);
+    if (usedPercent === undefined)
+        return undefined;
+    const resetAt = finiteNumber(value.resetsAt);
+    const now = Math.floor(Date.now() / 1000);
     return {
         usedPercent,
         remainingPercent: Math.max(0, 100 - usedPercent),
-        resetAfterSeconds: num(map, `${prefix}-reset-after-seconds`),
-        resetAt: num(map, `${prefix}-reset-at`),
-        windowMinutes: num(map, `${prefix}-window-minutes`),
+        resetAt,
+        resetAfterSeconds: resetAt === undefined ? undefined : Math.max(0, resetAt - now),
+        windowMinutes: finiteNumber(value.windowDurationMins),
     };
 }
-/** Exported for protocol compatibility tests. */
-export function parseCodexHeaders(map, extras) {
-    const primary = windowFromHeaders(map, "x-codex-primary");
-    const secondary = windowFromHeaders(map, "x-codex-secondary");
-    // Codex CLI 0.144 removed the 5h limit. Its only Codex window is now the
-    // 10080-minute weekly window in `primary`, with `secondary` absent. Older
-    // responses used primary=5h and secondary=weekly, so prefer an explicitly
-    // weekly-sized window and then fall back to the legacy secondary position.
-    const weekly = [primary, secondary].find((window) => (window?.windowMinutes ?? 0) >= 7 * 24 * 60) ?? secondary ?? primary ?? { usedPercent: 0, remainingPercent: 0 };
+/** Normalize Codex app-server `account/rateLimits/read` into the manager shape. */
+export function parseCodexRateLimitsResponse(response, extras = {}) {
+    const payload = response && typeof response === "object"
+        ? response
+        : {};
+    // `rateLimits` is the official backward-compatible account bucket. Do not
+    // pick a model-specific entry from rateLimitsByLimitId: e.g. Spark can have
+    // a different weekly percentage from the main Codex account limit.
+    const snapshot = payload.rateLimits && typeof payload.rateLimits === "object"
+        ? payload.rateLimits
+        : undefined;
+    const windows = [quotaWindow(snapshot?.primary), quotaWindow(snapshot?.secondary)];
+    const weekly = windows.find((window) => (window?.windowMinutes ?? 0) >= WEEKLY_WINDOW_MINUTES);
+    const credits = snapshot?.credits && typeof snapshot.credits === "object"
+        ? {
+            hasCredits: snapshot.credits.hasCredits === true,
+            balance: nonEmptyString(snapshot.credits.balance),
+            unlimited: snapshot.credits.unlimited === true,
+        }
+        : undefined;
+    const limitId = nonEmptyString(snapshot?.limitId);
+    const limitName = nonEmptyString(snapshot?.limitName);
     return {
-        plan: str(map, "x-codex-plan-type"),
-        activeLimit: str(map, "x-codex-active-limit"),
+        plan: nonEmptyString(snapshot?.planType),
+        activeLimit: limitName ?? limitId,
         weekly,
-        credits: {
-            hasCredits: bool(map, "x-codex-credits-has-credits") ?? false,
-            balance: str(map, "x-codex-credits-balance"),
-            unlimited: bool(map, "x-codex-credits-unlimited") ?? false,
-        },
+        credits,
         email: extras.email,
         accountId: extras.accountId,
-        raw: Object.fromEntries(Object.entries(map).filter(([k]) => k.startsWith("x-codex-"))),
+        raw: payload,
+        ...(!weekly ? { error: "Codex rate-limit response has no weekly window" } : {}),
     };
 }
 export async function getCodexQuota(opts = {}) {
@@ -82,81 +77,75 @@ export async function getCodexQuota(opts = {}) {
     if (!authInfo.accessToken) {
         return emptyQuota("unknown", "codex auth.json missing access_token");
     }
-    const fp = fingerprintKey(["codex", authInfo.identityFingerprint ?? "unknown"]);
-    const file = cacheFile("codex", fp, opts.cacheDir);
+    const fp = fingerprintKey([CACHE_TOOL, authInfo.identityFingerprint ?? "unknown"]);
+    const file = cacheFile(CACHE_TOOL, fp, opts.cacheDir);
     if (!opts.forceRefresh && ttl > 0) {
         const cached = await readCache(file);
         if (isFresh(cached, ttl) && cached) {
-            return { ...withoutLegacyFiveHour(cached.value), source: "cached" };
+            return { ...cached.value, source: "cached" };
         }
     }
-    const model = opts.model ??
-        (await readConfiguredModel(opts.codexConfigPath ?? DEFAULT_CODEX_CONFIG)) ??
-        "gpt-5";
-    const body = JSON.stringify({
-        model,
-        instructions: "Reply with exactly one character.",
-        input: [
-            { type: "message", role: "user", content: [{ type: "input_text", text: "." }] },
-        ],
-        stream: true,
-        store: false,
-    });
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    let res;
+    let response;
     try {
-        res = await fetch(RESPONSES_URL, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${authInfo.accessToken}`,
-                "Content-Type": "application/json",
-                "OpenAI-Beta": "responses=experimental",
-                ...(authInfo.accountId ? { "chatgpt-account-id": authInfo.accountId } : {}),
-            },
-            body,
-            signal: controller.signal,
+        response = await (opts.rateLimitsReader ?? readCodexRateLimits)({
+            codexAuthPath,
+            timeoutMs,
         });
     }
-    catch (err) {
-        clearTimeout(timer);
-        return await fallbackFromCache(file, ttl, err?.message ?? String(err));
-    }
-    // Abort the body stream immediately once headers are in; they're all we need.
-    try {
-        await res.body?.cancel();
-    }
-    catch {
-        // ignore
-    }
-    clearTimeout(timer);
-    const map = headersToMap(res.headers);
-    if (res.status === 401 || res.status === 403) {
-        return await fallbackFromCache(file, ttl, `auth failed: HTTP ${res.status}`);
+    catch (error) {
+        return fallbackFromCache(file, ttl, errorMessage(error));
     }
-    const parsed = parseCodexHeaders(map, {
+    const parsed = parseCodexRateLimitsResponse(response, {
         email: authInfo.email,
         accountId: authInfo.accountId,
     });
-    const now = Math.floor(Date.now() / 1000);
+    if (!parsed.weekly) {
+        return fallbackFromCache(file, ttl, parsed.error ?? "Codex weekly quota unavailable");
+    }
     const fresh = {
         tool: "codex",
-        fetchedAt: now,
+        fetchedAt: Math.floor(Date.now() / 1000),
         source: "fresh",
         ...parsed,
     };
-    // Only persist if we actually got rate-limit headers — otherwise the upstream was unhealthy.
-    if (Object.keys(fresh.raw ?? {}).length > 0) {
-        await writeCache(file, fresh);
-        return fresh;
+    await writeCache(file, fresh);
+    return fresh;
+}
+async function readCodexRateLimits(options) {
+    if (basename(options.codexAuthPath) !== "auth.json") {
+        throw new Error(`Codex app-server quota requires an active auth.json path; got ${options.codexAuthPath}`);
+    }
+    const transport = new CodexAppServerTransport({
+        env: { CODEX_HOME: dirname(options.codexAuthPath) },
+        ignoreCodexApiKey: true,
+    });
+    try {
+        return await withTimeout(transport.request("account/rateLimits/read"), options.timeoutMs, "Codex account/rateLimits/read timed out");
+    }
+    finally {
+        await transport.close();
+    }
+}
+async function withTimeout(promise, timeoutMs, message) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
     }
-    return await fallbackFromCache(file, ttl, `no x-codex-* headers on HTTP ${res.status}`);
 }
 async function fallbackFromCache(file, ttl, error) {
     const cached = await readCache(file);
     if (cached) {
         return {
-            ...withoutLegacyFiveHour(cached.value),
+            ...cached.value,
             source: isFresh(cached, ttl) ? "cached" : "stale",
             error,
         };
@@ -165,23 +154,21 @@ async function fallbackFromCache(file, ttl, error) {
 }
 /**
  * Read the on-disk quota cache for a given codex auth.json without triggering
- * any network call. Returns whatever snapshot was last written (regardless of
- * age) or `null` if nothing has been cached for this identity yet. Used by the
- * daemon's `list_accounts` handler to surface "last known" quota for inactive
- * accounts so the web UI can restore them across page refreshes.
+ * any network call. Only app-server snapshots are considered; legacy caches
+ * from response headers are intentionally ignored.
  */
 export async function readCachedCodexQuota(codexAuthPath, opts = {}) {
     try {
         const authInfo = await parseAuthFile(codexAuthPath);
         if (!authInfo.identityFingerprint)
             return null;
-        const fp = fingerprintKey(["codex", authInfo.identityFingerprint]);
-        const file = cacheFile("codex", fp, opts.cacheDir);
+        const fp = fingerprintKey([CACHE_TOOL, authInfo.identityFingerprint]);
+        const file = cacheFile(CACHE_TOOL, fp, opts.cacheDir);
         const entry = await readCache(file);
         if (!entry)
             return null;
         return {
-            ...withoutLegacyFiveHour(entry.value),
+            ...entry.value,
             source: "cached",
             fetchedAt: entry.fetchedAt,
         };
@@ -190,9 +177,8 @@ export async function readCachedCodexQuota(codexAuthPath, opts = {}) {
         return null;
     }
 }
-function withoutLegacyFiveHour(quota) {
-    const { fiveHour: _legacyFiveHour, ...current } = quota;
-    return current;
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
 }
 function emptyQuota(source, error) {
     return {
@@ -200,6 +186,5 @@ function emptyQuota(source, error) {
         source,
         error,
         fetchedAt: Math.floor(Date.now() / 1000),
-        weekly: { usedPercent: 0, remainingPercent: 0 },
     };
 }

package/dist/manager/types.d.ts

@@ -37,9 +37,7 @@ export interface CodexQuota {
     tool: "codex";
     plan?: string;
     activeLimit?: string;
-    /** @deprecated Codex CLI 0.144+ no longer exposes a 5h limit. */
-    fiveHour?: QuotaWindow;
-    weekly: QuotaWindow;
+    weekly?: QuotaWindow;
     credits?: {
         hasCredits: boolean;
         balance?: string;
@@ -49,7 +47,7 @@ export interface CodexQuota {
     source: QuotaSource;
     email?: string;
     accountId?: string;
-    raw?: Record<string, string>;
+    raw?: Record<string, unknown>;
     error?: string;
 }
 export interface ClaudeQuota {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -32,12 +32,12 @@
     "zod": "^4.1.5"
   },
   "optionalDependencies": {
-    "@love-moon/chat-web": "^0.7.4"
+    "@love-moon/chat-web": "^0.7.5"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsx": "^4.20.6",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "b9a27b4"
+  "gitCommitId": "702c7c4"
 }