@latentminds/pi-quotas 0.2.6 → 0.3.1

package/src/providers/parse.test.ts

@@ -4,6 +4,8 @@ import { parseCodexUsage } from "./providers.js";
 import { parseGitHubCopilotUsage } from "./providers.js";
 import { parseOpenRouterUsage } from "./providers.js";
 import { parseSyntheticUsage } from "./providers.js";
+import { parseZaiUsage } from "./providers.js";
+import { parseOpenCodeGoUsage } from "./providers.js";
 
 describe("parseAnthropicUsage", () => {
   it("maps oauth usage response into quota windows", () => {
@@ -63,7 +65,10 @@ describe("parseAnthropicUsage", () => {
       five_hour: { utilization: 9, resets_at: "2026-04-22T09:00:00Z" },
       seven_day: { utilization: 31, resets_at: "2026-04-23T23:00:00Z" },
       seven_day_sonnet: { utilization: 8, resets_at: "2026-04-23T23:00:00Z" },
-      seven_day_omelette: { utilization: 23, resets_at: "2026-04-26T23:00:00Z" },
+      seven_day_omelette: {
+        utilization: 23,
+        resets_at: "2026-04-26T23:00:00Z",
+      },
       seven_day_opus: null,
     });
 
@@ -140,7 +145,11 @@ describe("parseCodexUsage", () => {
     const windows = parseCodexUsage({
       plan_type: "team",
       rate_limit: {
-        primary_window: { used_percent: 10, reset_at: 1776880800, limit_window_seconds: 18000 },
+        primary_window: {
+          used_percent: 10,
+          reset_at: 1776880800,
+          limit_window_seconds: 18000,
+        },
       },
       credits: {
         has_credits: true,
@@ -160,7 +169,11 @@ describe("parseCodexUsage", () => {
     const windows = parseCodexUsage({
       plan_type: "team",
       rate_limit: {
-        primary_window: { used_percent: 10, reset_at: 1776880800, limit_window_seconds: 18000 },
+        primary_window: {
+          used_percent: 10,
+          reset_at: 1776880800,
+          limit_window_seconds: 18000,
+        },
       },
       spend_control: { reached: true },
     });
@@ -173,7 +186,11 @@ describe("parseCodexUsage", () => {
   it("skips credits when no balance", () => {
     const windows = parseCodexUsage({
       rate_limit: {
-        primary_window: { used_percent: 10, reset_at: 1776880800, limit_window_seconds: 18000 },
+        primary_window: {
+          used_percent: 10,
+          reset_at: 1776880800,
+          limit_window_seconds: 18000,
+        },
       },
       credits: { has_credits: false, balance: null },
     });
@@ -254,8 +271,14 @@ describe("parseGitHubCopilotUsage", () => {
     });
 
     expect(windows).toHaveLength(2);
-    expect(windows[0]).toMatchObject({ label: "Chat / month", usedPercent: 18 });
-    expect(windows[1]).toMatchObject({ label: "Completions / month", usedPercent: 0 });
+    expect(windows[0]).toMatchObject({
+      label: "Chat / month",
+      usedPercent: 18,
+    });
+    expect(windows[1]).toMatchObject({
+      label: "Completions / month",
+      usedPercent: 0,
+    });
   });
 });
 
@@ -477,7 +500,9 @@ describe("parseSyntheticUsage", () => {
     expect(search!.limitValue).toBe(250);
 
     // freeToolCalls with limit=0 is NOT shown
-    expect(windows.find((w) => w.label === "Free Tool Calls / day")).toBeUndefined();
+    expect(
+      windows.find((w) => w.label === "Free Tool Calls / day"),
+    ).toBeUndefined();
   });
 
   it("shows freeToolCalls when limit > 0", () => {
@@ -541,3 +566,156 @@ describe("parseSyntheticUsage", () => {
     expect(windows).toHaveLength(0);
   });
 });
+
+describe("parseOpenCodeGoUsage", () => {
+  it("parses rolling, weekly, and monthly windows", () => {
+    const windows = parseOpenCodeGoUsage({
+      rolling: {
+        usagePercent: 35,
+        resetInSec: 12000,
+        percentRemaining: 65,
+        resetTimeIso: "2026-05-18T22:00:00Z",
+      },
+      weekly: {
+        usagePercent: 62,
+        resetInSec: 500000,
+        percentRemaining: 38,
+        resetTimeIso: "2026-05-25T00:00:00Z",
+      },
+      monthly: {
+        usagePercent: 28,
+        resetInSec: 1200000,
+        percentRemaining: 72,
+        resetTimeIso: "2026-06-01T00:00:00Z",
+      },
+    });
+
+    expect(windows).toHaveLength(3);
+
+    expect(windows[0]).toMatchObject({
+      provider: "opencode-go",
+      label: "5h Rolling",
+      usedPercent: 35,
+      windowSeconds: 5 * 60 * 60,
+    });
+
+    expect(windows[1]).toMatchObject({
+      provider: "opencode-go",
+      label: "Weekly",
+      usedPercent: 62,
+      windowSeconds: 7 * 24 * 60 * 60,
+      showPace: true,
+    });
+
+    expect(windows[2]).toMatchObject({
+      provider: "opencode-go",
+      label: "Monthly",
+      usedPercent: 28,
+      windowSeconds: 30 * 24 * 60 * 60,
+      showPace: true,
+    });
+  });
+
+  it("handles partial windows", () => {
+    const windows = parseOpenCodeGoUsage({
+      rolling: {
+        usagePercent: 10,
+        resetInSec: 15000,
+        percentRemaining: 90,
+        resetTimeIso: "2026-05-18T21:00:00Z",
+      },
+    });
+
+    expect(windows).toHaveLength(1);
+    expect(windows[0].label).toBe("5h Rolling");
+  });
+
+  it("returns empty for no data", () => {
+    const windows = parseOpenCodeGoUsage({});
+    expect(windows).toHaveLength(0);
+  });
+});
+
+describe("parseZaiUsage", () => {
+  it("maps token windows (5h/7d) and the monthly web-search count", () => {
+    const windows = parseZaiUsage({
+      data: {
+        level: "lite",
+        limits: [
+          {
+            type: "TIME_LIMIT",
+            unit: 5,
+            number: 1,
+            usage: 100,
+            currentValue: 25,
+            remaining: 75,
+            percentage: 25,
+            nextResetTime: 1785048370995,
+            usageDetails: [
+              { modelCode: "search-prime", usage: 20 },
+              { modelCode: "web-reader", usage: 5 },
+            ],
+          },
+          {
+            type: "TOKENS_LIMIT",
+            unit: 3,
+            number: 5,
+            percentage: 8,
+            nextResetTime: 1782932874304,
+          },
+          {
+            type: "TOKENS_LIMIT",
+            unit: 6,
+            number: 1,
+            percentage: 52,
+            nextResetTime: 1783061170994,
+          },
+        ],
+      },
+    });
+
+    // Shortest window first: 5h → 7d → month
+    expect(windows).toHaveLength(3);
+    expect(windows[0]).toMatchObject({
+      provider: "zai",
+      label: "5h",
+      usedPercent: 8,
+      windowSeconds: 5 * 60 * 60,
+      usedValue: 8,
+      limitValue: 100,
+    });
+    expect(windows[1]).toMatchObject({
+      provider: "zai",
+      label: "7d",
+      usedPercent: 52,
+      windowSeconds: 7 * 24 * 60 * 60,
+    });
+    expect(windows[2]).toMatchObject({
+      provider: "zai",
+      label: "Web / month",
+      usedPercent: 25,
+      usedValue: 25,
+      limitValue: 100,
+      windowSeconds: 30 * 24 * 60 * 60,
+    });
+  });
+
+  it("skips the monthly window when the entitlement is zero", () => {
+    const windows = parseZaiUsage({
+      data: {
+        limits: [
+          { type: "TIME_LIMIT", unit: 5, number: 1, usage: 0, currentValue: 0, nextResetTime: 1785048370995 },
+          { type: "TOKENS_LIMIT", unit: 3, number: 5, percentage: 0, nextResetTime: 1782932874304 },
+        ],
+      },
+    });
+    expect(windows).toHaveLength(1);
+    expect(windows[0].label).toBe("5h");
+  });
+
+  it("returns empty array when there are no limits", () => {
+    expect(parseZaiUsage({})).toHaveLength(0);
+    expect(parseZaiUsage({ data: {} })).toHaveLength(0);
+    expect(parseZaiUsage({ data: { limits: [] } })).toHaveLength(0);
+  });
+});

package/src/providers/providers.ts

@@ -13,7 +13,10 @@ function parseDateish(value: unknown): Date {
 function monthWindowSeconds(resetAt: Date): number {
   const approxStart = new Date(resetAt);
   approxStart.setMonth(approxStart.getMonth() - 1);
-  return Math.max(1, Math.round((resetAt.getTime() - approxStart.getTime()) / 1000));
+  return Math.max(
+    1,
+    Math.round((resetAt.getTime() - approxStart.getTime()) / 1000),
+  );
 }
 
 export function parseAnthropicUsage(data: any): QuotaWindow[] {
@@ -79,8 +82,14 @@ export function parseAnthropicUsage(data: any): QuotaWindow[] {
     windows.push({
       provider: "anthropic",
       label: `Extra (${currency})`,
-      usedPercent: Number(extra.utilization ?? safePercent(usedDollars, limitDollars)),
-      resetsAt: new Date(new Date().getFullYear(), new Date().getMonth() + 1, 1),
+      usedPercent: Number(
+        extra.utilization ?? safePercent(usedDollars, limitDollars),
+      ),
+      resetsAt: new Date(
+        new Date().getFullYear(),
+        new Date().getMonth() + 1,
+        1,
+      ),
       windowSeconds: 30 * 24 * 60 * 60,
       usedValue: usedDollars,
       limitValue: limitDollars,
@@ -95,16 +104,26 @@ export function parseAnthropicUsage(data: any): QuotaWindow[] {
 }
 
 function percentLeftToUsedPercent(limit: any): number {
-  if (limit?.percent_left != null) return Math.max(0, 100 - Number(limit.percent_left));
-  if (limit?.remaining_percent != null) return Math.max(0, 100 - Number(limit.remaining_percent));
+  if (limit?.percent_left != null)
+    return Math.max(0, 100 - Number(limit.percent_left));
+  if (limit?.remaining_percent != null)
+    return Math.max(0, 100 - Number(limit.remaining_percent));
   if (limit?.used_percent != null) return Number(limit.used_percent);
   return 0;
 }
 
 export function parseCodexUsage(data: any): QuotaWindow[] {
   const rateLimit = data?.rate_limit ?? data?.rate_limits ?? {};
-  const primary = rateLimit.primary_window ?? rateLimit.primary ?? rateLimit.five_hour_limit ?? rateLimit.five_hour;
-  const secondary = rateLimit.secondary_window ?? rateLimit.secondary ?? rateLimit.weekly_limit ?? rateLimit.weekly;
+  const primary =
+    rateLimit.primary_window ??
+    rateLimit.primary ??
+    rateLimit.five_hour_limit ??
+    rateLimit.five_hour;
+  const secondary =
+    rateLimit.secondary_window ??
+    rateLimit.secondary ??
+    rateLimit.weekly_limit ??
+    rateLimit.weekly;
 
   const windows: QuotaWindow[] = [];
 
@@ -180,7 +199,11 @@ export function parseCodexUsage(data: any): QuotaWindow[] {
 export function parseGitHubCopilotUsage(data: any): QuotaWindow[] {
   const windows: QuotaWindow[] = [];
 
-  const resetAt = parseDateish(data?.quota_reset_date ?? data?.quota_reset_date_utc ?? data?.limited_user_reset_date);
+  const resetAt = parseDateish(
+    data?.quota_reset_date ??
+      data?.quota_reset_date_utc ??
+      data?.limited_user_reset_date,
+  );
   const periodSeconds = monthWindowSeconds(resetAt);
 
   const snapshots = data?.quota_snapshots;
@@ -209,11 +232,12 @@ export function parseGitHubCopilotUsage(data: any): QuotaWindow[] {
         limitValue: entitlement,
         showPace: true,
         nextLabel: "Resets",
-        nextAmount: overageCount > 0
-          ? `+${overageCount} overage`
-          : overagePermitted
-            ? "overage allowed"
-            : undefined,
+        nextAmount:
+          overageCount > 0
+            ? `+${overageCount} overage`
+            : overagePermitted
+              ? "overage allowed"
+              : undefined,
       });
     }
     return windows;
@@ -247,21 +271,41 @@ export function parseGitHubCopilotUsage(data: any): QuotaWindow[] {
 // Helper functions for OpenRouter date calculations (UTC-based)
 function calculateNextMidnightUTC(): Date {
   const now = new Date();
-  const midnight = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1, 0, 0, 0));
+  const midnight = new Date(
+    Date.UTC(
+      now.getUTCFullYear(),
+      now.getUTCMonth(),
+      now.getUTCDate() + 1,
+      0,
+      0,
+      0,
+    ),
+  );
   return midnight;
 }
 
 function calculateNextMondayUTC(): Date {
   const now = new Date();
   const day = now.getUTCDay(); // 0 = Sunday, 1 = Monday, etc.
-  const daysUntilMonday = day === 0 ? 1 : (8 - day); // Days until next Monday
-  const monday = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + daysUntilMonday, 0, 0, 0));
+  const daysUntilMonday = day === 0 ? 1 : 8 - day; // Days until next Monday
+  const monday = new Date(
+    Date.UTC(
+      now.getUTCFullYear(),
+      now.getUTCMonth(),
+      now.getUTCDate() + daysUntilMonday,
+      0,
+      0,
+      0,
+    ),
+  );
   return monday;
 }
 
 function calculateNextMonthStartUTC(): Date {
   const now = new Date();
-  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1, 0, 0, 0));
+  return new Date(
+    Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1, 0, 0, 0),
+  );
 }
 
 export function parseOpenRouterUsage(data: any): QuotaWindow[] {
@@ -364,7 +408,6 @@ export function parseSyntheticUsage(data: any): QuotaWindow[] {
 
   // Weekly token/credit limit (primary window for paid plans)
   if (data?.weeklyTokenLimit) {
-    const { weeklyTokenLimit } = data.weeklyTokenLimit;
     const limitValue = parseCurrency(data.weeklyTokenLimit.maxCredits);
     const remainingValue = parseCurrency(data.weeklyTokenLimit.remainingCredits);
     windows.push({
@@ -385,7 +428,8 @@ export function parseSyntheticUsage(data: any): QuotaWindow[] {
 
   // Rolling 5-hour request limit
   if (data?.rollingFiveHourLimit && data.rollingFiveHourLimit.max > 0) {
-    const used = data.rollingFiveHourLimit.max - data.rollingFiveHourLimit.remaining;
+    const used =
+      data.rollingFiveHourLimit.max - data.rollingFiveHourLimit.remaining;
     windows.push({
       provider: "synthetic",
       label: "Requests / 5h",
@@ -405,7 +449,10 @@ export function parseSyntheticUsage(data: any): QuotaWindow[] {
     windows.push({
       provider: "synthetic",
       label: "Search / hour",
-      usedPercent: safePercent(data.search.hourly.requests, data.search.hourly.limit),
+      usedPercent: safePercent(
+        data.search.hourly.requests,
+        data.search.hourly.limit,
+      ),
       resetsAt: parseDateish(data.search.hourly.renewsAt),
       windowSeconds: 60 * 60,
       usedValue: data.search.hourly.requests,
@@ -421,7 +468,10 @@ export function parseSyntheticUsage(data: any): QuotaWindow[] {
     windows.push({
       provider: "synthetic",
       label: "Free Tool Calls / day",
-      usedPercent: safePercent(data.freeToolCalls.requests, data.freeToolCalls.limit),
+      usedPercent: safePercent(
+        data.freeToolCalls.requests,
+        data.freeToolCalls.limit,
+      ),
       resetsAt: parseDateish(data.freeToolCalls.renewsAt),
       windowSeconds: 24 * 60 * 60,
       usedValue: data.freeToolCalls.requests,
@@ -434,3 +484,161 @@ export function parseSyntheticUsage(data: any): QuotaWindow[] {
 
   return windows;
 }
+
+export function parseOpenCodeGoUsage(data: {
+  rolling?: {
+    usagePercent: number;
+    resetInSec: number;
+    percentRemaining: number;
+    resetTimeIso: string;
+  };
+  weekly?: {
+    usagePercent: number;
+    resetInSec: number;
+    percentRemaining: number;
+    resetTimeIso: string;
+  };
+  monthly?: {
+    usagePercent: number;
+    resetInSec: number;
+    percentRemaining: number;
+    resetTimeIso: string;
+  };
+}): QuotaWindow[] {
+  const windows: QuotaWindow[] = [];
+
+  if (data.rolling) {
+    windows.push({
+      provider: "opencode-go",
+      label: "5h Rolling",
+      usedPercent: data.rolling.usagePercent,
+      resetsAt: new Date(data.rolling.resetTimeIso),
+      windowSeconds: 5 * 60 * 60,
+      usedValue: data.rolling.usagePercent,
+      limitValue: 100,
+      showPace: false,
+      nextLabel: "Resets",
+    });
+  }
+
+  if (data.weekly) {
+    windows.push({
+      provider: "opencode-go",
+      label: "Weekly",
+      usedPercent: data.weekly.usagePercent,
+      resetsAt: new Date(data.weekly.resetTimeIso),
+      windowSeconds: 7 * 24 * 60 * 60,
+      usedValue: data.weekly.usagePercent,
+      limitValue: 100,
+      showPace: true,
+      paceScale: 1 / 7,
+      nextLabel: "Resets",
+    });
+  }
+
+  if (data.monthly) {
+    windows.push({
+      provider: "opencode-go",
+      label: "Monthly",
+      usedPercent: data.monthly.usagePercent,
+      resetsAt: new Date(data.monthly.resetTimeIso),
+      windowSeconds: 30 * 24 * 60 * 60,
+      usedValue: data.monthly.usagePercent,
+      limitValue: 100,
+      showPace: true,
+      paceScale: 1,
+      nextLabel: "Resets",
+    });
+  }
+
+  return windows;
+}
+
+// Z.ai (Zhipu AI) GLM Coding Plan quotas.
+//
+// The quota endpoint returns { data: { limits: [...], level } }. Each entry in
+// `limits` is either a TOKENS_LIMIT (token utilisation, reported as a bare
+// `percentage` with no absolute used/limit counts) or a TIME_LIMIT (a monthly
+// count window such as web searches, which does carry real used/limit counts).
+//
+// The window length is encoded as (unit, number). Observed values:
+//   unit 3 = HOUR  (e.g. the rolling 5-hour session window)
+//   unit 6 = WEEK  (e.g. the rolling 7-day weekly window)
+//   unit 5 = MONTH (TIME_LIMIT only, the monthly count window)
+// Reset times are epoch milliseconds.
+export function parseZaiUsage(data: any): QuotaWindow[] {
+  const collected: QuotaWindow[] = [];
+
+  const limits: any[] = data?.data?.limits ?? data?.limits ?? [];
+  if (!Array.isArray(limits)) return collected;
+
+  for (const entry of limits) {
+    if (!entry || typeof entry !== "object") continue;
+
+    // Token windows only expose a percentage, so — like Anthropic/Codex — we
+    // report usedValue as the percentage against a nominal limit of 100.
+    if (entry.type === "TOKENS_LIMIT") {
+      const unit = entry.unit;
+      const count = Number(entry.number ?? 1) || 1;
+      let label: string;
+      let windowSeconds: number;
+
+      switch (unit) {
+        case 3: // HOUR
+          label = `${count}h`;
+          windowSeconds = count * 60 * 60;
+          break;
+        case 4: // DAY (defensive — not observed, but handled)
+          label = `${count}d`;
+          windowSeconds = count * 24 * 60 * 60;
+          break;
+        case 6: // WEEK
+          label = `${count * 7}d`;
+          windowSeconds = count * 7 * 24 * 60 * 60;
+          break;
+        default:
+          // Unknown unit — still surface it so usage is never silently hidden.
+          label = "Tokens";
+          windowSeconds = 0;
+          break;
+      }
+
+      collected.push({
+        provider: "zai",
+        label,
+        usedPercent: Number(entry.percentage ?? 0),
+        resetsAt: parseDateish(entry.nextResetTime),
+        windowSeconds,
+        usedValue: Number(entry.percentage ?? 0),
+        limitValue: 100,
+        showPace: false,
+        nextLabel: "Resets",
+      });
+      continue;
+    }
+
+    // Monthly web-search / tool-call count window. Here z.ai gives real
+    // counts: `usage` is the entitlement, `currentValue` is what's been used.
+    if (entry.type === "TIME_LIMIT") {
+      const limit = Number(entry.usage ?? 0);
+      const used = Number(entry.currentValue ?? 0);
+      if (limit <= 0) continue;
+
+      collected.push({
+        provider: "zai",
+        label: "Web / month",
+        usedPercent: safePercent(used, limit),
+        resetsAt: parseDateish(entry.nextResetTime),
+        windowSeconds: 30 * 24 * 60 * 60,
+        usedValue: used,
+        limitValue: limit,
+        showPace: false,
+        nextLabel: "Resets",
+      });
+    }
+  }
+
+  // Shortest window first (5h → 7d → month), matching Anthropic/Codex order.
+  collected.sort((a, b) => a.windowSeconds - b.windowSeconds);
+  return collected;
+}

package/src/types/quotas.ts

@@ -3,17 +3,26 @@ export type SupportedQuotaProvider =
   | "openai-codex"
   | "github-copilot"
   | "openrouter"
-  | "synthetic";
+  | "synthetic"
+  | "zai"
+  | "opencode-go";
 
 export type QuotasErrorKind =
   | "cancelled"
   | "timeout"
   | "config"
   | "http"
-  | "network";
+  | "network"
+  // The provider is not applicable for the stored credential type
+  // (e.g. a direct Anthropic API key has no OAuth subscription usage to
+  // report). Consumers should render this silently rather than as a warning.
+  | "not_applicable";
 
 export type QuotasResult =
-  | { success: true; data: { windows: QuotaWindow[]; provider: SupportedQuotaProvider } }
+  | {
+      success: true;
+      data: { windows: QuotaWindow[]; provider: SupportedQuotaProvider };
+    }
   | { success: false; error: { message: string; kind: QuotasErrorKind } };
 
 export interface QuotaWindow {

package/src/utils/quotas-severity.ts

@@ -53,7 +53,10 @@ export function getProjectedPercent(
   return Math.max(0, (usedPercent / effectivePace) * 100);
 }
 
-function absoluteUsageSeverity(window: QuotaWindow, percent: number): RiskSeverity {
+function absoluteUsageSeverity(
+  window: QuotaWindow,
+  percent: number,
+): RiskSeverity {
   if (window.limited || percent >= 100) return "critical";
   if (percent >= 90) return "high";
   if (percent >= 80) return "warning";
@@ -139,8 +142,17 @@ export function formatTimeRemaining(date: Date): string {
   const ms = date.getTime() - Date.now();
   if (ms <= 0) return "now";
   const totalMins = Math.ceil(ms / (1000 * 60));
-  const hours = Math.floor(totalMins / 60);
+  const totalHours = Math.floor(totalMins / 60);
+  const days = Math.floor(totalHours / 24);
+  const hours = totalHours % 24;
   const mins = totalMins % 60;
+
+  if (days >= 1) {
+    const parts: string[] = [`${days}d`];
+    if (hours > 0) parts.push(`${hours}h`);
+    if (mins > 0) parts.push(`${mins}m`);
+    return parts.join("");
+  }
   if (hours >= 1) return mins > 0 ? `${hours}h${mins}m` : `${hours}h`;
   const totalSecs = Math.ceil(ms / 1000);
   return totalMins >= 1 ? `${totalMins}m` : `${totalSecs}s`;