+ {quota?.raw?.freebucks && !error && !isLoading && (
+
+ {formatFreebucksHeader(quota.raw.freebucks)}
+
+ )}
{isLoading ? (
diff --git a/src/app/(dashboard)/dashboard/usage/components/ProviderLimits/utils.js b/src/app/(dashboard)/dashboard/usage/components/ProviderLimits/utils.js
index baf34221..f8d8b760 100644
--- a/src/app/(dashboard)/dashboard/usage/components/ProviderLimits/utils.js
+++ b/src/app/(dashboard)/dashboard/usage/components/ProviderLimits/utils.js
@@ -258,6 +258,49 @@ export function formatResetTime(date) {
}
}
+/**
+ * Freebucks account header line — mirrors upstream freebucksHeaderLine:
+ * "10/25 Freebucks daily · resets in 4h 12m · 20 in wallet · $6.50 monthly usage left".
+ * Wallet shown only when non-empty; monthly only when the server sent it
+ * (older servers omit it — showing $0 would read as "nothing left").
+ * @param {{balance: number|null, daily: {limit:number,spent:number,remaining:number,resetAt:string|null}, wallet:{balance:number}, monthly?:{remainingUsd:number,limitUsd:number|null,resetAt:string|null}}} freebucks
+ * @returns {string|null}
+ */
+export function formatFreebucksHeader(freebucks) {
+ if (!freebucks?.daily) return null;
+ const parts = [
+ `${Math.max(0, Math.round(freebucks.daily.remaining))}/${Math.max(0, Math.round(freebucks.daily.limit))} Freebucks daily`,
+ ];
+ const countdown = formatResetTime(freebucks.daily.resetAt);
+ if (countdown !== "-") parts.push(`resets in ${countdown}`);
+ if (Number(freebucks.wallet?.balance) > 0) {
+ parts.push(`${Math.max(0, Math.round(freebucks.wallet.balance))} in wallet`);
+ }
+ if (freebucks.monthly && Number.isFinite(Number(freebucks.monthly.remainingUsd))) {
+ parts.push(`${formatFreebucksUsd(freebucks.monthly.remainingUsd)} monthly usage left`);
+ }
+ return parts.join(" · ");
+}
+
+/**
+ * "$25", "$4.20", "$0" — whole dollars until the figure is small enough that
+ * the cents are the story. Mirrors upstream formatAllowanceUsd.
+ */
+export function formatFreebucksUsd(usd) {
+ const safe = Math.max(0, Number(usd));
+ if (safe >= 10) return `$${Math.round(safe)}`;
+ if (safe >= 1) return `$${safe.toFixed(1).replace(/\.0$/, "")}`;
+ return `$${safe.toFixed(2)}`;
+}
+
+/**
+ * "15 Freebucks/hr" — a bare number would read as dollars; the unit is the
+ * hour, not the message.
+ */
+export function formatFreebucksPrice(price) {
+ return `${Math.max(0, Math.round(Number(price) || 0))} Freebucks/hr`;
+}
+
/**
* Get Tailwind color class based on percentage
* @param {number} percentage - Remaining percentage (0-100)
@@ -545,6 +588,8 @@ export function parseQuotaData(provider, data) {
case "freebuff":
// Session quotas keyed by model id — label rows with the friendly
// displayName (from the registry) and keep modelKey for ordering.
+ // Metered rows carry the live Freebucks price (price) + promo tagline
+ // (priceNote), both server-authoritative.
if (data.quotas) {
Object.entries(data.quotas).forEach(([modelKey, quota]) => {
normalizedQuotas.push({
@@ -554,6 +599,8 @@ export function parseQuotaData(provider, data) {
total: quota.total || 0,
resetAt: quota.resetAt || null,
recurring: quota.recurring !== false,
+ price: quota.price,
+ priceNote: quota.priceNote,
});
});
}
diff --git a/src/sse/services/auth.js b/src/sse/services/auth.js
index 53094973..ec28b194 100644
--- a/src/sse/services/auth.js
+++ b/src/sse/services/auth.js
@@ -287,9 +287,15 @@ export async function markAccountUnavailable(connectionId, status, errorText, pr
} else if (resetsAtMs && resetsAtMs > Date.now()) {
shouldFallback = true;
// Antigravity quota API provides exact per-model resetAt. Do not truncate it.
- cooldownMs = resolveProviderId(provider) === "antigravity"
+ // Freebucks exhaustion is likewise a hard stop until the daily Pacific
+ // reset (up to ~24h) — skip the account for the day rather than re-poke it
+ // every 30 min; guard at 26h so a bad server value can't lock forever.
+ const providerId = resolveProviderId(provider);
+ cooldownMs = providerId === "antigravity"
? resetsAtMs - Date.now()
- : Math.min(resetsAtMs - Date.now(), MAX_RATE_LIMIT_COOLDOWN_MS);
+ : providerId === "freebuff"
+ ? Math.min(resetsAtMs - Date.now(), 26 * 60 * 60 * 1000)
+ : Math.min(resetsAtMs - Date.now(), MAX_RATE_LIMIT_COOLDOWN_MS);
newBackoffLevel = 0;
} else {
({ shouldFallback, cooldownMs, newBackoffLevel } = checkFallbackError(status, errorText, backoffLevel));
diff --git a/tests/unit/freebuff-provider.test.js b/tests/unit/freebuff-provider.test.js
index 51cbf2b9..8489572f 100644
--- a/tests/unit/freebuff-provider.test.js
+++ b/tests/unit/freebuff-provider.test.js
@@ -294,6 +294,50 @@ describe("freebuff session pre-flight", () => {
);
});
+ it("rate_limited with a resetAt locks the account until the daily Pacific reset (skip the day, not retry loops)", async () => {
+ const resetAt = "2099-01-01T00:00:00.000Z";
+ fetchMock.mockResolvedValue(
+ jsonResponse({
+ status: "rate_limited",
+ resetAt,
+ retryAfterMs: 1234,
+ freebucksShortfall: { price: 15, balance: 0 },
+ message: "Freebucks exhausted",
+ }),
+ );
+ await expect(requestSession("tok-1", "deepseek/deepseek-v4-flash", null)).rejects.toMatchObject({
+ status: 429,
+ resetsAtMs: Date.parse(resetAt),
+ });
+ });
+
+ it("spend_limited falls back to retryAfterMs when resetAt is absent", async () => {
+ const retryAfterMs = 90 * 60 * 1000;
+ fetchMock.mockResolvedValue(
+ jsonResponse({ status: "spend_limited", retryAfterMs, message: "daily spend cap" }),
+ );
+ const before = Date.now();
+ try {
+ await requestSession("tok-1", "deepseek/deepseek-v4-flash", null);
+ throw new Error("should have rejected");
+ } catch (error) {
+ expect(error.status).toBe(429);
+ expect(error.resetsAtMs).toBeGreaterThanOrEqual(before + retryAfterMs - 1000);
+ expect(error.resetsAtMs).toBeLessThanOrEqual(before + retryAfterMs + 1000);
+ }
+ });
+
+ it("rate_limited without any reset hint stays a plain error (transient cooldown path)", async () => {
+ fetchMock.mockResolvedValue(jsonResponse({ status: "rate_limited", message: "busy" }));
+ try {
+ await requestSession("tok-1", "deepseek/deepseek-v4-flash", null);
+ throw new Error("should have rejected");
+ } catch (error) {
+ expect(error.status).toBeUndefined();
+ expect(error.resetsAtMs).toBeUndefined();
+ }
+ });
+
it("throws a friendly error on country_blocked", async () => {
fetchMock.mockResolvedValue(jsonResponse({ status: "country_blocked" }));
await expect(ensureSession("tok-1", "deepseek/deepseek-v4-flash", null)).rejects.toThrow(
diff --git a/tests/unit/freebuff-usage.test.js b/tests/unit/freebuff-usage.test.js
index 71ffb3db..fbf99c84 100644
--- a/tests/unit/freebuff-usage.test.js
+++ b/tests/unit/freebuff-usage.test.js
@@ -119,6 +119,115 @@ describe("getUsageForProvider(freebuff)", () => {
});
});
+ it("reports the Freebucks daily pool under each priced model for metered accounts (no rateLimitsByModel)", async () => {
+ proxyAwareFetch.mockResolvedValueOnce(
+ jsonResponse({
+ status: "none",
+ accessTier: "limited",
+ rateLimitsByModel: {},
+ freebucks: {
+ balance: 10,
+ daily: { limit: 25, spent: 15, remaining: 10, resetAt: "2026-09-08T07:00:00.000Z" },
+ wallet: { balance: 0, monthlyBonus: 0 },
+ spend: { limitUsd: 4, resetAt: "2026-09-08T07:00:00.000Z" },
+ monthly: { limitUsd: 10, spentUsd: 3.5, remainingUsd: 6.5, resetAt: "2026-10-01T07:00:00.000Z" },
+ planId: null,
+ prices: { "deepseek/deepseek-v4-flash": 15, "z-ai/glm-5.3-flash": 5 },
+ },
+ }),
+ );
+
+ const usage = await getUsageForProvider({
+ provider: "freebuff",
+ accessToken: "tok-1",
+ });
+
+ expect(usage.message).toBeUndefined();
+ expect(usage.quotas["deepseek/deepseek-v4-flash"]).toMatchObject({
+ used: 15,
+ total: 25,
+ resetAt: "2026-09-08T07:00:00.000Z",
+ recurring: true,
+ unlimited: false,
+ price: 15,
+ displayName: "DeepSeek V4 Flash",
+ });
+ expect(usage.quotas["z-ai/glm-5.3-flash"]).toMatchObject({
+ used: 15,
+ total: 25,
+ price: 5,
+ displayName: "GLM 5.3 Flash",
+ });
+ // No session pools → only the freebucks-derived rows exist.
+ expect(Object.keys(usage.quotas)).toEqual([
+ "deepseek/deepseek-v4-flash",
+ "z-ai/glm-5.3-flash",
+ ]);
+ // Account summary rides the response for the card header (server data,
+ // nothing hardcoded client-side).
+ expect(usage.freebucks).toEqual({
+ balance: 10,
+ daily: {
+ limit: 25,
+ spent: 15,
+ remaining: 10,
+ resetAt: "2026-09-08T07:00:00.000Z",
+ },
+ wallet: { balance: 0 },
+ monthly: { remainingUsd: 6.5, limitUsd: 10, resetAt: "2026-10-01T07:00:00.000Z" },
+ });
+ });
+
+ it("folds the server's announced priceChanges into the live price (promos expire without a client release)", async () => {
+ proxyAwareFetch.mockResolvedValueOnce(
+ jsonResponse({
+ status: "none",
+ accessTier: "full",
+ rateLimitsByModel: {},
+ freebucks: {
+ balance: 20,
+ daily: { limit: 25, spent: 5, remaining: 20, resetAt: "2026-09-08T07:00:00.000Z" },
+ wallet: { balance: 0, monthlyBonus: 0 },
+ planId: null,
+ prices: { "upstage/solar-pro4": 0 },
+ priceNotices: { "upstage/solar-pro4": "0 Freebucks · Labor Day weekend (through Sep 7 PT)" },
+ priceChanges: [
+ {
+ at: "2026-01-01T00:00:00.000Z", // already due
+ modelId: "upstage/solar-pro4",
+ price: 5,
+ tagline: "Limited-time trial",
+ },
+ ],
+ },
+ }),
+ );
+
+ const usage = await getUsageForProvider({
+ provider: "freebuff",
+ accessToken: "tok-1",
+ });
+
+ // The due change is folded in: price 5 + new tagline, schedule emptied.
+ expect(usage.quotas["upstage/solar-pro4"]).toMatchObject({
+ price: 5,
+ priceNote: "Limited-time trial",
+ displayName: "Solar Pro 4",
+ });
+ });
+
+ it("attaches no price to legacy session-quota rows", async () => {
+ proxyAwareFetch.mockResolvedValueOnce(jsonResponse(PRE_JOIN));
+
+ const usage = await getUsageForProvider({
+ provider: "freebuff",
+ accessToken: "tok-1",
+ });
+
+ expect(usage.quotas["deepseek/deepseek-v4-flash"].price).toBeUndefined();
+ expect(usage.freebucks).toBeUndefined();
+ });
+
it("surfaces a re-login message on 401", async () => {
proxyAwareFetch.mockResolvedValueOnce(jsonResponse({ error: "unauthorized" }, 401));