@aliou/pi-synthetic 0.17.4 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-synthetic",
-  "version": "0.17.4",
+  "version": "0.18.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -29,7 +29,8 @@
   },
   "files": [
     "src",
-    "README.md"
+    "README.md",
+    "!src/**/*.test.ts"
   ],
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "0.74.0",
@@ -40,8 +41,8 @@
     "@aliou/pi-utils-ui": "^0.4.0"
   },
   "devDependencies": {
-    "@aliou/biome-plugins": "^0.7.0",
-    "@biomejs/biome": "^2.4.2",
+    "@aliou/biome-plugins": "^0.8.1",
+    "@biomejs/biome": "^2.4.15",
     "@changesets/cli": "^2.27.11",
     "@earendil-works/pi-coding-agent": "0.74.0",
     "typebox": "^1.1.37",

package/src/extensions/provider/models.ts

@@ -216,4 +216,85 @@ export const SYNTHETIC_MODELS: SyntheticModelConfig[] = [
     contextWindow: 262144,
     maxTokens: 65536,
   },
+  // API: syn:large:text → alias for hf:zai-org/GLM-5.1 → ctx=196608, out=65536
+  {
+    id: "syn:large:text",
+    name: "syn:large:text",
+    provider: "synthetic",
+    reasoning: true,
+    thinkingLevelMap: { minimal: null, xhigh: null },
+    compat: {
+      supportsReasoningEffort: true,
+      supportsDeveloperRole: false,
+    },
+    input: ["text"],
+    cost: {
+      input: 1,
+      output: 3,
+      cacheRead: 1,
+      cacheWrite: 0,
+    },
+    contextWindow: 196608,
+    maxTokens: 65536,
+  },
+  // API: syn:small:text → alias for hf:zai-org/GLM-4.7-Flash → ctx=196608, out=65536
+  {
+    id: "syn:small:text",
+    name: "syn:small:text",
+    provider: "synthetic",
+    reasoning: true,
+    thinkingLevelMap: { minimal: null, xhigh: null },
+    compat: {
+      supportsReasoningEffort: true,
+    },
+    input: ["text"],
+    cost: {
+      input: 0.1,
+      output: 0.5,
+      cacheRead: 0.1,
+      cacheWrite: 0,
+    },
+    contextWindow: 196608,
+    maxTokens: 65536,
+  },
+  // API: syn:large:vision → alias for hf:moonshotai/Kimi-K2.6 → ctx=262144, out=65536
+  {
+    id: "syn:large:vision",
+    name: "syn:large:vision",
+    provider: "synthetic",
+    reasoning: true,
+    thinkingLevelMap: { minimal: null, low: null, xhigh: null },
+    compat: {
+      supportsReasoningEffort: true,
+    },
+    input: ["text", "image"],
+    cost: {
+      input: 0.95,
+      output: 4,
+      cacheRead: 0.95,
+      cacheWrite: 0,
+    },
+    contextWindow: 262144,
+    maxTokens: 65536,
+  },
+  // API: syn:small:vision → alias for hf:moonshotai/Kimi-K2.6 → ctx=262144, out=65536
+  {
+    id: "syn:small:vision",
+    name: "syn:small:vision",
+    provider: "synthetic",
+    reasoning: true,
+    thinkingLevelMap: { minimal: null, low: null, xhigh: null },
+    compat: {
+      supportsReasoningEffort: true,
+    },
+    input: ["text", "image"],
+    cost: {
+      input: 0.95,
+      output: 4,
+      cacheRead: 0.95,
+      cacheWrite: 0,
+    },
+    contextWindow: 262144,
+    maxTokens: 65536,
+  },
 ];

package/src/extensions/provider/index.test.ts

@@ -1,46 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildSyntheticProviderModels } from "./index";
-import { SYNTHETIC_MODELS } from "./models";
-
-describe("buildSyntheticProviderModels", () => {
-  it("excludes proxied models when includeProxiedModels is false", () => {
-    const models = buildSyntheticProviderModels(false);
-    for (const model of models) {
-      const source = SYNTHETIC_MODELS.find((m) => m.id === model.id);
-      expect(source).toBeDefined();
-      expect(source?.provider).toBe("synthetic");
-    }
-  });
-
-  it("includes all models when includeProxiedModels is true", () => {
-    const models = buildSyntheticProviderModels(true);
-    expect(models).toHaveLength(SYNTHETIC_MODELS.length);
-  });
-
-  it("does not expose the internal provider field", () => {
-    const models = buildSyntheticProviderModels(true);
-    for (const model of models) {
-      expect(model).not.toHaveProperty("provider");
-    }
-  });
-
-  it("sets default compat fields on every model", () => {
-    const models = buildSyntheticProviderModels(true);
-    for (const model of models) {
-      expect(model.compat).toMatchObject({
-        supportsDeveloperRole: false,
-      });
-      expect(model.compat).toHaveProperty("maxTokensField");
-    }
-  });
-
-  it("preserves model-specific compat overrides", () => {
-    const models = buildSyntheticProviderModels(true);
-    const miniMax = models.find((m) => m.id === "hf:MiniMaxAI/MiniMax-M2.5");
-    expect(miniMax).toBeDefined();
-    expect(miniMax?.compat).toMatchObject({
-      supportsDeveloperRole: false,
-      maxTokensField: "max_completion_tokens",
-    });
-  });
-});

package/src/extensions/provider/models.test.ts

@@ -1,217 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { SYNTHETIC_MODELS } from "./models";
-
-interface ApiModel {
-  id: string;
-  name: string;
-  provider: string | null;
-  input_modalities: string[];
-  output_modalities: string[];
-  context_length: number;
-  max_output_length: number;
-  pricing: {
-    prompt: string;
-    completion: string;
-    input_cache_reads: string;
-    input_cache_writes: string;
-  };
-  supported_features?: string[];
-}
-
-interface ApiResponse {
-  data: ApiModel[];
-}
-
-interface Discrepancy {
-  model: string;
-  field: string;
-  hardcoded: unknown;
-  api: unknown;
-}
-
-async function fetchApiModels(): Promise<ApiModel[]> {
-  // Making ourselves known
-  const response = await fetch("https://api.synthetic.new/openai/v1/models", {
-    headers: {
-      Referer: "https://github.com/aliou/pi-synthetic",
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(
-      `API request failed: ${response.status} ${response.statusText}`,
-    );
-  }
-
-  const data: ApiResponse = await response.json();
-  return data.data;
-}
-
-function parsePrice(priceStr: string): number {
-  // Convert "$0.0000006" to 0.6 (dollars per million tokens)
-  const match = priceStr.match(/\$?(\d+\.?\d*)/);
-  if (!match) return 0;
-  const pricePerToken = Number.parseFloat(match[1]);
-  // API prices are per token, hardcoded prices are per million tokens
-  return pricePerToken * 1_000_000;
-}
-
-function compareModels(
-  apiModels: ApiModel[],
-  hardcodedModels: typeof SYNTHETIC_MODELS,
-): Discrepancy[] {
-  const discrepancies: Discrepancy[] = [];
-
-  for (const hardcoded of hardcodedModels) {
-    const apiModel = apiModels.find((m) => m.id === hardcoded.id);
-
-    if (!apiModel) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "exists",
-        hardcoded: true,
-        api: false,
-      });
-      continue;
-    }
-
-    // Check input modalities (text vs image support)
-    const apiInputs = apiModel.input_modalities.sort();
-    const hardcodedInputs = [...hardcoded.input].sort();
-    if (JSON.stringify(apiInputs) !== JSON.stringify(hardcodedInputs)) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "input",
-        hardcoded: hardcodedInputs,
-        api: apiInputs,
-      });
-    }
-
-    // Check context window
-    if (apiModel.context_length !== hardcoded.contextWindow) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "contextWindow",
-        hardcoded: hardcoded.contextWindow,
-        api: apiModel.context_length,
-      });
-    }
-
-    // Check max output tokens (skip if API doesn't provide it)
-    if (
-      apiModel.max_output_length !== undefined &&
-      apiModel.max_output_length !== hardcoded.maxTokens
-    ) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "maxTokens",
-        hardcoded: hardcoded.maxTokens,
-        api: apiModel.max_output_length,
-      });
-    }
-
-    // Check input cost (convert API price to per-million rate)
-    const apiInputCost = parsePrice(apiModel.pricing.prompt);
-    const epsilon = 0.001; // Small tolerance for floating point
-    if (Math.abs(apiInputCost - hardcoded.cost.input) > epsilon) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "cost.input",
-        hardcoded: hardcoded.cost.input,
-        api: apiInputCost,
-      });
-    }
-
-    // Check output cost
-    const apiOutputCost = parsePrice(apiModel.pricing.completion);
-    if (Math.abs(apiOutputCost - hardcoded.cost.output) > epsilon) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "cost.output",
-        hardcoded: hardcoded.cost.output,
-        api: apiOutputCost,
-      });
-    }
-
-    // Check cache read cost
-    const apiCacheReadCost = parsePrice(apiModel.pricing.input_cache_reads);
-    if (Math.abs(apiCacheReadCost - hardcoded.cost.cacheRead) > epsilon) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "cost.cacheRead",
-        hardcoded: hardcoded.cost.cacheRead,
-        api: apiCacheReadCost,
-      });
-    }
-
-    // Check reasoning capability from supported_features (skip if API doesn't provide it)
-    if (apiModel.supported_features !== undefined) {
-      const apiSupportsReasoning =
-        apiModel.supported_features.includes("reasoning");
-      if (apiSupportsReasoning !== hardcoded.reasoning) {
-        discrepancies.push({
-          model: hardcoded.id,
-          field: "reasoning",
-          hardcoded: hardcoded.reasoning,
-          api: apiSupportsReasoning,
-        });
-      }
-    }
-
-    // Check provider
-    if (
-      apiModel.provider !== null &&
-      apiModel.provider !== hardcoded.provider
-    ) {
-      discrepancies.push({
-        model: hardcoded.id,
-        field: "provider",
-        hardcoded: hardcoded.provider,
-        api: apiModel.provider,
-      });
-    }
-  }
-
-  // Check for API models not in hardcoded list
-  for (const apiModel of apiModels) {
-    const hardcoded = hardcodedModels.find((m) => m.id === apiModel.id);
-    if (!hardcoded) {
-      discrepancies.push({
-        model: apiModel.id,
-        field: "exists",
-        hardcoded: false,
-        api: true,
-      });
-    }
-  }
-
-  return discrepancies;
-}
-
-describe("Synthetic models", () => {
-  it("should match API model definitions", { timeout: 30000 }, async () => {
-    const apiModels = await fetchApiModels();
-    const discrepancies = compareModels(apiModels, SYNTHETIC_MODELS);
-
-    if (discrepancies.length > 0) {
-      console.error("\nModel discrepancies found:");
-      console.error("==========================");
-      for (const d of discrepancies) {
-        if (d.field === "exists") {
-          if (d.hardcoded) {
-            console.error(`  ${d.model}: Missing from API`);
-          } else {
-            console.error(`  ${d.model}: Missing from hardcoded models (NEW)`);
-          }
-        } else {
-          console.error(`  ${d.model}.${d.field}:`);
-          console.error(`    hardcoded: ${JSON.stringify(d.hardcoded)}`);
-          console.error(`    api:       ${JSON.stringify(d.api)}`);
-        }
-      }
-      console.error("==========================\n");
-    }
-
-    expect(discrepancies).toHaveLength(0);
-  });
-});

package/src/services/quota-store.test.ts

@@ -1,211 +0,0 @@
-import {
-  afterEach,
-  assert,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  vi,
-} from "vitest";
-import type { QuotasResponse } from "../types/quotas";
-import { QuotaStore } from "./quota-store";
-
-beforeEach(() => {
-  vi.useFakeTimers();
-});
-
-afterEach(() => {
-  vi.useRealTimers();
-});
-
-describe("QuotaStore", () => {
-  const sampleQuotas: QuotasResponse = {
-    subscription: { limit: 100, requests: 5, renewsAt: "2026-01-01T00:00:00Z" },
-  };
-
-  describe("ingest", () => {
-    it("stores and emits API-sourced data", () => {
-      const store = new QuotaStore();
-      const received: QuotasResponse[] = [];
-      store.subscribe((snap) => received.push(snap.quotas));
-
-      const result = store.ingest(sampleQuotas, "api");
-
-      expect(result).toBe(true);
-      expect(store.getSnapshot()?.quotas).toBe(sampleQuotas);
-      expect(store.getSnapshot()?.source).toBe("api");
-      expect(received).toHaveLength(1);
-    });
-
-    it("stores and emits header-sourced data", () => {
-      const store = new QuotaStore();
-      const result = store.ingest(sampleQuotas, "header");
-
-      expect(result).toBe(true);
-      expect(store.getSnapshot()?.source).toBe("header");
-    });
-
-    it("throttles header ingestion within throttle window", () => {
-      const store = new QuotaStore();
-      store.ingest(sampleQuotas, "header");
-
-      // Within throttle window — should be dropped
-      const result = store.ingest(sampleQuotas, "header");
-      expect(result).toBe(false);
-
-      // Advance past throttle
-      vi.advanceTimersByTime(store.headerThrottleMs + 1);
-      const result2 = store.ingest(sampleQuotas, "header");
-      expect(result2).toBe(true);
-    });
-
-    it("does NOT throttle API ingestion", () => {
-      const store = new QuotaStore();
-      store.ingest(sampleQuotas, "api");
-
-      // API is never throttled
-      const result = store.ingest(sampleQuotas, "api");
-      expect(result).toBe(true);
-    });
-
-    it("header after API emit always goes through", () => {
-      const store = new QuotaStore();
-      store.ingest(sampleQuotas, "api");
-
-      // Header 1ms after API should not be blocked
-      vi.advanceTimersByTime(1);
-      const result = store.ingest(sampleQuotas, "header");
-      expect(result).toBe(true);
-    });
-
-    it("updates timestamp on each successful ingest", () => {
-      const store = new QuotaStore();
-      store.ingest(sampleQuotas, "api");
-      const snap1 = store.getSnapshot();
-      assert(snap1);
-      const t1 = snap1.updatedAt;
-
-      vi.advanceTimersByTime(10_000);
-      store.ingest(sampleQuotas, "api");
-      const snap2 = store.getSnapshot();
-      assert(snap2);
-      const t2 = snap2.updatedAt;
-
-      expect(t2).toBeGreaterThan(t1);
-    });
-  });
-
-  describe("subscribe", () => {
-    it("notifies subscribers on ingest", () => {
-      const store = new QuotaStore();
-      const calls: QuotasResponse[] = [];
-      store.subscribe((snap) => calls.push(snap.quotas));
-
-      store.ingest(sampleQuotas, "api");
-      expect(calls).toHaveLength(1);
-      expect(calls[0]).toBe(sampleQuotas);
-    });
-
-    it("does not notify on throttled ingest", () => {
-      const store = new QuotaStore();
-      const calls: QuotasResponse[] = [];
-      store.subscribe((snap) => calls.push(snap.quotas));
-
-      store.ingest(sampleQuotas, "header");
-      store.ingest(sampleQuotas, "header"); // throttled
-
-      expect(calls).toHaveLength(1);
-    });
-
-    it("unsubscribes when unsubscribe function is called", () => {
-      const store = new QuotaStore();
-      const calls: QuotasResponse[] = [];
-      const unsub = store.subscribe((snap) => calls.push(snap.quotas));
-
-      unsub();
-      store.ingest(sampleQuotas, "api");
-
-      expect(calls).toHaveLength(0);
-    });
-
-    it("supports multiple subscribers", () => {
-      const store = new QuotaStore();
-      const calls1: QuotasResponse[] = [];
-      const calls2: QuotasResponse[] = [];
-      store.subscribe((snap) => calls1.push(snap.quotas));
-      store.subscribe((snap) => calls2.push(snap.quotas));
-
-      store.ingest(sampleQuotas, "api");
-
-      expect(calls1).toHaveLength(1);
-      expect(calls2).toHaveLength(1);
-    });
-  });
-
-  describe("refreshFromApi", () => {
-    it("calls the fetcher and ingests the result", async () => {
-      const store = new QuotaStore();
-      const fetcher = vi.fn().mockResolvedValue(sampleQuotas);
-
-      const result = await store.refreshFromApi(fetcher);
-
-      assert(result);
-      expect(result.quotas).toBe(sampleQuotas);
-      expect(result.source).toBe("api");
-      expect(fetcher).toHaveBeenCalledOnce();
-    });
-
-    it("deduplicates concurrent calls", async () => {
-      const store = new QuotaStore();
-      let resolveFirst!: (v: QuotasResponse) => void;
-      const first = new Promise<QuotasResponse>((r) => (resolveFirst = r));
-      const fetcher = vi.fn().mockImplementation(() => first);
-
-      // Start two concurrent refreshes
-      const p1 = store.refreshFromApi(fetcher);
-      const p2 = store.refreshFromApi(fetcher);
-
-      // Only one fetcher call
-      expect(fetcher).toHaveBeenCalledOnce();
-      expect(store.isRefreshing).toBe(true);
-
-      // Resolve the fetch
-      resolveFirst(sampleQuotas);
-      await p1;
-      await p2;
-
-      expect(store.isRefreshing).toBe(false);
-    });
-
-    it("handles fetcher returning undefined", async () => {
-      const store = new QuotaStore();
-      const fetcher = vi.fn().mockResolvedValue(undefined);
-
-      const result = await store.refreshFromApi(fetcher);
-
-      expect(result).toBeUndefined();
-      expect(store.getSnapshot()).toBeUndefined();
-    });
-  });
-
-  describe("clear", () => {
-    it("resets all state", () => {
-      const store = new QuotaStore();
-      store.ingest(sampleQuotas, "api");
-
-      store.clear();
-
-      expect(store.getSnapshot()).toBeUndefined();
-    });
-
-    it("resets header throttle after clear", () => {
-      const store = new QuotaStore();
-      store.ingest(sampleQuotas, "header");
-      expect(store.ingest(sampleQuotas, "header")).toBe(false);
-
-      store.clear();
-
-      expect(store.ingest(sampleQuotas, "header")).toBe(true);
-    });
-  });
-});

package/src/services/quota-warnings.test.ts

@@ -1,393 +0,0 @@
-import {
-  afterEach,
-  assert,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  vi,
-} from "vitest";
-import type { QuotasResponse } from "../types/quotas";
-import { assessWindow, type QuotaWindow } from "../utils/quotas-severity";
-import { type NotifyFn, QuotaWarningNotifier } from "./quota-warnings";
-
-beforeEach(() => {
-  vi.useFakeTimers();
-});
-
-afterEach(() => {
-  vi.useRealTimers();
-});
-
-describe("QuotaWarningNotifier", () => {
-  const baseQuotas: QuotasResponse = {
-    weeklyTokenLimit: {
-      nextRegenAt: new Date(Date.now() + 6 * 24 * 3600 * 1000).toISOString(),
-      percentRemaining: 90,
-      maxCredits: "$10.00",
-      remainingCredits: "$9.00",
-      nextRegenCredits: "$0.50",
-    },
-    rollingFiveHourLimit: {
-      nextTickAt: new Date(Date.now() + 2.5 * 3600 * 1000).toISOString(),
-      tickPercent: 10,
-      remaining: 90,
-      max: 100,
-      limited: false,
-    },
-    search: {
-      hourly: {
-        limit: 100,
-        requests: 10,
-        renewsAt: new Date(Date.now() + 30 * 60 * 1000).toISOString(),
-      },
-    },
-    freeToolCalls: {
-      limit: 100,
-      requests: 5,
-      renewsAt: new Date(Date.now() + 12 * 3600 * 1000).toISOString(),
-    },
-  };
-
-  describe("shouldNotify", () => {
-    it("notifies on first time seeing a window at risk", () => {
-      const notifier = new QuotaWarningNotifier();
-      expect(notifier.shouldNotify("Credits / week", "warning")).toBe(true);
-      expect(notifier.shouldNotify("Requests / 5h", "high")).toBe(true);
-      expect(notifier.shouldNotify("Search / hour", "critical")).toBe(true);
-    });
-
-    it("notifies on severity escalation", () => {
-      const notifier = new QuotaWarningNotifier();
-      notifier.markNotified("Credits / week", "warning");
-      expect(notifier.shouldNotify("Credits / week", "high")).toBe(true);
-
-      notifier.markNotified("Requests / 5h", "high");
-      expect(notifier.shouldNotify("Requests / 5h", "critical")).toBe(true);
-    });
-
-    it("notifies on skip from none to any risk level", () => {
-      const notifier = new QuotaWarningNotifier();
-      notifier.markNotified("Test", "none");
-      expect(notifier.shouldNotify("Test", "warning")).toBe(true);
-    });
-
-    it("does not notify on same severity for warning within cooldown", () => {
-      const notifier = new QuotaWarningNotifier();
-      notifier.markNotified("Credits / week", "warning");
-      expect(notifier.shouldNotify("Credits / week", "warning")).toBe(false);
-    });
-
-    it("does notify on warning after cooldown elapsed", () => {
-      const notifier = new QuotaWarningNotifier();
-      notifier.markNotified("Credits / week", "warning");
-
-      vi.advanceTimersByTime(60 * 60 * 1000 + 1);
-
-      expect(notifier.shouldNotify("Credits / week", "warning")).toBe(true);
-    });
-
-    it("does not notify on downgrade to warning", () => {
-      const notifier = new QuotaWarningNotifier();
-      notifier.markNotified("Credits / week", "high");
-      expect(notifier.shouldNotify("Credits / week", "warning")).toBe(false);
-    });
-
-    it("does notify on downgrade to high (no cooldown)", () => {
-      const notifier = new QuotaWarningNotifier();
-      notifier.markNotified("Requests / 5h", "critical");
-      expect(notifier.shouldNotify("Requests / 5h", "high")).toBe(true);
-    });
-
-    it("always notifies for high severity (no cooldown)", () => {
-      const notifier = new QuotaWarningNotifier();
-      notifier.markNotified("Credits / week", "high");
-      expect(notifier.shouldNotify("Credits / week", "high")).toBe(true);
-    });
-
-    it("always notifies for critical severity (no cooldown)", () => {
-      const notifier = new QuotaWarningNotifier();
-      notifier.markNotified("Credits / week", "critical");
-      expect(notifier.shouldNotify("Credits / week", "critical")).toBe(true);
-    });
-  });
-
-  describe("markNotified", () => {
-    it("tracks severity per window key", () => {
-      const notifier = new QuotaWarningNotifier();
-      notifier.markNotified("Credits / week", "warning");
-      expect(notifier.shouldNotify("Credits / week", "warning")).toBe(false);
-
-      // Different key is independent
-      expect(notifier.shouldNotify("Requests / 5h", "warning")).toBe(true);
-    });
-
-    it("allows re-notification after escalation then downgrade then re-escalation", () => {
-      const notifier = new QuotaWarningNotifier();
-      notifier.markNotified("Test", "high");
-      expect(notifier.shouldNotify("Test", "warning")).toBe(false);
-      expect(notifier.shouldNotify("Test", "high")).toBe(true);
-    });
-  });
-
-  describe("clearAlertState", () => {
-    it("resets all alert state so windows notify again", () => {
-      const notifier = new QuotaWarningNotifier();
-      notifier.markNotified("Credits / week", "warning");
-      expect(notifier.shouldNotify("Credits / week", "warning")).toBe(false);
-
-      notifier.clearAlertState();
-
-      expect(notifier.shouldNotify("Credits / week", "warning")).toBe(true);
-    });
-  });
-
-  describe("findHighRiskWindows", () => {
-    it("returns empty for low-usage quotas", () => {
-      const notifier = new QuotaWarningNotifier();
-      const risks = notifier.findHighRiskWindows(baseQuotas);
-      expect(risks).toHaveLength(0);
-    });
-
-    it("finds windows with high usage", () => {
-      const notifier = new QuotaWarningNotifier();
-      const quotas: QuotasResponse = {
-        ...baseQuotas,
-        rollingFiveHourLimit: {
-          nextTickAt: new Date(Date.now() + 2.5 * 3600 * 1000).toISOString(),
-          tickPercent: 10,
-          remaining: 5,
-          max: 100,
-          limited: false,
-        },
-      };
-      const risks = notifier.findHighRiskWindows(quotas);
-      const fiveHourRisk = risks.find(
-        (r) => r.window.label === "Requests / 5h",
-      );
-      assert(fiveHourRisk, "fiveHourRisk should exist");
-      expect(fiveHourRisk.assessment.severity).toBe("high");
-    });
-
-    it("finds limited windows even with low usage", () => {
-      const notifier = new QuotaWarningNotifier();
-      const quotas: QuotasResponse = {
-        ...baseQuotas,
-        rollingFiveHourLimit: {
-          nextTickAt: new Date(Date.now() + 2.5 * 3600 * 1000).toISOString(),
-          tickPercent: 10,
-          remaining: 95,
-          max: 100,
-          limited: true,
-        },
-      };
-      const risks = notifier.findHighRiskWindows(quotas);
-      const fiveHourRisk = risks.find(
-        (r) => r.window.label === "Requests / 5h",
-      );
-      assert(fiveHourRisk, "fiveHourRisk should exist");
-      expect(fiveHourRisk.assessment.severity).toBe("critical");
-    });
-
-    it("returns empty for quotas with no windows", () => {
-      const notifier = new QuotaWarningNotifier();
-      expect(notifier.findHighRiskWindows({})).toHaveLength(0);
-    });
-  });
-
-  describe("formatWarningMessage", () => {
-    it("formats single window warning", () => {
-      const notifier = new QuotaWarningNotifier();
-      const w: QuotaWindow = {
-        label: "Requests / 5h",
-        usedPercent: 92,
-        resetsAt: new Date(Date.now() + 2 * 3600 * 1000),
-        windowSeconds: 5 * 3600,
-        usedValue: 92,
-        limitValue: 100,
-        showPace: false,
-      };
-      const assessment = assessWindow(w);
-      const msg = notifier.formatWarningMessage([{ window: w, assessment }]);
-      expect(msg).toContain("Synthetic quota warning:");
-      expect(msg).toContain("Requests / 5h");
-      expect(msg).toContain("92% used");
-      expect(msg).toContain("projected");
-    });
-
-    it("formats multiple windows", () => {
-      const notifier = new QuotaWarningNotifier();
-      const w1: QuotaWindow = {
-        label: "Credits / week",
-        usedPercent: 85,
-        resetsAt: new Date(Date.now() + 6 * 24 * 3600 * 1000),
-        windowSeconds: 7 * 24 * 3600,
-        usedValue: 85,
-        limitValue: 100,
-        showPace: true,
-        paceScale: 1 / 7,
-      };
-      const w2: QuotaWindow = {
-        label: "Requests / 5h",
-        usedPercent: 92,
-        resetsAt: new Date(Date.now() + 2 * 3600 * 1000),
-        windowSeconds: 5 * 3600,
-        usedValue: 92,
-        limitValue: 100,
-        showPace: false,
-      };
-      const msg = notifier.formatWarningMessage([
-        { window: w1, assessment: assessWindow(w1) },
-        { window: w2, assessment: assessWindow(w2) },
-      ]);
-      expect(msg).toContain("Credits / week");
-      expect(msg).toContain("Requests / 5h");
-      const lines = msg.split("\n");
-      expect(lines).toHaveLength(3); // header + 2 windows
-    });
-
-    it("includes severity label for non-none severities", () => {
-      const notifier = new QuotaWarningNotifier();
-      const w: QuotaWindow = {
-        label: "Requests / 5h",
-        usedPercent: 92,
-        resetsAt: new Date(Date.now() + 2 * 3600 * 1000),
-        windowSeconds: 5 * 3600,
-        usedValue: 92,
-        limitValue: 100,
-        showPace: false,
-      };
-      const msg = notifier.formatWarningMessage([
-        { window: w, assessment: assessWindow(w) },
-      ]);
-      expect(msg).toMatch(/\(high\)/);
-    });
-  });
-
-  describe("evaluate", () => {
-    it("does not notify for low-usage quotas", () => {
-      const notifier = new QuotaWarningNotifier();
-      const calls: Array<[string, string]> = [];
-      const notify: NotifyFn = (msg, lvl) => calls.push([msg, lvl]);
-
-      notifier.evaluate(baseQuotas, false, notify);
-      expect(calls).toHaveLength(0);
-    });
-
-    it("notifies for high-usage quotas with skipAlreadyWarned=false", () => {
-      const notifier = new QuotaWarningNotifier();
-      const calls: Array<[string, string]> = [];
-      const notify: NotifyFn = (msg, lvl) => calls.push([msg, lvl]);
-
-      const highUsageQuotas: QuotasResponse = {
-        ...baseQuotas,
-        rollingFiveHourLimit: {
-          nextTickAt: new Date(Date.now() + 2.5 * 3600 * 1000).toISOString(),
-          tickPercent: 10,
-          remaining: 5,
-          max: 100,
-          limited: false,
-        },
-      };
-
-      notifier.evaluate(highUsageQuotas, false, notify);
-      expect(calls).toHaveLength(1);
-      expect(calls[0][0]).toContain("Synthetic quota warning");
-    });
-
-    it("does not re-notify on same severity with skipAlreadyWarned=true", () => {
-      const notifier = new QuotaWarningNotifier();
-      const calls: Array<[string, string]> = [];
-      const notify: NotifyFn = (msg, lvl) => calls.push([msg, lvl]);
-
-      // 85% used (no pace) → warning severity, which has cooldown
-      const warningQuotas: QuotasResponse = {
-        ...baseQuotas,
-        rollingFiveHourLimit: {
-          nextTickAt: new Date(Date.now() + 2.5 * 3600 * 1000).toISOString(),
-          tickPercent: 10,
-          remaining: 15,
-          max: 100,
-          limited: false,
-        },
-      };
-
-      notifier.evaluate(warningQuotas, true, notify);
-      expect(calls).toHaveLength(1);
-
-      // Same severity, same data — should not re-notify (warning has cooldown)
-      notifier.evaluate(warningQuotas, true, notify);
-      expect(calls).toHaveLength(1);
-    });
-
-    it("notifies on severity escalation even with skipAlreadyWarned=true", () => {
-      const notifier = new QuotaWarningNotifier();
-      const calls: Array<[string, string]> = [];
-      const notify: NotifyFn = (msg, lvl) => calls.push([msg, lvl]);
-
-      // 92% used (no pace) → high severity
-      const highQuotas: QuotasResponse = {
-        ...baseQuotas,
-        rollingFiveHourLimit: {
-          nextTickAt: new Date(Date.now() + 2.5 * 3600 * 1000).toISOString(),
-          tickPercent: 10,
-          remaining: 8,
-          max: 100,
-          limited: false,
-        },
-      };
-
-      notifier.evaluate(highQuotas, true, notify);
-      expect(calls).toHaveLength(1);
-
-      // Escalate to critical (limited)
-      const criticalQuotas: QuotasResponse = {
-        ...baseQuotas,
-        rollingFiveHourLimit: {
-          nextTickAt: new Date(Date.now() + 2.5 * 3600 * 1000).toISOString(),
-          tickPercent: 10,
-          remaining: 2,
-          max: 100,
-          limited: true,
-        },
-      };
-
-      notifier.evaluate(criticalQuotas, true, notify);
-      expect(calls).toHaveLength(2);
-      expect(calls[1][1]).toBe("error");
-    });
-  });
-
-  describe("notification flow (shouldNotify + markNotified integration)", () => {
-    it("notifies once on first warning, blocks repeat, notifies on escalation", () => {
-      const notifier = new QuotaWarningNotifier();
-      expect(notifier.shouldNotify("Credits / week", "warning")).toBe(true);
-      notifier.markNotified("Credits / week", "warning");
-
-      expect(notifier.shouldNotify("Credits / week", "warning")).toBe(false);
-
-      expect(notifier.shouldNotify("Credits / week", "high")).toBe(true);
-      notifier.markNotified("Credits / week", "high");
-
-      expect(notifier.shouldNotify("Credits / week", "high")).toBe(true);
-    });
-
-    it("allows re-notification after clear", () => {
-      const notifier = new QuotaWarningNotifier();
-      expect(notifier.shouldNotify("Credits / week", "warning")).toBe(true);
-      notifier.markNotified("Credits / week", "warning");
-      expect(notifier.shouldNotify("Credits / week", "warning")).toBe(false);
-
-      notifier.clearAlertState();
-
-      expect(notifier.shouldNotify("Credits / week", "warning")).toBe(true);
-    });
-
-    it("tracks windows independently", () => {
-      const notifier = new QuotaWarningNotifier();
-      notifier.markNotified("Credits / week", "warning");
-      expect(notifier.shouldNotify("Credits / week", "warning")).toBe(false);
-      expect(notifier.shouldNotify("Search / hour", "warning")).toBe(true);
-    });
-  });
-});

package/src/utils/quotas-severity.test.ts

@@ -1,295 +0,0 @@
-import {
-  afterEach,
-  assert,
-  beforeEach,
-  describe,
-  expect,
-  it,
-  vi,
-} from "vitest";
-import {
-  assessWindow,
-  getPacePercent,
-  getProjectedPercent,
-  getSeverityColor,
-  parseCurrency,
-  type QuotaWindow,
-  safePercent,
-} from "./quotas-severity";
-
-// Helper to create a QuotaWindow with sensible defaults
-function makeWindow(
-  overrides: Partial<QuotaWindow> & Pick<QuotaWindow, "usedPercent">,
-): QuotaWindow {
-  const windowSeconds = overrides.windowSeconds ?? 3600;
-  // resetsAt defaults to 30 minutes from now (50% through a 1h window)
-  const resetsAt =
-    overrides.resetsAt ?? new Date(Date.now() + windowSeconds * 500);
-  return {
-    label: "Test Window",
-    resetsAt,
-    windowSeconds,
-    usedValue: 0,
-    limitValue: 100,
-    ...overrides,
-  };
-}
-
-describe("safePercent", () => {
-  it("returns 0 for zero/invalid limit", () => {
-    expect(safePercent(50, 0)).toBe(0);
-    expect(safePercent(50, -1)).toBe(0);
-    expect(safePercent(50, NaN)).toBe(0);
-    expect(safePercent(NaN, 100)).toBe(0);
-  });
-
-  it("computes correct percentage", () => {
-    expect(safePercent(50, 100)).toBe(50);
-    expect(safePercent(75, 100)).toBe(75);
-    expect(safePercent(1, 3)).toBeCloseTo(33.33);
-  });
-
-  it("clamps to 0-100", () => {
-    expect(safePercent(150, 100)).toBe(100);
-    expect(safePercent(-10, 100)).toBe(0);
-  });
-});
-
-describe("parseCurrency", () => {
-  it("parses dollar amounts", () => {
-    expect(parseCurrency("$1,234.56")).toBe(1234.56);
-    expect(parseCurrency("$10.00")).toBe(10);
-  });
-
-  it("returns 0 for invalid input", () => {
-    expect(parseCurrency("")).toBe(0);
-    expect(parseCurrency("abc")).toBe(0);
-  });
-});
-
-describe("getPacePercent", () => {
-  it("returns null for zero window", () => {
-    const w = makeWindow({ usedPercent: 50, windowSeconds: 0 });
-    expect(getPacePercent(w)).toBeNull();
-  });
-
-  it("returns ~50 for a window 50% elapsed", () => {
-    const w = makeWindow({
-      usedPercent: 50,
-      windowSeconds: 3600,
-      resetsAt: new Date(Date.now() + 1800 * 1000), // 30 min remaining
-    });
-    const pace = getPacePercent(w);
-    assert(pace, "pace should not be null");
-    expect(pace).toBeCloseTo(50, 0);
-  });
-
-  it("clamps to 0-100", () => {
-    const w = makeWindow({
-      usedPercent: 50,
-      windowSeconds: 3600,
-      resetsAt: new Date(Date.now() + 7200 * 1000), // way past
-    });
-    expect(getPacePercent(w)).toBe(0);
-  });
-});
-
-describe("getProjectedPercent", () => {
-  it("returns usedPercent when no pace", () => {
-    expect(getProjectedPercent(42, null)).toBe(42);
-  });
-
-  it("projects based on pace", () => {
-    // 50% used, 25% through window => projected 200%
-    expect(getProjectedPercent(50, 25)).toBe(200);
-  });
-
-  it("uses minimum pace of 5", () => {
-    // Very low pace should not blow up projection
-    expect(getProjectedPercent(1, 0)).toBe(20); // 1 / 5 * 100
-    expect(getProjectedPercent(1, 1)).toBe(20); // clamped to 5
-  });
-});
-
-describe("assessWindow", () => {
-  describe("no pace (showPace: false)", () => {
-    it("returns none for low usage", () => {
-      const w = makeWindow({ usedPercent: 10, showPace: false });
-      expect(assessWindow(w).severity).toBe("none");
-    });
-
-    it("returns warning at 80% projected", () => {
-      const w = makeWindow({ usedPercent: 85, showPace: false });
-      expect(assessWindow(w).severity).toBe("warning");
-    });
-
-    it("returns high at 90% projected", () => {
-      const w = makeWindow({ usedPercent: 92, showPace: false });
-      expect(assessWindow(w).severity).toBe("high");
-    });
-
-    it("returns critical at 100% projected", () => {
-      const w = makeWindow({ usedPercent: 100, showPace: false });
-      expect(assessWindow(w).severity).toBe("critical");
-    });
-
-    it("returns critical for limited window regardless of usage", () => {
-      const w = makeWindow({ usedPercent: 5, showPace: false, limited: true });
-      expect(assessWindow(w).severity).toBe("critical");
-    });
-  });
-
-  describe("with pace (showPace: true)", () => {
-    beforeEach(() => {
-      vi.useFakeTimers();
-      vi.setSystemTime(new Date("2026-01-01T00:00:00Z"));
-    });
-
-    afterEach(() => {
-      vi.useRealTimers();
-    });
-
-    it("returns none when usage is low and pace is normal", () => {
-      const w = makeWindow({
-        usedPercent: 20,
-        showPace: true,
-        paceScale: 1,
-        windowSeconds: 3600,
-        resetsAt: new Date(Date.now() + 1800 * 1000), // 50% through
-      });
-      expect(assessWindow(w).severity).toBe("none");
-    });
-
-    it("returns warning when projected exceeds warn threshold", () => {
-      // 50% used, 50% through => projected 100%, well above warn at 50% progress (190)
-      // But usedFloor at 50% progress is 20.5, so 50% > 20.5 => passes floor check
-      const w = makeWindow({
-        usedPercent: 50,
-        showPace: true,
-        paceScale: 1,
-        windowSeconds: 3600,
-        resetsAt: new Date(Date.now() + 1800 * 1000),
-      });
-      const result = assessWindow(w);
-      // projected = 50 / 50 * 100 = 100
-      // At 50% progress: warn = 260 - (260-120)*0.5 = 190, high = 232.5, critical = 285
-      // 100 < 190 => none actually. Let me pick better numbers.
-      expect(result.severity).toBe("none");
-    });
-
-    it("returns warning when projected exceeds dynamic warn threshold", () => {
-      // 95% used, 50% through => projected 190%
-      // At 50% progress: warn = 190, so 190 >= 190 => warning
-      // usedFloor at 50% = 20.5, 95 >= 20.5 => passes
-      const w = makeWindow({
-        usedPercent: 95,
-        showPace: true,
-        paceScale: 1,
-        windowSeconds: 3600,
-        resetsAt: new Date(Date.now() + 1800 * 1000),
-      });
-      const result = assessWindow(w);
-      expect(result.severity).toBe("warning");
-    });
-
-    it("uses paceScale to normalize pace", () => {
-      // Weekly window with daily pace: paceScale = 1/7
-      // At 50% through the day (12h), raw pace = 50%, scaled = 50/7 ≈ 7.14%
-      // So progress ≈ 0.0714, projected = 95 / max(5, 7.14) * 100 ≈ 1330%
-      const w = makeWindow({
-        usedPercent: 95,
-        showPace: true,
-        paceScale: 1 / 7,
-        windowSeconds: 7 * 24 * 3600, // 1 week
-        resetsAt: new Date(Date.now() + 6 * 24 * 3600 * 1000), // 6 days remaining
-      });
-      const result = assessWindow(w);
-      // With paceScale applied, projected should be much higher
-      assert(result.pacePercent, "pacePercent should not be null");
-      expect(result.pacePercent).toBeLessThan(15); // scaled down
-      expect(result.projectedPercent).toBeGreaterThan(500);
-      expect(result.severity).toBe("critical");
-    });
-
-    it("does not use pace when showPace is false", () => {
-      // Same timestamps but showPace: false
-      const w = makeWindow({
-        usedPercent: 50,
-        showPace: false,
-        windowSeconds: 5 * 3600,
-        resetsAt: new Date(Date.now() + 2.5 * 3600 * 1000),
-      });
-      const result = assessWindow(w);
-      expect(result.pacePercent).toBeNull();
-      expect(result.progress).toBeNull();
-      // Static thresholds: 50% < 80 => none
-      expect(result.severity).toBe("none");
-    });
-
-    it("suppresses warning when usage is below usedFloor", () => {
-      // Early window: raw pace ~10%, with paceScale=1 => progress=0.1
-      // usedFloor at 10% progress = 33 - (33-8)*0.1 = 33 - 2.5 = 30.5
-      // If used = 15% (< 30.5), projected might exceed warn but floor blocks it
-      const w = makeWindow({
-        usedPercent: 15,
-        showPace: true,
-        paceScale: 1,
-        windowSeconds: 3600,
-        // 10% through: 54 min remaining
-        resetsAt: new Date(Date.now() + 54 * 60 * 1000),
-      });
-      const result = assessWindow(w);
-      // projected = 15 / 10 * 100 = 150, which exceeds warn at 10% progress (246)
-      // But usedFloor = 30.5, and 15 < 30.5 => suppressed
-      expect(result.severity).toBe("none");
-    });
-
-    it("allows warning when usage exceeds usedFloor", () => {
-      // Same timing but higher usage
-      const w = makeWindow({
-        usedPercent: 50,
-        showPace: true,
-        paceScale: 1,
-        windowSeconds: 3600,
-        resetsAt: new Date(Date.now() + 54 * 60 * 1000),
-      });
-      const result = assessWindow(w);
-      // projected = 50 / 10 * 100 = 500
-      // warn at 10% progress = 246, high = 282.5, critical = 357
-      // 500 >= 357 => critical, usedFloor = 30.5, 50 >= 30.5 => passes
-      expect(result.severity).toBe("critical");
-    });
-  });
-
-  describe("limited flag", () => {
-    it("overrides severity to critical even with low usage", () => {
-      const w = makeWindow({
-        usedPercent: 5,
-        showPace: false,
-        limited: true,
-      });
-      expect(assessWindow(w).severity).toBe("critical");
-    });
-
-    it("overrides severity to critical even with pace showing none", () => {
-      const w = makeWindow({
-        usedPercent: 5,
-        showPace: true,
-        paceScale: 1,
-        limited: true,
-        windowSeconds: 3600,
-        resetsAt: new Date(Date.now() + 54 * 60 * 1000),
-      });
-      expect(assessWindow(w).severity).toBe("critical");
-    });
-  });
-});
-
-describe("getSeverityColor", () => {
-  it("maps severity levels to display colors", () => {
-    expect(getSeverityColor("none")).toBe("success");
-    expect(getSeverityColor("warning")).toBe("warning");
-    expect(getSeverityColor("high")).toBe("error");
-    expect(getSeverityColor("critical")).toBe("error");
-  });
-});