@latentminds/pi-quotas 0.2.0 → 0.2.3

package/README.md

@@ -1,6 +1,6 @@
 # @latentminds/pi-quotas
 
-Quota monitoring for the [Pi coding agent](https://github.com/mariozechner/pi). Shows remaining usage and rate limits for Anthropic, OpenAI Codex, GitHub Copilot, and OpenRouter — directly in your Pi session.
+Quota monitoring for the [Pi coding agent](https://github.com/mariozechner/pi). Shows remaining usage and rate limits for Anthropic, OpenAI Codex, GitHub Copilot, OpenRouter, and Synthetic — directly in your Pi session.
 
 ## Screenshots
 
@@ -38,6 +38,7 @@ pi -e npm:@latentminds/pi-quotas
 | `/codex:quotas` | OpenAI Codex quotas only |
 | `/github:quotas` | GitHub Copilot quotas only |
 | `/openrouter:quotas` | OpenRouter quotas only |
+| `/synthetic:quotas` | Synthetic quotas only |
 | `/quotas:settings` | Toggle individual features on or off |
 
 ## Features
@@ -58,7 +59,7 @@ Automatic notifications when projected usage is on track to exceed limits before
 
 Use `/quotas:settings` to enable or disable:
 - Combined `/quotas` command
-- Per-provider commands (`/anthropic:quotas`, `/codex:quotas`, `/github:quotas`, `/openrouter:quotas`)
+- Per-provider commands (`/anthropic:quotas`, `/codex:quotas`, `/github:quotas`, `/openrouter:quotas`, `/synthetic:quotas`)
 - Footer status widget
 - Quota warning notifications
 
@@ -72,6 +73,7 @@ Settings can be saved globally (`~/.pi/agent/extensions/quotas.json`) or per-pro
 | OpenAI Codex | 5h, 7d, credits, spend cap | Rate-limit percentages; credit balance; spend-cap reached/OK |
 | GitHub Copilot | Premium/chat/completions per month | Remaining/entitlement counts with overage indicators |
 | OpenRouter | Monthly budget, daily/weekly/monthly usage | USD spending tracking with cents precision; optional per-key budget limits; UTC-based period resets |
+| Synthetic | Subscription, search/hour, free tools, weekly tokens, 5h limit | Request counts and token budgets; rolling five-hour rate limit; weekly token regen |
 
 ## Credentials
 
@@ -81,8 +83,9 @@ pi-quotas reads existing Pi auth entries from `~/.pi/agent/auth.json`:
 - `openai-codex` — Codex access token (also reads `~/.codex/auth.json` for the account ID)
 - `github-copilot` — GitHub Copilot OAuth token (falls back to `gh auth token` if needed)
 - `openrouter` — OpenRouter API key (Bearer token)
+- `synthetic` — Synthetic API key (set the `SYNTHETIC_API_KEY` environment variable)
 
-No additional setup is required - if Pi can use the provider, pi-quotas can check its quotas.
+No additional setup is required - if Pi can use the provider, pi-quotas can check its quotas. For Synthetic, export `SYNTHETIC_API_KEY` in your shell or Pi environment.
 
 ## Requirements
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@latentminds/pi-quotas",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "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, formatStatusForFooter, toStatusWindows, 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,142 @@ 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("clears the footer status when filtering removes all windows", () => {
+    expect(formatStatusForFooter({ ui: { theme } } as any, [])).toBeUndefined();
+  });
+
+  it("filters Anthropic subscription windows from footer status while keeping extra usage", () => {
+    const windows = toStatusWindows([
+      {
+        provider: "anthropic",
+        label: "5h",
+        usedPercent: 10,
+        resetsAt: new Date("2026-05-06T07:47:37Z"),
+        windowSeconds: 5 * 60 * 60,
+        usedValue: 10,
+        limitValue: 100,
+      },
+      {
+        provider: "anthropic",
+        label: "7d Sonnet",
+        usedPercent: 20,
+        resetsAt: new Date("2026-05-06T07:47:37Z"),
+        windowSeconds: 7 * 24 * 60 * 60,
+        usedValue: 20,
+        limitValue: 100,
+      },
+      {
+        provider: "anthropic",
+        label: "Extra (USD)",
+        usedPercent: 30,
+        resetsAt: new Date("2026-06-01T00:00:00Z"),
+        windowSeconds: 30 * 24 * 60 * 60,
+        usedValue: 30,
+        limitValue: 100,
+        isCurrency: true,
+      },
+    ]);
+
+    expect(windows).toHaveLength(1);
+    expect(windows[0]).toMatchObject({ label: "Extra (USD)" });
+  });
+
+  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,74 @@ 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(" ");
 }
 
+const ANTHROPIC_SUBSCRIPTION_WINDOW_LABELS = new Set([
+  "5h",
+  "7d",
+  "7d Sonnet",
+  "7d Opus",
+  "7d Opus (legacy)",
+]);
+
+function shouldShowInStatus(window: QuotaWindow): boolean {
+  return !(
+    window.provider === "anthropic" &&
+    ANTHROPIC_SUBSCRIPTION_WINDOW_LABELS.has(window.label)
+  );
+}
+
+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,
+  };
+}
+
+export function toStatusWindows(windows: QuotaWindow[]): WindowStatus[] {
+  return windows.filter(shouldShowInStatus).map(toWindowStatus);
+}
+
+export function formatStatusForFooter(
+  ctx: Pick<ExtensionContext, "ui">,
+  windows: WindowStatus[],
+): string | undefined {
+  if (windows.length === 0) return undefined;
+  return formatStatus(ctx, windows);
+}
+
 function createStatusRefresher() {
   let refreshTimer: ReturnType<typeof setInterval> | undefined;
   let activeContext: ExtensionContext | undefined;
@@ -54,18 +100,10 @@ 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,
-      }));
-      lastStatus = windows;
-      ctx.ui.setStatus(EXTENSION_ID, formatStatus(ctx, windows));
+      const windows: WindowStatus[] = toStatusWindows(result.data.windows);
+      const status = formatStatusForFooter(ctx, windows);
+      lastStatus = status === undefined ? undefined : windows;
+      ctx.ui.setStatus(EXTENSION_ID, status);
     } catch {
       ctx.ui.setStatus(EXTENSION_ID, ctx.ui.theme.fg("warning", "usage unavailable"));
     } finally {
@@ -104,7 +142,7 @@ function createStatusRefresher() {
     },
     renderLast(ctx: ExtensionContext): boolean {
       if (!lastStatus || !ctx.hasUI) return false;
-      ctx.ui.setStatus(EXTENSION_ID, formatStatus(ctx, lastStatus));
+      ctx.ui.setStatus(EXTENSION_ID, formatStatusForFooter(ctx, lastStatus));
       return true;
     },
   };

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/parse.test.ts

@@ -48,6 +48,8 @@ describe("parseAnthropicUsage", () => {
     const extra = windows.find((w) => w.label === "Extra (AUD)");
     expect(extra).toBeDefined();
     expect(extra).toMatchObject({
+      provider: "anthropic",
+      label: "Extra (AUD)",
       isCurrency: true,
       usedPercent: 71.83,
       usedValue: 215.48,

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"