@velum-labs/routekit-accounts 0.16.2 → 0.16.4

package/dist/account-set.js

@@ -49,6 +49,63 @@ function parsedRateLimitWindow(value, observedAt, source, migration) {
         source: windowSource
     };
 }
+function parsedResetCredit(value) {
+    if (!isRecord(value) || typeof value.id !== "string" || value.id.length === 0) {
+        return undefined;
+    }
+    return {
+        id: value.id,
+        ...(typeof value.resetType === "string" ? { resetType: value.resetType } : {}),
+        ...(typeof value.status === "string" ? { status: value.status } : {}),
+        ...(typeof value.grantedAt === "number" && Number.isFinite(value.grantedAt)
+            ? { grantedAt: value.grantedAt }
+            : {}),
+        ...(typeof value.expiresAt === "number" && Number.isFinite(value.expiresAt)
+            ? { expiresAt: value.expiresAt }
+            : {}),
+        ...(typeof value.title === "string" ? { title: value.title } : {}),
+        ...(typeof value.description === "string" ? { description: value.description } : {})
+    };
+}
+function parsedResetCreditSnapshot(value, fallbackObservedAt, migration) {
+    if (!isRecord(value) ||
+        typeof value.availableCount !== "number" ||
+        !Number.isFinite(value.availableCount) ||
+        value.availableCount < 0) {
+        return undefined;
+    }
+    let observedAt;
+    if (typeof value.observedAt === "number" && Number.isFinite(value.observedAt)) {
+        observedAt = value.observedAt;
+    }
+    else if (fallbackObservedAt !== undefined) {
+        if (migration !== undefined)
+            migration.required = true;
+        observedAt = fallbackObservedAt;
+    }
+    else {
+        return undefined;
+    }
+    if (value.credits !== undefined && !Array.isArray(value.credits))
+        return undefined;
+    const credits = Array.isArray(value.credits)
+        ? value.credits.flatMap((entry) => {
+            const credit = parsedResetCredit(entry);
+            return credit === undefined ? [] : [credit];
+        })
+        : undefined;
+    if (Array.isArray(value.credits) &&
+        credits !== undefined &&
+        credits.length !== value.credits.length &&
+        migration !== undefined) {
+        migration.required = true;
+    }
+    return {
+        observedAt,
+        availableCount: Math.floor(value.availableCount),
+        ...(credits !== undefined ? { credits } : {})
+    };
+}
 function parsedAccountLimits(value, mode, migration) {
     if (!isRecord(value) ||
         !isRecord(value.windows) ||
@@ -87,13 +144,15 @@ function parsedAccountLimits(value, mode, migration) {
             writable: true
         });
     }
+    const resetCredits = parsedResetCreditSnapshot(value.resetCredits, value.observedAt, migration);
     return {
         windows,
         observedAt: value.observedAt,
         source: value.source,
         completeness,
         ...(typeof value.planType === "string" ? { planType: value.planType } : {}),
-        ...(isRecord(value.credits) ? { credits: value.credits } : {})
+        ...(isRecord(value.credits) ? { credits: value.credits } : {}),
+        ...(resetCredits !== undefined ? { resetCredits } : {})
     };
 }
 function parsedMemberState(value, mode, migration) {
@@ -183,7 +242,8 @@ function mergeLimits(previous, next, mode) {
             });
         }
     }
-    return next.completeness === "snapshot"
+    const resetCredits = next.resetCredits ?? previous?.resetCredits;
+    const merged = next.completeness === "snapshot"
         ? { ...next, windows }
         : {
             ...previous,
@@ -192,6 +252,10 @@ function mergeLimits(previous, next, mode) {
             observedAt: next.observedAt,
             source: next.source
         };
+    return {
+        ...merged,
+        ...(resetCredits !== undefined ? { resetCredits } : {})
+    };
 }
 /**
  * Trackers for one state file share mutable state process-wide. A daemon
@@ -782,7 +846,18 @@ export class SubscriptionAccountSet {
         if (this.#provider.fetchResetCredits === undefined) {
             throw new Error(`${this.mode} does not support redeemable rate-limit resets`);
         }
-        return await this.#provider.fetchResetCredits(member.credential, signal);
+        const resetCredits = await this.#provider.fetchResetCredits(member.credential, signal);
+        const previous = this.#tracker.limits(member.id);
+        this.#tracker.update(member.id, {
+            ...(previous ?? {
+                windows: {},
+                source: "usage",
+                completeness: "partial"
+            }),
+            resetCredits,
+            observedAt: previous?.observedAt ?? resetCredits.observedAt
+        });
+        return resetCredits;
     }
     async #attachResetCredits(member, limits, signal) {
         if (this.#provider.fetchResetCredits === undefined)
@@ -792,7 +867,10 @@ export class SubscriptionAccountSet {
             return { ...limits, resetCredits };
         }
         catch {
-            return limits;
+            // Keep the last authoritative snapshot when the dedicated listing fails.
+            // Do not let a weaker embedded usage payload erase known credit rows.
+            const previous = this.#tracker.limits(member.id)?.resetCredits;
+            return previous === undefined ? limits : { ...limits, resetCredits: previous };
         }
     }
     async #acquire(model, excluded, signal) {

package/dist/provider.js

@@ -285,7 +285,7 @@ function codexUsageLimits(payload, source = "usage", completeness = "snapshot")
                 : {}),
             ...(typeof rawCredits.balance === "string" ? { balance: rawCredits.balance } : {})
         };
-    const resetCredits = codexResetCreditsFromUsage(payload);
+    const resetCredits = codexResetCreditsFromUsage(payload, observedAt);
     return {
         windows,
         ...(typeof payload.plan_type === "string" ? { planType: payload.plan_type } : {}),
@@ -296,7 +296,7 @@ function codexUsageLimits(payload, source = "usage", completeness = "snapshot")
         completeness
     };
 }
-function codexResetCreditsFromUsage(payload) {
+function codexResetCreditsFromUsage(payload, observedAt) {
     const raw = isRecord(payload.rate_limit_reset_credits)
         ? payload.rate_limit_reset_credits
         : isRecord(payload.rateLimitResetCredits)
@@ -315,6 +315,7 @@ function codexResetCreditsFromUsage(payload) {
             .filter((entry) => entry !== undefined)
         : undefined;
     return {
+        observedAt,
         availableCount: Math.max(0, Math.floor(count)),
         ...(credits !== undefined && credits.length > 0 ? { credits } : {})
     };
@@ -353,6 +354,7 @@ function parseResetCredit(value) {
     };
 }
 function parseResetCreditSnapshot(payload) {
+    const observedAt = Date.now() / 1000;
     if (!isRecord(payload))
         throw new Error("Codex reset-credits endpoint returned an invalid payload");
     const rows = Array.isArray(payload.credits)
@@ -373,6 +375,7 @@ function parseResetCreditSnapshot(payload) {
         numeric(payload.availableCount) ??
         available.length;
     return {
+        observedAt,
         availableCount: Math.max(0, Math.floor(count)),
         ...(credits.length > 0 ? { credits } : {})
     };

package/dist/test/subscription-pool.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -46,7 +46,9 @@ function fakeProvider(state, modelsByToken = {}, mode = "codex") {
             };
         },
         async fetchResetCredits() {
-            return state.resetCredits ?? { availableCount: 0, credits: [] };
+            if (state.failResetCredits === true)
+                throw new Error("reset credits unavailable");
+            return state.resetCredits ?? { observedAt: Date.now() / 1000, availableCount: 0, credits: [] };
         },
         async consumeResetCredit(_credential, input) {
             state.consumeCalls = (state.consumeCalls ?? 0) + 1;
@@ -60,12 +62,12 @@ function fakeProvider(state, modelsByToken = {}, mode = "codex") {
                             source: "usage"
                         }
                     },
-                    resetCredits: { availableCount: 0, credits: [] },
+                    resetCredits: { observedAt: Date.now() / 1000, availableCount: 0, credits: [] },
                     observedAt: Date.now() / 1000,
                     source: "usage",
                     completeness: "snapshot"
                 };
-                state.resetCredits = { availableCount: 0, credits: [] };
+                state.resetCredits = { observedAt: Date.now() / 1000, availableCount: 0, credits: [] };
             }
             return {
                 ok: code === "reset",
@@ -1449,6 +1451,7 @@ test("redeeming a banked reset refreshes windows and clears cooling", async () =
                 }
             },
             resetCredits: {
+                observedAt,
                 availableCount: 1,
                 credits: [
                     {
@@ -1463,6 +1466,7 @@ test("redeeming a banked reset refreshes windows and clears cooling", async () =
             completeness: "snapshot"
         },
         resetCredits: {
+            observedAt,
             availableCount: 1,
             credits: [
                 {
@@ -1501,3 +1505,114 @@ test("redeeming a banked reset refreshes windows and clears cooling", async () =
         rmSync(directory, { recursive: true, force: true });
     }
 });
+test("dedicated reset refresh preserves stale state on failure and clears on empty", async () => {
+    const directory = mkdtempSync(join(tmpdir(), "routekit-pool-reset-refresh-"));
+    writeMember(directory, "work", { accessToken: "token-work" });
+    const observedAt = Date.now() / 1000;
+    const detailed = {
+        observedAt,
+        availableCount: 1,
+        credits: [{ id: "RateLimitResetCredit_stale", status: "available", title: "Stale reset" }]
+    };
+    const state = {
+        refreshes: 0,
+        resetCredits: detailed,
+        usageLimits: {
+            windows: {
+                primary: {
+                    utilization: 0.5,
+                    observedAt,
+                    source: "usage"
+                }
+            },
+            // Weaker embedded count-only payload must not win when dedicated listing fails.
+            resetCredits: { observedAt, availableCount: 1 },
+            observedAt,
+            source: "usage",
+            completeness: "snapshot"
+        }
+    };
+    const pool = await SubscriptionAccountSet.open(fakeProvider(state), {
+        mode: "codex",
+        source: { kind: "directory", path: directory }
+    });
+    try {
+        await pool.listResetCredits("work");
+        assert.deepEqual(pool.snapshot().members[0]?.limits?.resetCredits, detailed);
+        state.failResetCredits = true;
+        await pool.probe();
+        assert.deepEqual(pool.snapshot().members[0]?.limits?.resetCredits, detailed);
+        state.failResetCredits = false;
+        state.resetCredits = { observedAt: observedAt + 1, availableCount: 0, credits: [] };
+        await pool.listResetCredits("work");
+        assert.deepEqual(pool.snapshot().members[0]?.limits?.resetCredits, state.resetCredits);
+    }
+    finally {
+        await pool.close();
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
+test("tracker restores fully validated reset credit details", () => {
+    const directory = mkdtempSync(join(tmpdir(), "routekit-tracker-reset-persist-"));
+    const path = join(directory, ".state.json");
+    const observedAt = 1775000000;
+    writeFileSync(path, JSON.stringify({
+        members: [{
+                id: "work",
+                limits: {
+                    windows: {}, observedAt, source: "usage", completeness: "snapshot",
+                    resetCredits: {
+                        observedAt: observedAt + 1,
+                        availableCount: 1,
+                        credits: [{
+                                id: "RateLimitResetCredit_saved", resetType: "codex_rate_limits",
+                                status: "available", grantedAt: observedAt - 10, expiresAt: observedAt + 100,
+                                title: "Saved reset", description: "Persisted details"
+                            }]
+                    }
+                }
+            }]
+    }));
+    try {
+        assert.deepEqual(new RateLimitTracker(path, "codex").limits("work")?.resetCredits, {
+            observedAt: observedAt + 1, availableCount: 1, credits: [{
+                    id: "RateLimitResetCredit_saved", resetType: "codex_rate_limits",
+                    status: "available", grantedAt: observedAt - 10, expiresAt: observedAt + 100,
+                    title: "Saved reset", description: "Persisted details"
+                }]
+        });
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});
+test("tracker migrates legacy reset credits missing observedAt", () => {
+    const directory = mkdtempSync(join(tmpdir(), "routekit-tracker-reset-migrate-"));
+    const path = join(directory, ".state.json");
+    const observedAt = 1775000000;
+    writeFileSync(path, JSON.stringify({
+        members: [{
+                id: "work",
+                limits: {
+                    windows: {}, observedAt, source: "usage", completeness: "snapshot",
+                    resetCredits: {
+                        availableCount: 1,
+                        credits: [{ id: "RateLimitResetCredit_legacy", status: "available" }]
+                    }
+                }
+            }]
+    }));
+    try {
+        const tracker = new RateLimitTracker(path, "codex");
+        assert.deepEqual(tracker.limits("work")?.resetCredits, {
+            observedAt,
+            availableCount: 1,
+            credits: [{ id: "RateLimitResetCredit_legacy", status: "available" }]
+        });
+        const persisted = JSON.parse(readFileSync(path, "utf8"));
+        assert.equal(persisted.members[0]?.limits?.resetCredits?.observedAt, observedAt);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});

package/dist/test/subscription-provider.test.js

@@ -109,6 +109,7 @@ test("Codex adapter parses banked reset credits from usage payloads", async () =
             sourcePath: "/tmp/codex.json"
         });
         assert.equal(limits.resetCredits?.availableCount, 2);
+        assert.equal(typeof limits.resetCredits?.observedAt, "number");
         assert.equal(limits.resetCredits?.credits?.[0]?.id, "RateLimitResetCredit_a");
         assert.equal(limits.windows.primary?.utilization, 0.9);
     }
@@ -161,6 +162,7 @@ test("Codex adapter lists and consumes banked rate-limit resets", async () => {
             sourcePath: "/tmp/codex.json"
         });
         assert.equal(listed.availableCount, 1);
+        assert.equal(typeof listed.observedAt, "number");
         assert.equal(listed.credits?.[0]?.id, "RateLimitResetCredit_b");
         const consumed = await provider.consumeResetCredit({
             mode: "codex",

package/dist/test/subscription-sdk.test.js

@@ -114,6 +114,16 @@ test("the usage wire schema round-trips an account-set snapshot", () => {
                             source: "headers"
                         }
                     },
+                    resetCredits: {
+                        observedAt: 1_776_000_100,
+                        availableCount: 1,
+                        credits: [{
+                                id: "RateLimitResetCredit_wire",
+                                status: "available",
+                                title: "Wire reset",
+                                expiresAt: 1_777_000_000
+                            }]
+                    },
                     observedAt: 1_776_000_000,
                     source: "headers",
                     completeness: "partial"
@@ -128,6 +138,7 @@ test("the usage wire schema round-trips an account-set snapshot", () => {
     assert.equal(parsed.accountSets[0]?.members[0]?.lastSelected, true);
     assert.equal(parsed.accountSets[0]?.members[0]?.lastSelectedAt, 1_776_000_000_000);
     assert.equal(parsed.accountSets[0]?.members[0]?.active, true);
+    assert.equal(parsed.accountSets[0]?.members[0]?.limits?.resetCredits?.credits?.[0]?.id, "RateLimitResetCredit_wire");
     assert.deepEqual(parsed.accountSets[0]?.members[0]?.readinessReasons, snapshot.members[0]?.readinessReasons);
     const older = structuredClone(snapshot);
     delete older.members[0]?.readinessReasons;

package/dist/types.d.ts

@@ -39,6 +39,7 @@ export type ResetCredit = {
     description?: string;
 };
 export type ResetCreditSnapshot = {
+    observedAt: number;
     availableCount: number;
     credits?: ResetCredit[];
 };

package/dist/wire.d.ts

@@ -88,6 +88,7 @@ export declare const subscriptionUsageResponseSchema: z.ZodObject<{
                     balance: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
                 resetCredits: z.ZodOptional<z.ZodObject<{
+                    observedAt: z.ZodNumber;
                     availableCount: z.ZodNumber;
                     credits: z.ZodOptional<z.ZodArray<z.ZodObject<{
                         id: z.ZodString;

package/dist/wire.js

@@ -30,6 +30,7 @@ const resetCreditSchema = z.object({
     description: z.string().optional()
 });
 const resetCreditSnapshotSchema = z.object({
+    observedAt: z.number(),
     availableCount: z.number(),
     credits: z.array(resetCreditSchema).optional()
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-accounts",
   "private": false,
-  "version": "0.16.2",
+  "version": "0.16.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/routekit.git",
@@ -28,10 +28,10 @@
   "dependencies": {
     "yaml": "2.9.0",
     "zod": "4.4.3",
-    "@velum-labs/routekit-contracts": "0.16.2",
-    "@velum-labs/routekit-gateway": "0.16.2",
-    "@velum-labs/routekit-registry": "0.16.2",
-    "@velum-labs/routekit-runtime": "0.16.2"
+    "@velum-labs/routekit-contracts": "0.16.4",
+    "@velum-labs/routekit-gateway": "0.16.4",
+    "@velum-labs/routekit-registry": "0.16.4",
+    "@velum-labs/routekit-runtime": "0.16.4"
   },
   "keywords": [
     "routekit",