@latentminds/pi-quotas 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@latentminds/pi-quotas",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "license": "MIT",
   "type": "module",
   "private": false,

package/src/config.ts

@@ -152,7 +152,7 @@ const FEATURE_META: Array<{
   {
     id: "providerCommands",
     label: "Provider quota commands",
-    description: "Toggle `/anthropic:quotas`, `/codex:quotas`, and `/github:quotas`",
+    description: "Toggle `/anthropic:quotas`, `/codex:quotas`, `/github:quotas`, `/openrouter:quotas`, and `/synthetic:quotas`",
   },
   {
     id: "usageStatus",

package/src/extensions/command-quotas/provider-commands.ts

@@ -34,5 +34,11 @@ export function getProviderCommandInfo(
         commandName: "openrouter:quotas",
         title: "OpenRouter Quotas",
       };
+    case "synthetic":
+      return {
+        provider,
+        commandName: "synthetic:quotas",
+        title: "Synthetic Quotas",
+      };
   }
 }

package/src/extensions/usage-status/format-status.test.ts

@@ -1,5 +1,7 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { formatWindowStatus, type WindowStatus } from "./format-status.js";
+import type { SupportedQuotaProvider } from "../../types/quotas.js";
+import { formatStatus, toWindowStatus } from "./index.js";
 
 // Minimal fake theme that just returns text with markers for color assertions
 function fakeTheme() {
@@ -11,6 +13,10 @@ function fakeTheme() {
 describe("formatWindowStatus", () => {
   const theme = fakeTheme() as any;
 
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
   it("shows remaining/limit for windows with known limits (GitHub premium)", () => {
     const w: WindowStatus = {
       label: "Premium / month",
@@ -101,4 +107,102 @@ describe("formatWindowStatus", () => {
     const result = formatWindowStatus(theme, w);
     expect(result).toContain("[dim]5h:");
   });
+
+  it("renders footer reset times with minute precision for every provider", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-05-06T05:28:37Z"));
+
+    const providers: Array<{ provider: SupportedQuotaProvider; label: string }> = [
+      { provider: "anthropic", label: "5h" },
+      { provider: "openai-codex", label: "7d" },
+      { provider: "github-copilot", label: "Premium / month" },
+      { provider: "openrouter", label: "Monthly Budget" },
+      { provider: "synthetic", label: "Subscription" },
+    ];
+
+    for (const { provider, label } of providers) {
+      const status = toWindowStatus({
+        provider,
+        label,
+        usedPercent: 50,
+        resetsAt: new Date("2026-05-06T07:47:37Z"),
+        windowSeconds: 5 * 60 * 60,
+        usedValue: 50,
+        limitValue: 100,
+      });
+
+      const result = formatStatus({ ui: { theme } } as any, [status]);
+
+      expect(result).toContain("(↺in 2h19m)");
+      expect(result).not.toContain("(↺in 3h)");
+    }
+  });
+
+  it("omits footer reset tags for windows without a real reset time", () => {
+    const result = formatStatus(
+      { ui: { theme } } as any,
+      [
+        {
+          label: "Spend cap",
+          usedPercent: 0,
+          severity: "none",
+          resetsAt: null,
+          limited: false,
+          usedValue: 0,
+          limitValue: 1,
+        },
+      ],
+    );
+
+    expect(result).toContain("cap:");
+    expect(result).not.toContain("↺");
+    expect(result).not.toContain("soon");
+  });
+
+  it("maps sentinel reset dates to null before rendering status for non-reset provider windows", () => {
+    const windows: Array<{ provider: SupportedQuotaProvider; label: string; isCurrency?: boolean }> = [
+      { provider: "openai-codex", label: "Spend cap" },
+      { provider: "openai-codex", label: "Credits", isCurrency: true },
+      { provider: "openrouter", label: "Credits Remaining", isCurrency: true },
+    ];
+
+    for (const { provider, label, isCurrency } of windows) {
+      const status = toWindowStatus({
+        provider,
+        label,
+        usedPercent: 0,
+        resetsAt: new Date(0),
+        windowSeconds: 0,
+        usedValue: 0,
+        limitValue: 1,
+        limited: false,
+        isCurrency,
+      });
+
+      expect(status.resetsAt).toBeNull();
+    }
+  });
+
+  it("does not prefix elapsed reset times with in", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-05-06T05:28:37Z"));
+
+    const result = formatStatus(
+      { ui: { theme } } as any,
+      [
+        {
+          label: "5h",
+          usedPercent: 100,
+          severity: "critical",
+          resetsAt: "2026-05-06T05:28:37Z",
+          limited: false,
+          usedValue: 100,
+          limitValue: 100,
+        },
+      ],
+    );
+
+    expect(result).toContain("(↺now)");
+    expect(result).not.toContain("(↺in now)");
+  });
 });

package/src/extensions/usage-status/index.ts

@@ -11,28 +11,47 @@ import {
 } from "../../config.js";
 import {
   fetchProviderQuotas,
-  formatResetTime,
   isSupportedProvider,
 } from "../../lib/quotas.js";
 import {
   assessWindow,
+  formatTimeRemaining,
 } from "../../utils/quotas-severity.js";
+import type { QuotaWindow } from "../../types/quotas.js";
 import { formatWindowStatus, type WindowStatus } from "./format-status.js";
 
 const EXTENSION_ID = "pi-quotas-usage";
 const REFRESH_INTERVAL_MS = 60_000;
 
-function formatStatus(ctx: ExtensionContext, windows: WindowStatus[]): string {
+function formatFooterResetTime(resetsAt: string): string {
+  const remaining = formatTimeRemaining(new Date(resetsAt));
+  return remaining === "now" ? "now" : `in ${remaining}`;
+}
+
+export function formatStatus(ctx: Pick<ExtensionContext, "ui">, windows: WindowStatus[]): string {
   const theme = ctx.ui.theme;
   return windows
     .map((w) => {
       const core = formatWindowStatus(theme, w);
-      const reset = w.resetsAt ? theme.fg("dim", ` (↺${formatResetTime(w.resetsAt)})`) : "";
+      const reset = w.resetsAt ? theme.fg("dim", ` (↺${formatFooterResetTime(w.resetsAt)})`) : "";
       return `${core}${reset}`;
     })
     .join(" ");
 }
 
+export function toWindowStatus(window: QuotaWindow): WindowStatus {
+  return {
+    label: window.label,
+    usedPercent: window.usedPercent,
+    severity: assessWindow(window).severity,
+    resetsAt: window.resetsAt.getTime() > 0 ? window.resetsAt.toISOString() : null,
+    limited: window.limited ?? false,
+    isCurrency: window.isCurrency,
+    usedValue: window.usedValue,
+    limitValue: window.limitValue,
+  };
+}
+
 function createStatusRefresher() {
   let refreshTimer: ReturnType<typeof setInterval> | undefined;
   let activeContext: ExtensionContext | undefined;
@@ -54,16 +73,7 @@ function createStatusRefresher() {
         ctx.ui.setStatus(EXTENSION_ID, ctx.ui.theme.fg("warning", "usage unavailable"));
         return;
       }
-      const windows: WindowStatus[] = result.data.windows.map((window) => ({
-        label: window.label,
-        usedPercent: window.usedPercent,
-        severity: assessWindow(window).severity,
-        resetsAt: window.resetsAt.toISOString(),
-        limited: window.limited ?? false,
-        isCurrency: window.isCurrency,
-        usedValue: window.usedValue,
-        limitValue: window.limitValue,
-      }));
+      const windows: WindowStatus[] = result.data.windows.map(toWindowStatus);
       lastStatus = windows;
       ctx.ui.setStatus(EXTENSION_ID, formatStatus(ctx, windows));
     } catch {

package/src/lib/quotas.ts

@@ -7,6 +7,7 @@ export const SUPPORTED_PROVIDERS: SupportedQuotaProvider[] = [
   "openai-codex",
   "github-copilot",
   "openrouter",
+  "synthetic",
 ];
 
 export const PROVIDER_LABELS: Record<SupportedQuotaProvider, string> = {
@@ -14,6 +15,7 @@ export const PROVIDER_LABELS: Record<SupportedQuotaProvider, string> = {
   "openai-codex": "OpenAI Codex",
   "github-copilot": "GitHub Copilot",
   openrouter: "OpenRouter",
+  synthetic: "Synthetic",
 };
 
 const PROVIDER_TTLS_MS: Record<SupportedQuotaProvider, number> = {
@@ -21,6 +23,7 @@ const PROVIDER_TTLS_MS: Record<SupportedQuotaProvider, number> = {
   "openai-codex": 60_000,
   "github-copilot": 5 * 60_000,
   openrouter: 60_000,
+  synthetic: 60_000,
 };
 
 type CacheEntry = {

package/src/providers/fetch.ts

@@ -9,6 +9,7 @@ import {
   parseCodexUsage,
   parseGitHubCopilotUsage,
   parseOpenRouterUsage,
+  parseSyntheticUsage,
 } from "./providers.js";
 
 const FETCH_TIMEOUT_MS = 15_000;
@@ -268,9 +269,28 @@ export async function fetchOpenRouterQuotas(
   );
 }
 
+export async function fetchSyntheticQuotas(
+  _authStorage: AuthStorage,
+  signal?: AbortSignal,
+): Promise<QuotasResult> {
+  const apiKey = process.env.SYNTHETIC_API_KEY;
+  if (!apiKey) return failure("No Synthetic API key found (set SYNTHETIC_API_KEY)", "config");
+
+  const result = await fetchJson(
+    "https://api.synthetic.new/v2/quotas",
+    {
+      headers: { Authorization: `Bearer ${apiKey}` },
+    },
+    signal,
+  );
+  if (!result.ok) return failure(result.message, result.kind);
+  return success("synthetic", parseSyntheticUsage(result.data));
+}
+
 export const PROVIDER_FETCHERS = {
   anthropic: fetchAnthropicQuotas,
   "openai-codex": fetchCodexQuotas,
   "github-copilot": fetchGitHubCopilotQuotas,
   openrouter: fetchOpenRouterQuotas,
+  synthetic: fetchSyntheticQuotas,
 } as const;

package/src/providers/providers.ts

@@ -352,3 +352,88 @@ export function parseOpenRouterUsage(data: any): QuotaWindow[] {
 
   return windows;
 }
+
+export function parseSyntheticUsage(data: any): QuotaWindow[] {
+  const windows: QuotaWindow[] = [];
+
+  // Subscription (requests)
+  if (data?.subscription) {
+    windows.push({
+      provider: "synthetic",
+      label: "Subscription",
+      usedPercent: safePercent(data.subscription.requests, data.subscription.limit),
+      resetsAt: parseDateish(data.subscription.renewsAt),
+      windowSeconds: 30 * 24 * 60 * 60,
+      usedValue: data.subscription.requests,
+      limitValue: data.subscription.limit,
+      showPace: true,
+      nextLabel: "Resets",
+    });
+  }
+
+  // Search hourly
+  if (data?.search?.hourly) {
+    windows.push({
+      provider: "synthetic",
+      label: "Search / hour",
+      usedPercent: safePercent(data.search.hourly.requests, data.search.hourly.limit),
+      resetsAt: parseDateish(data.search.hourly.renewsAt),
+      windowSeconds: 60 * 60,
+      usedValue: data.search.hourly.requests,
+      limitValue: data.search.hourly.limit,
+      showPace: false,
+      nextLabel: "Resets",
+    });
+  }
+
+  // Free tool calls
+  if (data?.freeToolCalls) {
+    windows.push({
+      provider: "synthetic",
+      label: "Free Tools",
+      usedPercent: safePercent(data.freeToolCalls.requests, data.freeToolCalls.limit),
+      resetsAt: parseDateish(data.freeToolCalls.renewsAt),
+      windowSeconds: 30 * 24 * 60 * 60,
+      usedValue: data.freeToolCalls.requests,
+      limitValue: data.freeToolCalls.limit,
+      showPace: true,
+      nextLabel: "Resets",
+    });
+  }
+
+  // Weekly token limit
+  if (data?.weeklyTokenLimit) {
+    const maxCredits = parseFloat(data.weeklyTokenLimit.maxCredits) || 0;
+    const remainingCredits = parseFloat(data.weeklyTokenLimit.remainingCredits) || 0;
+    windows.push({
+      provider: "synthetic",
+      label: "Weekly Tokens",
+      usedPercent: data.weeklyTokenLimit.percentRemaining ?? safePercent(remainingCredits, maxCredits),
+      resetsAt: parseDateish(data.weeklyTokenLimit.nextRegenAt),
+      windowSeconds: 7 * 24 * 60 * 60,
+      usedValue: maxCredits - remainingCredits,
+      limitValue: maxCredits,
+      isCurrency: true,
+      showPace: true,
+      nextLabel: "Regen",
+    });
+  }
+
+  // Rolling 5-hour limit
+  if (data?.rollingFiveHourLimit) {
+    windows.push({
+      provider: "synthetic",
+      label: "5h Limit",
+      usedPercent: data.rollingFiveHourLimit.tickPercent,
+      resetsAt: parseDateish(data.rollingFiveHourLimit.nextTickAt),
+      windowSeconds: 5 * 60 * 60,
+      usedValue: data.rollingFiveHourLimit.max - data.rollingFiveHourLimit.remaining,
+      limitValue: data.rollingFiveHourLimit.max,
+      limited: data.rollingFiveHourLimit.limited,
+      showPace: false,
+      nextLabel: data.rollingFiveHourLimit.limited ? "Limited" : "Resets",
+    });
+  }
+
+  return windows;
+}

package/src/types/quotas.ts

@@ -2,7 +2,8 @@ export type SupportedQuotaProvider =
   | "anthropic"
   | "openai-codex"
   | "github-copilot"
-  | "openrouter";
+  | "openrouter"
+  | "synthetic";
 
 export type QuotasErrorKind =
   | "cancelled"