@cortexkit/opencode-openai-auth 1.3.0 → 1.4.0

package/src/tui-compiled/raw/shared/4f36d333d081d040-merge.js

@@ -11,7 +11,7 @@
 // no entry gets an absence record. A pair outside the coverage is never
 // touched, so a header-shaped partial observation (which covers only what it
 // carries) cannot erase a family limit or the budget.
-import { ALL_SCOPE, decodeQuotaMap, entryTime, isQuotaCounters, limitKey, } from "./905bffc0220f43d0-map.js";
+import { ALL_SCOPE, decodeQuotaMap, entryTime, isQuotaCounters, isQuotaCredits, limitKey, } from "./905bffc0220f43d0-map.js";
 /** Thrown by `mergeQuotaObservation` when either argument is malformed. */
 export class QuotaCodecError extends TypeError {
     constructor(message) {
@@ -84,7 +84,8 @@ export function isQuotaObservation(value) {
     if (!coverage.every(isObservedPair))
         return false;
     return ((value.budget === undefined || isObservedBudget(value.budget)) &&
-        (value.counters === undefined || isQuotaCounters(value.counters)));
+        (value.counters === undefined || isQuotaCounters(value.counters)) &&
+        (value.credits === undefined || isQuotaCredits(value.credits)));
 }
 function compareEntries(left, right) {
     if (left.scope !== right.scope)
@@ -110,6 +111,17 @@ function mergeCounters(stored, observed) {
     }
     return counters.size === 0 ? undefined : Object.fromEntries(counters);
 }
+// Credits merge like a single counter: the newer record wins, an equal time
+// applies (the observation applied last wins), and an observation without
+// credits leaves the stored record alone.
+function mergeCredits(stored, observed) {
+    if (observed === undefined)
+        return stored;
+    if (stored !== undefined && observed.checkedAt < stored.checkedAt) {
+        return stored;
+    }
+    return { ...observed };
+}
 /**
  * Applies `observation` to `stored` (undefined for a row with no map yet) and
  * returns the new map. Pure: neither argument is modified. Throws
@@ -166,13 +178,15 @@ export function mergeQuotaObservation(stored, observation) {
             : { scope, label: pair.label, kind: 'retired', retiredAt: at });
     }
     // Keys this module does not recognise are carried over untouched.
-    const { limits: _limits, budget: _budget, counters: _counters, ...unknownKeys } = base;
+    const { limits: _limits, budget: _budget, counters: _counters, credits: _credits, ...unknownKeys } = base;
     const budget = mergeBudget(base.budget, observation.budget, at);
     const counters = mergeCounters(base.counters, observation.counters);
+    const credits = mergeCredits(base.credits, observation.credits);
     return {
         ...unknownKeys,
         limits: [...entries.values()].sort(compareEntries),
         ...(budget === undefined ? {} : { budget }),
         ...(counters === undefined ? {} : { counters }),
+        ...(credits === undefined ? {} : { credits }),
     };
 }

package/src/tui-compiled/raw/shared/81dddd203f1b92a3-quota-writer.js

@@ -0,0 +1,253 @@
+import { resolve } from "node:path";
+import { createLogger } from "./cc9e0702a752cea7-index.js";
+import { isQuotaObservation } from "./d5a8f1061ee2f114-index.js";
+import { applyVaultQuota, mutateVaultRoster, } from "./30f5bc480f31f51c-roster.js";
+// Every consumer of the same file shares one mailbox and one lock waiter.
+const writers = new Map();
+const logger = createLogger('claustrum');
+const COALESCE_MS = 100;
+function writerFor(path) {
+    const key = resolve(path);
+    let writer = writers.get(key);
+    if (!writer) {
+        writer = {
+            path: key,
+            pending: new Map(),
+            listeners: new Set(),
+            wake: new Set(),
+            abort: new AbortController(),
+            failures: 0,
+            draining: false,
+            order: 0,
+        };
+        writers.set(key, writer);
+    }
+    return writer;
+}
+/** Retain the shared writer; the last consumer's close drains it. */
+export function retainVaultQuotaWriter(path, listener) {
+    const writer = writerFor(path);
+    writer.listeners.add(listener);
+    let released;
+    return () => (released ??= (() => {
+        writer.listeners.delete(listener);
+        return writer.listeners.size ? Promise.resolve() : drainVaultQuota(path);
+    })());
+}
+// Split one observation into its independently dated parts: each rate-limit
+// window (scope and label), each covered-but-unread window, the budget, each
+// counter and the credits record. The mailbox keeps the newest of each part on
+// its own, so a later observation that carries only some parts can't erase an
+// older but still newest reading of another part, which is how
+// mergeQuotaObservation treats them on disk. Each key also carries the
+// receipt's identity, so the identity fence still applies to every part.
+function fields(publication) {
+    const result = new Map();
+    const { observation } = publication;
+    const witness = JSON.stringify([
+        publication.routeId,
+        publication.receipt?.credentialId,
+        publication.receipt?.accountIdentitySource,
+        publication.receipt?.expectedAccountIdentity,
+    ]);
+    const add = (key, at, part) => result.set(`${witness}:${key}`, {
+        at,
+        order: 0,
+        publication: { ...publication, observation: part },
+    });
+    const keyFor = (scope, label) => JSON.stringify([scope ?? 'all', label]);
+    const read = new Set();
+    for (const reading of observation.readings ?? []) {
+        const key = keyFor(reading.scope, reading.label);
+        read.add(key);
+        add(key, observation.checkedAt, {
+            checkedAt: observation.checkedAt,
+            readings: [{ ...reading }],
+        });
+    }
+    for (const pair of observation.coverage ?? []) {
+        const key = keyFor(pair.scope, pair.label);
+        if (!read.has(key))
+            add(key, observation.checkedAt, {
+                checkedAt: observation.checkedAt,
+                coverage: [{ ...pair }],
+            });
+    }
+    if (observation.budget)
+        add('budget', observation.checkedAt, {
+            checkedAt: observation.checkedAt,
+            budget: { ...observation.budget },
+        });
+    for (const [name, counter] of Object.entries(observation.counters ?? {})) {
+        add(`counter:${name}`, counter.checkedAt, {
+            checkedAt: observation.checkedAt,
+            counters: { [name]: { ...counter } },
+        });
+    }
+    if (observation.credits)
+        add('credits', observation.credits.checkedAt, {
+            checkedAt: observation.checkedAt,
+            credits: { ...observation.credits },
+        });
+    // Even an empty observation can bind an account proved by its receipt.
+    if (!result.size)
+        add('empty', observation.checkedAt, { checkedAt: observation.checkedAt });
+    return result;
+}
+/** Enqueue without filesystem work; each quota field retains its own receipt fence. */
+export function enqueueVaultQuota(path, publication) {
+    if (!isQuotaObservation(publication.observation))
+        return Promise.resolve(false);
+    const writer = writerFor(path);
+    const account = JSON.stringify([
+        publication.accountIdentity ?? null,
+        publication.accountIdentity === undefined ? publication.routeId : null,
+    ]);
+    const pending = writer.pending.get(account) ?? new Map();
+    for (const [key, field] of fields(publication)) {
+        const previous = pending.get(key);
+        if (!previous || field.at >= previous.at) {
+            field.order = ++writer.order;
+            // A covered disappearance after an unflushed reading is a retirement,
+            // not an absence. Retain just enough history to preserve that distinction.
+            if (field.publication.observation.coverage)
+                field.priorReading = previous?.publication.observation.readings
+                    ? previous.publication
+                    : previous?.priorReading;
+            pending.set(key, field);
+        }
+    }
+    if (pending.size)
+        writer.pending.set(account, pending);
+    for (const listener of writer.listeners)
+        listener(publication);
+    schedule(writer, COALESCE_MS);
+    return Promise.resolve(true);
+}
+function orderedFields(pending) {
+    // Equal observation times are last-enqueue-wins even across different
+    // credentials or account-only readings. Map insertion order cannot prove it.
+    return [...pending.values()]
+        .flatMap((account) => [...account.values()])
+        .sort((a, b) => a.order - b.order);
+}
+/** Overlay uncommitted observations when a consumer reloads the durable roster. */
+export function pendingVaultQuota(path, roster) {
+    const writer = writers.get(resolve(path));
+    if (writer) {
+        for (const field of orderedFields(writer.pending)) {
+            if (field.priorReading)
+                roster = applyVaultQuota(roster, field.priorReading).roster;
+            roster = applyVaultQuota(roster, field.publication).roster;
+        }
+    }
+    return roster;
+}
+function schedule(writer, delay) {
+    if (writer.running ||
+        writer.timer ||
+        !writer.pending.size ||
+        writer.abort.signal.aborted)
+        return;
+    writer.timer = setTimeout(() => {
+        writer.timer = undefined;
+        flush(writer);
+    }, delay);
+    if (!writer.draining)
+        writer.timer.unref?.();
+}
+function flush(writer) {
+    if (writer.running || writer.abort.signal.aborted)
+        return;
+    const batch = new Map([...writer.pending].map(([account, pending]) => [
+        account,
+        new Map(pending),
+    ]));
+    writer.running = (async () => {
+        try {
+            await mutateVaultRoster(writer.path, (current) => {
+                let next = current;
+                for (const field of orderedFields(batch)) {
+                    if (field.priorReading)
+                        next = applyVaultQuota(next, field.priorReading).roster;
+                    next = applyVaultQuota(next, field.publication).roster;
+                }
+                return { ...(next !== current && { next }), result: undefined };
+            }, { signal: writer.abort.signal });
+            for (const [account, fields] of batch) {
+                const pending = writer.pending.get(account);
+                for (const [key, field] of fields) {
+                    // A newer enqueue must survive completion of an older flush.
+                    if (pending?.get(key) === field)
+                        pending.delete(key);
+                }
+                if (!pending?.size)
+                    writer.pending.delete(account);
+            }
+            writer.failures = 0;
+        }
+        catch (error) {
+            if (!writer.abort.signal.aborted && writer.failures++ === 0) {
+                logger.warn('vault quota publication delayed; retrying', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            // Keep the batch in the mailbox, including any fresher fields enqueued meanwhile.
+        }
+        finally {
+            writer.running = undefined;
+            for (const wake of writer.wake)
+                wake();
+            const backoff = writer.failures
+                ? Math.min(5_000, 100 * 2 ** Math.min(writer.failures, 6)) *
+                    (0.5 + Math.random())
+                : COALESCE_MS;
+            schedule(writer, backoff);
+        }
+    })();
+}
+/** Wait at most timeoutMs for detached publication; shutdown loss is acceptable. */
+export async function drainVaultQuota(path, timeoutMs = 1_000) {
+    const key = resolve(path);
+    const writer = writers.get(key);
+    if (!writer)
+        return;
+    writer.draining = true;
+    clearTimeout(writer.timer);
+    writer.timer = undefined;
+    let deadline;
+    let wake;
+    const drained = new Promise((done) => {
+        wake = () => {
+            if (!writer.pending.size || writer.abort.signal.aborted)
+                done();
+        };
+        writer.wake.add(wake);
+        wake();
+    });
+    try {
+        if (writer.pending.size)
+            flush(writer);
+        await Promise.race([
+            drained,
+            new Promise((done) => {
+                deadline = setTimeout(done, Math.max(0, timeoutMs));
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(deadline);
+        if (wake)
+            writer.wake.delete(wake);
+        writer.draining = false;
+        // A still-open consumer owns the mailbox, so another consumer's disposal
+        // must not discard its observations or stop its retries.
+        if (!writer.listeners.size) {
+            writer.abort.abort();
+            clearTimeout(writer.timer);
+            writer.pending.clear();
+            if (writers.get(key) === writer)
+                writers.delete(key);
+        }
+    }
+}

package/src/tui-compiled/raw/shared/905bffc0220f43d0-map.js

@@ -14,6 +14,9 @@
 // reset clock. It is a tri-state: absent (never reported), a reading, or
 // cleared (the provider reported that no budget exists).
 //
+// Provider-named counters and the prepaid credits record sit beside them too,
+// each judged by its own observation time rather than the limits'.
+//
 // The map is plain JSON so the store can persist it without interpreting it.
 /** The scope of a limit that binds every request regardless of model. */
 export const ALL_SCOPE = 'all';
@@ -93,6 +96,18 @@ function isQuotaCounter(value) {
 export function isQuotaCounters(value) {
     return isRecord(value) && Object.values(value).every(isQuotaCounter);
 }
+function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+/** True when `value` is a well-formed prepaid-credits record. */
+export function isQuotaCredits(value) {
+    return (isRecord(value) &&
+        typeof value.hasCredits === 'boolean' &&
+        typeof value.unlimited === 'boolean' &&
+        optional(value, 'balance', isFiniteNumber) &&
+        optional(value, 'overageLimitReached', isBoolean) &&
+        isFiniteNumber(value.checkedAt));
+}
 /** Keep usable counters without letting one malformed count hide a quota map. */
 export function readQuotaCounters(value) {
     if (!isRecord(value))
@@ -102,20 +117,29 @@ export function readQuotaCounters(value) {
         ? undefined
         : Object.fromEntries(entries);
 }
-/** Decode persisted quota, dropping malformed counters but not limit evidence. */
+/**
+ * Decode persisted quota, dropping malformed counters or a malformed credits
+ * record but not limit or budget evidence.
+ */
 export function decodeQuotaMap(value) {
     // A valid map is returned as the same object, so stored quota keeps the
-    // identity it had before counters existed; only a map with a malformed
-    // counter is copied without it.
+    // identity it had before counters and credits existed. A map with a
+    // malformed counter or credits record is copied with those malformed
+    // fields left out.
     if (isQuotaMap(value))
         return value;
     if (!isRecord(value))
         return undefined;
-    const { counters: rawCounters, ...rest } = value;
+    const { counters: rawCounters, credits: rawCredits, ...rest } = value;
     if (!isQuotaMap(rest))
         return undefined;
     const counters = readQuotaCounters(rawCounters);
-    return { ...rest, ...(counters === undefined ? {} : { counters }) };
+    const credits = isQuotaCredits(rawCredits) ? rawCredits : undefined;
+    return {
+        ...rest,
+        ...(counters === undefined ? {} : { counters }),
+        ...(credits === undefined ? {} : { credits }),
+    };
 }
 /**
  * True when `value` is a well-formed quota map. Unrecognised top-level keys
@@ -136,5 +160,6 @@ export function isQuotaMap(value) {
         seen.add(key);
     }
     return (optional(value, 'budget', isCreditBudgetEntry) &&
-        optional(value, 'counters', isQuotaCounters));
+        optional(value, 'counters', isQuotaCounters) &&
+        optional(value, 'credits', isQuotaCredits));
 }

package/src/tui-compiled/raw/shared/abd062d633e29fd2-pool-routing.js

@@ -1,8 +1,13 @@
-import { projectQuota } from "./d5a8f1061ee2f114-index.js";
+import {
+  budgetExhaustedResetAt,
+  isQuotaCredits,
+  projectQuota
+} from "./d5a8f1061ee2f114-index.js";
 import {
   admit,
   decideStickyBreak,
   orderForPlacement,
+  QUOTA_STALENESS_MS,
   routeOrdered,
   routeSticky
 } from "./3e7d45a77c6ad4d5-index.js";
@@ -65,6 +70,70 @@ export function waitForFirstQuotaReading(input, waitMs = FIRST_QUOTA_READING_WAI
 function isConfirmedExhaustion(refusal) {
   return refusal.reason === "exhausted" || refusal.reason === "budget-spent";
 }
+export function creditsUsable(credits, now) {
+  if (!isQuotaCredits(credits))
+    return !1;
+  const record = credits;
+  if (!(now - record.checkedAt <= QUOTA_STALENESS_MS))
+    return !1;
+  if (record.overageLimitReached === !0)
+    return !1;
+  if (record.unlimited)
+    return !0;
+  return record.hasCredits && (record.balance === void 0 || record.balance > 0);
+}
+function creditsTiers(rows, input, admission) {
+  const passes = (id) => input.killswitch.get(id) !== !1, free = new Set(admission.admitted.filter((row) => row.lastPath !== !0 && passes(row.id)).map((row) => row.id)), refusals = new Map(admission.refused.map((refusal) => [refusal.id, refusal])), credits = rows.filter((row) => {
+    if (row.kind !== "oauth" || !passes(row.id))
+      return !1;
+    if (refusals.get(row.id)?.reason !== "exhausted")
+      return !1;
+    const projection = projectQuota(row.quota);
+    if (budgetExhaustedResetAt(projection, input.now))
+      return !1;
+    return creditsUsable(projection.credits, input.now);
+  }).map((row) => row.id);
+  return { free, credits };
+}
+function admitQuietly(input, rows = input.rows) {
+  return admit({
+    rows,
+    now: input.now,
+    rateLimitMarks: input.rateLimitMarks,
+    refreshBackoff: input.refreshBackoff,
+    requestPull: () => {}
+  });
+}
+export function creditsFallbackIds(input) {
+  return [...creditsTiers(input.rows, input, admitQuietly(input)).credits];
+}
+
+export class CreditsServing {
+  #ids = new Set;
+  served(input, id, log) {
+    const admission = admitQuietly(input), tiers = creditsTiers(input.rows, input, admission), credits = new Set(tiers.credits);
+    if (tiers.free.has(id)) {
+      this.#ids.clear();
+      return;
+    }
+    for (const marked of [...this.#ids])
+      if (!credits.has(marked))
+        this.#ids.delete(marked);
+    if (!credits.has(id) || this.#ids.has(id))
+      return;
+    this.#ids.add(id);
+    log?.info("serving requests on prepaid credits", {
+      accountId: id,
+      reason: "free quota used up"
+    });
+  }
+  has(id) {
+    return this.#ids.has(id);
+  }
+  ids() {
+    return new Set(this.#ids);
+  }
+}
 export function blockFor(id, admission, killswitch) {
   if (id === void 0)
     return { reason: "no-credential" };
@@ -97,11 +166,13 @@ export function planOrdered(input) {
     refreshBackoff: input.refreshBackoff,
     now: input.now,
     requestPull: input.requestPull
-  }), ids = orderForPlacement(input.rows.map((row) => row.id), placement, mainId), confirmed = new Set(route.admission.refused.filter((refusal) => isConfirmedExhaustion(refusal) && input.killswitch.get(refusal.id) !== !1).map((refusal) => refusal.id)), lastPath = ids.filter((id) => confirmed.has(id));
+  }), ids = orderForPlacement(input.rows.map((row) => row.id), placement, mainId), confirmed = new Set(route.admission.refused.filter((refusal) => isConfirmedExhaustion(refusal) && input.killswitch.get(refusal.id) !== !1).map((refusal) => refusal.id)), lastPath = ids.filter((id) => confirmed.has(id)), tiers = creditsTiers(input.rows, input, route.admission), free = route.order.filter((id) => tiers.free.has(id)), credits = ids.filter((id) => tiers.credits.includes(id));
   if (!replayable) {
-    const hasMain = ids.includes(mainId), target = hasMain ? mainId : route.order[0] ?? lastPath[0];
+    const hasMain = ids.includes(mainId), target = hasMain ? mainId : free[0] ?? credits[0] ?? route.order[0] ?? lastPath[0];
     if (target !== void 0 && route.order.includes(target))
       return { kind: "send", order: [target], lastPath: !1 };
+    if (target !== void 0 && credits.includes(target))
+      return { kind: "send", order: [target], lastPath: !1 };
     if (target !== void 0 && confirmed.has(target))
       return { kind: "send", order: [target], lastPath: !0 };
     return {
@@ -109,6 +180,16 @@ export function planOrdered(input) {
       block: hasMain ? blockFor(mainId, route.admission, input.killswitch) : routeBlock(ids, route.admission, input.killswitch)
     };
   }
+  if (free.length > 0)
+    return { kind: "send", order: free, lastPath: !1 };
+  if (credits.length > 0) {
+    const rest = route.order.length > 0 ? route.order : lastPath;
+    return {
+      kind: "send",
+      order: [...credits, ...rest.filter((id) => !credits.includes(id))],
+      lastPath: !1
+    };
+  }
   if (route.order.length > 0)
     return { kind: "send", order: route.order, lastPath: !1 };
   if (lastPath.length > 0)
@@ -160,23 +241,46 @@ function routePoolSticky(input, options, extra) {
   });
 }
 export function selectStickyRow(input, options, exclude, pendingBytes) {
-  const route = routePoolSticky(input, options, { exclude, pendingBytes });
-  if (route.outcome !== "dispatch" || route.source === "pin")
-    return;
-  return {
+  const route = routePoolSticky(input, options, { exclude, pendingBytes }), rows = input.rows.filter((row) => !exclude.has(row.id)), tiers = creditsTiers(rows, input, route.admission), selected = route.outcome === "dispatch" && route.source !== "pin" ? {
     accountId: route.accountId,
     source: route.source,
     ...route.quotaCheckedAt === void 0 ? {} : { quotaCheckedAt: route.quotaCheckedAt }
+  } : void 0;
+  if (selected && tiers.free.has(selected.accountId))
+    return selected;
+  const credits = tiers.credits[0];
+  if (credits === void 0)
+    return selected;
+  const checkedAt = projectQuota(rows.find((row) => row.id === credits)?.quota).checkedAt;
+  return {
+    accountId: credits,
+    source: "mode-fallback",
+    ...checkedAt === void 0 ? {} : { quotaCheckedAt: checkedAt }
   };
 }
 export function routePinnedRow(input, options, id) {
-  const killed = input.killswitch.get(id) === !1, route = routePoolSticky(input, options, { pin: id });
+  const killed = input.killswitch.get(id) === !1, move = {
+    kind: "move",
+    reason: killed ? "killswitch" : "exhausted"
+  }, route = routePoolSticky(input, options, { pin: id }), tiers = creditsTiers(input.rows, input, route.admission), onCredits = tiers.credits.includes(id), othersOnCredits = tiers.credits.some((other) => other !== id);
   if (route.outcome === "dispatch") {
-    if (route.pin.action === "assign")
-      return { kind: "move", reason: killed ? "killswitch" : "exhausted" };
-    return route.accountId === id ? { kind: "serve" } : { kind: "detour" };
+    const toLastPath = !tiers.free.has(route.accountId);
+    if (route.pin.action === "assign") {
+      if (toLastPath && onCredits)
+        return { kind: "serve" };
+      return move;
+    }
+    if (route.accountId !== id)
+      return { kind: "detour" };
+    if (toLastPath && othersOnCredits)
+      return move;
+    return { kind: "serve" };
   }
-  const refusal = route.admission.refused.find((entry) => entry.id === id);
+  const refusal = route.admission.refused.find((entry) => entry.id === id), confirmed = killed || refusal !== void 0 && isConfirmedExhaustion(refusal);
+  if (onCredits)
+    return { kind: "serve" };
+  if (othersOnCredits)
+    return confirmed ? move : { kind: "detour" };
   if (!killed && refusal && isConfirmedExhaustion(refusal))
     return { kind: "last-path" };
   return { kind: "none" };

package/src/tui-compiled/raw/shared/bfbdd0f9aae56b47-pool-quota.js

@@ -42,6 +42,17 @@ function budgetFor(snapshot) {
     return { kind: "cleared" };
   return;
 }
+function prepaidCreditsFor(value, checkedAt) {
+  if (!isRecord(value) || typeof value.hasCredits !== "boolean" || typeof value.unlimited !== "boolean")
+    return;
+  return {
+    hasCredits: value.hasCredits,
+    unlimited: value.unlimited,
+    ...finite(value.balance) && value.balance >= 0 ? { balance: value.balance } : {},
+    ...typeof value.overageLimitReached === "boolean" ? { overageLimitReached: value.overageLimitReached } : {},
+    checkedAt
+  };
+}
 export function observationFromSnapshot(snapshot, checkedAt, complete) {
   if (!isRecord(snapshot) || !finite(checkedAt))
     return;
@@ -53,15 +64,16 @@ export function observationFromSnapshot(snapshot, checkedAt, complete) {
     else if (complete)
       coverage.push({ label });
   }
-  const budget = budgetFor(snapshot), credits = snapshot.resetCreditsAvailable, counters = typeof credits === "number" && Number.isSafeInteger(credits) && credits >= 0 ? { resetCredits: { value: credits, checkedAt } } : void 0;
-  if (readings.length === 0 && coverage.length === 0 && !budget && !counters)
+  const budget = budgetFor(snapshot), credits = snapshot.resetCreditsAvailable, counters = typeof credits === "number" && Number.isSafeInteger(credits) && credits >= 0 ? { resetCredits: { value: credits, checkedAt } } : void 0, prepaid = prepaidCreditsFor(snapshot.credits, checkedAt);
+  if (readings.length === 0 && coverage.length === 0 && !budget && !counters && !prepaid)
     return;
   return {
     checkedAt,
     ...readings.length > 0 ? { readings } : {},
     ...coverage.length > 0 ? { coverage } : {},
     ...budget ? { budget } : {},
-    ...counters ? { counters } : {}
+    ...counters ? { counters } : {},
+    ...prepaid ? { credits: prepaid } : {}
   };
 }
 export function windowsFromQuotaMap(map) {