@cjhyy/code-shell-capability-coding 0.9.5 → 0.9.6

package/dist/quota/index.d.ts

@@ -6,14 +6,16 @@
  *            rate_limit.{primary_window,secondary_window}.{used_percent,reset_at}.
  *            Zero cost (no message sent).
  *   - Claude: POST /v1/messages (max_tokens:1) → response headers
- *            anthropic-ratelimit-unified-{5h,7d}-{utilization,reset}.
- *            Costs ~1 output token (Claude exposes quota only via response
- *            headers — there is no standalone usage endpoint).
+ *            anthropic-ratelimit-unified-<window>-{utilization,reset}, where
+ *            <window> is discovered from the headers (5h / 7d / overage / …)
+ *            rather than assumed — see parseClaudeWindows (re-verified
+ *            2026-09-06). Costs ~1 output token (Claude exposes quota only via
+ *            response headers — there is no standalone usage endpoint).
  *
  * The `fetch` and credentials are injected so this is unit-testable offline and
  * so the host owns secret resolution (see types.ts boundary note).
  */
-import type { ProviderQuota, QuotaCredentials, QuotaResult } from "./types.js";
+import type { ProviderQuota, QuotaCredentials, QuotaResult, QuotaWindow } from "./types.js";
 type FetchLike = typeof fetch;
 export interface CheckQuotaOptions {
     creds: QuotaCredentials;
@@ -29,6 +31,20 @@ export interface CheckQuotaOptions {
 export declare function queryCodexQuota(creds: QuotaCredentials, fetchImpl: FetchLike, signal: AbortSignal): Promise<ProviderQuota>;
 /** Claude: POST a 1-token probe and read the unified rate-limit headers. */
 export declare function queryClaudeQuota(creds: QuotaCredentials, fetchImpl: FetchLike, signal: AbortSignal): Promise<ProviderQuota>;
+/**
+ * Discover every rate-limit window from the unified headers.
+ *
+ * Windows are found by PREFIX, not from a hardcoded list, because which ones
+ * the API sends depends on the account. A normal subscription reports 5h + 7d;
+ * an account on overage reports `overage` and omits 5h/7d entirely. Matching a
+ * fixed list is what silently broke this lookup before (see types.ts).
+ *
+ * Each window contributes `<prefix><name>-utilization` (0–1) and an optional
+ * `<prefix><name>-reset` (epoch seconds). Bare `<prefix>reset` / `<prefix>status`
+ * are envelope fields, not windows, so anything without a `-utilization` suffix
+ * is skipped.
+ */
+export declare function parseClaudeWindows(h: Headers): QuotaWindow[];
 /** Query both providers (or the subset requested), concurrently. */
 export declare function checkQuota(opts: CheckQuotaOptions): Promise<QuotaResult>;
 /** Render a QuotaResult as a compact human/agent-readable summary. */

package/dist/quota/index.js

@@ -101,21 +101,68 @@ export async function queryClaudeQuota(creds, fetchImpl, signal) {
             error: `HTTP ${resp.status}${resp.status === 401 ? " (token 可能已过期)" : ""}`,
         };
     }
-    const h = resp.headers;
+    const windows = parseClaudeWindows(resp.headers);
+    if (windows.length === 0)
+        return { provider: "claude", error: "响应头无 rate-limit 字段" };
+    return { provider: "claude", windows };
+}
+const UNIFIED_PREFIX = "anthropic-ratelimit-unified-";
+/**
+ * Map `representative-claim` values onto the window names used in the headers.
+ * The claim spells a window out ("five_hour"); the window headers abbreviate it
+ * ("5h"). An unlisted claim value falls through to an exact `kind` match, which
+ * is how "overage" already lines up.
+ */
+const CLAIM_TO_KIND = {
+    five_hour: "5h",
+    seven_day: "7d",
+    seven_day_sonnet: "7d_sonnet",
+};
+/**
+ * Discover every rate-limit window from the unified headers.
+ *
+ * Windows are found by PREFIX, not from a hardcoded list, because which ones
+ * the API sends depends on the account. A normal subscription reports 5h + 7d;
+ * an account on overage reports `overage` and omits 5h/7d entirely. Matching a
+ * fixed list is what silently broke this lookup before (see types.ts).
+ *
+ * Each window contributes `<prefix><name>-utilization` (0–1) and an optional
+ * `<prefix><name>-reset` (epoch seconds). Bare `<prefix>reset` / `<prefix>status`
+ * are envelope fields, not windows, so anything without a `-utilization` suffix
+ * is skipped.
+ */
+export function parseClaudeWindows(h) {
     const windows = [];
-    const map = [
-        ["anthropic-ratelimit-unified-5h-utilization", "anthropic-ratelimit-unified-5h-reset", "5h"],
-        ["anthropic-ratelimit-unified-7d-utilization", "anthropic-ratelimit-unified-7d-reset", "7d"],
-    ];
-    for (const [utilKey, resetKey, kind] of map) {
-        const util = num(h.get(utilKey)); // 0–1
+    for (const [rawKey, rawVal] of h.entries()) {
+        const key = rawKey.toLowerCase();
+        if (!key.startsWith(UNIFIED_PREFIX) || !key.endsWith("-utilization"))
+            continue;
+        const kind = key.slice(UNIFIED_PREFIX.length, -"-utilization".length);
+        if (!kind)
+            continue; // guard a bare `<prefix>utilization`
+        const util = num(rawVal); // 0–1
         if (util == null)
             continue;
-        windows.push({ kind, usedPercent: util * 100, resetsAt: num(h.get(resetKey)) });
+        windows.push({
+            // Round to 4dp: `0.07 * 100` is 7.000000000000001 in binary float, which
+            // leaks into equality checks and any raw (unformatted) display.
+            kind,
+            usedPercent: Math.round(util * 100 * 1e4) / 1e4,
+            resetsAt: num(h.get(`${UNIFIED_PREFIX}${kind}-reset`)),
+        });
     }
-    if (windows.length === 0)
-        return { provider: "claude", error: "响应头无 rate-limit 字段" };
-    return { provider: "claude", windows };
+    // Stable order so output does not shuffle between identical probes.
+    windows.sort((a, b) => a.kind.localeCompare(b.kind));
+    // Flag the binding window. A request is throttled on this one, so it is what
+    // an orchestrator should plan against when windows disagree.
+    const claim = h.get(`${UNIFIED_PREFIX}representative-claim`)?.trim().toLowerCase();
+    if (claim) {
+        const want = CLAIM_TO_KIND[claim] ?? claim;
+        const hit = windows.find((w) => w.kind === want);
+        if (hit)
+            hit.representative = true;
+    }
+    return windows;
 }
 /** Query both providers (or the subset requested), concurrently. */
 export async function checkQuota(opts) {
@@ -145,17 +192,28 @@ export function formatQuota(result, nowSec) {
         const plan = pq.planType ? ` [${pq.planType}]` : "";
         const parts = pq.windows.map((w) => {
             const reset = w.resetsAt != null ? ` (重置 ${formatReset(w.resetsAt - nowSec)})` : "";
-            return `${w.kind} 用了 ${w.usedPercent.toFixed(0)}%${reset}`;
+            // Star the binding window so a reader/agent knows which one throttles.
+            const star = w.representative ? "*" : "";
+            return `${w.kind}${star} 用了 ${w.usedPercent.toFixed(0)}%${reset}`;
         });
         lines.push(`${name}${plan}: ${parts.join("，")}`);
     }
     return lines.length ? lines.join("\n") : "(无可用额度信息)";
 }
-/** "2h13m" / "45m" / "已重置" from a seconds delta. */
+/**
+ * "3d2h" / "2h13m" / "45m" / "已重置" from a seconds delta.
+ *
+ * The day unit matters: this only ever had to render 5h/7d windows, but an
+ * overage window can reset weeks out, and "606h0m 后" is not a readable way to
+ * say 25 days.
+ */
 function formatReset(deltaSec) {
     if (deltaSec <= 0)
         return "已重置";
-    const h = Math.floor(deltaSec / 3600);
+    const d = Math.floor(deltaSec / 86400);
+    const h = Math.floor((deltaSec % 86400) / 3600);
     const m = Math.floor((deltaSec % 3600) / 60);
+    if (d > 0)
+        return `${d}d${h}h 后`;
     return h > 0 ? `${h}h${m}m 后` : `${m}m 后`;
 }

package/dist/quota/types.d.ts

@@ -10,14 +10,30 @@
  * it from the rest of core. Nothing outside this module should know about
  * Keychain / wham endpoints / `anthropic-ratelimit-*` header names.
  */
-/** A single rolling limit window (e.g. the 5-hour or 7-day window). */
+/**
+ * A single rolling limit window.
+ *
+ * `kind` is NOT a closed set. Claude reports whichever windows apply to the
+ * account: usually "5h" and "7d", but an account running on overage reports an
+ * "overage" window INSTEAD of those (verified 2026-09-06 against a team /
+ * default_claude_max_5x account). New window names appear without notice, so
+ * the parser discovers them from the header prefix rather than matching a
+ * hardcoded list. Renderers must treat `kind` as an opaque label.
+ */
 export interface QuotaWindow {
-    /** Which window this is. */
-    kind: "5h" | "7d";
+    /** Which window this is: "5h" | "7d" | "overage" | any future name. */
+    kind: string;
     /** Percent of the window's limit already used, 0–100. */
     usedPercent: number;
     /** Unix epoch seconds when this window resets, or null if unknown. */
     resetsAt: number | null;
+    /**
+     * True for the window the API named as the binding constraint via
+     * `anthropic-ratelimit-unified-representative-claim`. Claude only; a request
+     * is throttled on THIS window, so it is the one to act on when several
+     * windows disagree.
+     */
+    representative?: boolean;
 }
 /** Quota for one provider (claude | codex). */
 export interface ProviderQuota {

package/dist/tools/check-quota.js

@@ -3,9 +3,11 @@ import { resolveQuotaCredentials } from "../quota/credentials.js";
 export const checkQuotaToolDef = {
     name: "CheckQuota",
     description: "Check remaining usage/rate-limit quota for the external coding-agent CLIs (Claude Code and/or " +
-        "Codex) — the same 5h/7d subscription windows their status lines show. Use before or during " +
+        "Codex) — the same subscription windows their status lines show. Use before or during " +
         "orchestration (DriveAgent) to plan how much work to hand off, whether to wait for a reset, or " +
-        "which provider to use. Returns each provider's 5h/7d used-% and reset time. " +
+        "which provider to use. Returns each window's used-% and reset time. Codex reports 5h/7d; " +
+        "Claude reports whichever windows apply to the account (5h/7d normally, 'overage' when the " +
+        "account is running on overage), and marks the currently binding window with '*'. " +
         "COST: 'codex' is free (reads a usage endpoint). 'claude' costs ~1 token (Anthropic exposes " +
         "quota only via a response header, so this sends a 1-token probe). Pass `provider` to query " +
         "just one and avoid the other's cost/latency.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-capability-coding",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "description": "Coding capability pack for the generic code-shell agent core.",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-core": "0.9.5"
+    "@cjhyy/code-shell-core": "0.9.6"
   },
   "engines": {
     "node": ">=20.10"