pi-provider-quota 0.1.0

package/README.md

@@ -0,0 +1,92 @@
+# pi-provider-quota
+
+Track live quota usage for **Z.Ai**, **Kimi Code**, **Ollama Cloud**, and **DeepSeek** in [pi](https://pi.dev)'s status bar.
+
+## What it does
+
+Polls provider APIs and Ollama's settings page every 30 seconds, then displays a color-coded quota bar:
+
+```
+quota: zai pro · 5h: 🟡 62% · wk: 🟢 34%
+quota: ollama pro · 5h: 🟢 18% · reset 2h 30m · wk: 🟢 5% · wk reset 3d 4h
+quota: ds · ¥12.50 · ✅ Yes
+```
+
+Color thresholds: 🟢 < 50%, 🟡 50–79%, 🔴 ≥ 80%.
+
+## Installation
+
+```bash
+pi install git:github.com/ronnieops/pi-provider-quota
+```
+
+## Setup
+
+Store your credentials in `~/.pi/agent/auth.json`:
+
+```json
+{
+  "zai": { "key": "sk-..." },
+  "kimi-coding": { "key": "sk-..." },
+  "deepseek": { "key": "sk-..." },
+  "ollama-session": { "key": "<__Secure-session cookie value>", "aid": "<aid cookie value>" }
+}
+```
+
+Environment variable fallbacks are also supported (`ZAI_API_KEY`, `KIMI_CODING_API_KEY`, `DEEPSEEK_API_KEY`).
+
+Select a tracked model in pi. Quota status appears in the status bar automatically.
+
+## Providers
+
+| Provider | Live quota source | Fields displayed |
+|----------|-------------------|------------------|
+| **Z.Ai** | Dashboard API | 5h %, weekly %, reset times, plan tier, MCP model breakdown |
+| **Kimi Code** | Billing API (web JWT) | 5h remaining, weekly remaining, weekly reset |
+| **Ollama Cloud** | Settings page (session cookie) | Session %, weekly %, session reset, weekly reset, plan tier |
+| **DeepSeek** | Balance API | Total balance, availability flag |
+
+Ollama falls back to local GPU-time weighted turn counting when no session cookie is configured.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/quota` | Detailed breakdown: live percentages, turn counts, reset times, cookie status, raw headers |
+| `/quota-plan <tier>` | Override detected plan tier for the active provider |
+| `/quota-json` | JSON snapshot of all quota state (for scripting) |
+
+## LLM Tool
+
+The `provider_quota` tool is registered automatically. When an LLM calls it, it returns a JSON object with live percentages, plan tier, turn counts, reset times, and any fetch errors for the active provider. This lets the agent reason about remaining quota without manual `/quota` calls.
+
+## Security
+
+- API keys and session cookies are stored in `~/.pi/agent/auth.json` only — never sent to any third party besides the provider's own API
+- Credentials are used in HTTP headers only, never stored in state, never logged, never displayed
+- HTML scraping uses regex captures that are numeric-only or fixed-alternation — no scraped text reaches output
+- Error messages are sanitized — no response bodies, headers, or credential fragments in status output
+- Session persistence strips credentials and raw headers before saving
+
+## Architecture
+
+Single-file extension (`extensions/provider-quota.ts`, ~1100 lines) with:
+
+- **Discriminated-union result types** (`OllamaQuotaResult`, `OllamaCookieResult`) — no `unknown` returns
+- **Stale-data clearing** — all live fields nulled on fetch failure; plan tier preserved across transient errors
+- **Session persistence** — quota state survives pi restarts (sanitized; credentials and raw headers stripped)
+
+## Development
+
+```bash
+npm install
+npx tsc --noEmit --target esnext --module esnext --moduleResolution bundler --strict --skipLibCheck --esModuleInterop extensions/provider-quota.ts
+```
+
+## License
+
+MIT
+
+---
+
+<p align="center">Proudly created with <a href="https://pi.dev">pi</a></p>

package/extensions/provider-quota.ts

@@ -0,0 +1,1144 @@
+/**
+ * pi-provider-quota
+ * Track Z.Ai GLM Coding Plan, Kimi Code, Ollama Cloud, and DeepSeek quota in pi's status bar.
+ */
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "typebox";
+
+// =============================================================================
+// Types
+// =============================================================================
+
+interface QuotaState {
+  provider: string;
+  model: string;
+  plan: string;
+  
+  // Turn counting (all providers)
+  turnsUsed5h: number;
+  quotaUsed5h: number;
+  cycleStart5h: number | null;
+  turnsUsedWeekly: number;
+  weeklyStart: number | null;
+  
+  // Live quota (Z.Ai, Kimi, DeepSeek - refreshed every 30s)
+  live5hPercentage: number | null;
+  liveWeeklyPercentage: number | null;
+  livePlan: string | null;
+  live5hResetAt: number | null;
+  liveWeeklyResetAt: number | null;
+  lastSuccessfulFetchAt: number | null;
+  
+  // Kimi specific
+  liveKimi5hRemaining: number | null;
+  liveKimiWeeklyRemaining: number | null;
+  liveKimiWeeklyResetAt: number | null;
+  kimiJwtExpired: boolean;
+  
+  // DeepSeek specific
+  liveDsAvailable: boolean | null;
+  liveDsTotalBalance: string | null;
+  liveDsCurrency: string | null;
+  
+  // Ollama specific (GPU-time weighted + live quota)
+  ollamaGpuUnitsUsed: number;
+  liveOllama5hPercentage: number | null;
+  liveOllamaWeeklyPercentage: number | null;
+  liveOllamaResetAt: number | null;
+  liveOllamaWeeklyResetAt: number | null;
+  
+  // MCP (Z.Ai)
+  liveMcpDetails: Array<{ modelCode: string; usage: number }>;
+  
+  // Header-based quota tracking
+  headerPromptsLimit: number | null;
+  rawHeaders: Record<string, string>;
+  
+  // Error handling
+  lastFetchError: string | null;
+  lastResponseAt: number | null;
+}
+
+interface TierData {
+  limit5h: number;
+  limitWeekly: number;
+}
+
+// =============================================================================
+// Config
+// =============================================================================
+
+const ZAI_TIERS: Record<string, TierData> = {
+  lite:    { limit5h: 80,    limitWeekly: 400  },
+  pro:     { limit5h: 400,   limitWeekly: 2000 },
+  max:     { limit5h: 1600,  limitWeekly: 8000 },
+};
+
+const KIMI_TIERS: Record<string, TierData> = {
+  moderato:   { limit5h: 100,   limitWeekly: 100  },
+  allegretto: { limit5h: 100,   limitWeekly: 600  },
+  vivace:     { limit5h: 100,   limitWeekly: 1200 },
+};
+
+const OLLAMA_TIERS: Record<string, TierData> = {
+  free: { limit5h: 500,   limitWeekly: 3000   },
+  pro:  { limit5h: 2400,  limitWeekly: 13700  },
+  max:  { limit5h: 12000, limitWeekly: 68500  },
+};
+
+// =============================================================================
+// State
+// =============================================================================
+
+let state: QuotaState = createFreshState();
+
+function createFreshState(): QuotaState {
+  return {
+    provider: "",
+    model: "",
+    plan: "",
+    turnsUsed5h: 0,
+    quotaUsed5h: 0,
+    cycleStart5h: null,
+    turnsUsedWeekly: 0,
+    weeklyStart: null,
+    live5hPercentage: null,
+    liveWeeklyPercentage: null,
+    livePlan: null,
+    live5hResetAt: null,
+    liveWeeklyResetAt: null,
+    lastSuccessfulFetchAt: null,
+    liveKimi5hRemaining: null,
+    liveKimiWeeklyRemaining: null,
+    liveKimiWeeklyResetAt: null,
+    kimiJwtExpired: false,
+    liveDsAvailable: null,
+    liveDsTotalBalance: null,
+    liveDsCurrency: null,
+    ollamaGpuUnitsUsed: 0,
+    liveOllama5hPercentage: null,
+    liveOllamaWeeklyPercentage: null,
+    liveOllamaResetAt: null,
+    liveOllamaWeeklyResetAt: null,
+    liveMcpDetails: [],
+    headerPromptsLimit: null,
+    rawHeaders: {},
+    lastFetchError: null,
+    lastResponseAt: null,
+  };
+}
+
+const ALLOWED_KEYS = new Set(Object.keys(createFreshState()));
+
+function resetProviderData(): void {
+  state.live5hPercentage = null;
+  state.liveWeeklyPercentage = null;
+  state.livePlan = null;
+  state.live5hResetAt = null;
+  state.liveWeeklyResetAt = null;
+  state.lastSuccessfulFetchAt = null;
+  state.liveKimi5hRemaining = null;
+  state.liveKimiWeeklyRemaining = null;
+  state.liveKimiWeeklyResetAt = null;
+  state.kimiJwtExpired = false;
+  state.liveDsAvailable = null;
+  state.liveDsTotalBalance = null;
+  state.liveDsCurrency = null;
+  state.ollamaGpuUnitsUsed = 0;
+  state.liveOllama5hPercentage = null;
+  state.liveOllamaWeeklyPercentage = null;
+  state.liveOllamaResetAt = null;
+  state.liveOllamaWeeklyResetAt = null;
+  state.liveMcpDetails = [];
+  state.headerPromptsLimit = null;
+  state.rawHeaders = {};
+  state.lastFetchError = null;
+}
+
+function sanitizeState(data: unknown): Partial<QuotaState> {
+  if (!data || typeof data !== "object") return {};
+  return Object.fromEntries(
+    Object.entries(data as Record<string, unknown>).filter(
+      ([k]) => ALLOWED_KEYS.has(k),
+    ),
+  ) as Partial<QuotaState>;
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+function isZai(name: string): boolean {
+  const normalized = name.toLowerCase().replace(/[^a-z0-9._-]/g, "");
+  return ["zai", "glm"].some(p => normalized.includes(p));
+}
+
+function isKimi(name: string): boolean {
+  const normalized = name.toLowerCase().replace(/[^a-z0-9._-]/g, "");
+  return ["kimi", "k2p6", "kimi-for-coding", "moonshot"].some(p => normalized.includes(p));
+}
+
+function isOllama(name: string): boolean {
+  const normalized = name.toLowerCase().replace(/[^a-z0-9._-]/g, "");
+  return ["ollama", "ollama-cloud"].some(p => normalized.includes(p));
+}
+
+function isDeepseek(name: string): boolean {
+  const normalized = name.toLowerCase().replace(/[^a-z0-9._-]/g, "");
+  return ["deepseek"].some(p => normalized.includes(p));
+}
+
+function isTrackedProvider(name: string): boolean {
+  return isZai(name) || isKimi(name) || isOllama(name) || isDeepseek(name);
+}
+
+function getLimit(): number | null {
+  if (isDeepseek(state.provider)) return null;
+  if (state.headerPromptsLimit && !isOllama(state.provider)) {
+    return state.headerPromptsLimit;
+  }
+  const tiers = getProviderTiers();
+  const tier = tiers[state.plan];
+  return tier ? tier.limit5h : null;
+}
+
+function getWeeklyLimit(): number | null {
+  if (isDeepseek(state.provider)) return null;
+  const tiers = getProviderTiers();
+  const tier = tiers[state.plan];
+  return tier ? tier.limitWeekly : null;
+}
+
+function getProviderTiers(): Record<string, TierData> {
+  if (isZai(state.provider)) return ZAI_TIERS;
+  if (isKimi(state.provider)) return KIMI_TIERS;
+  if (isOllama(state.provider)) return OLLAMA_TIERS;
+  return {};
+}
+
+function ollamaGpuMultiplier(modelId: string): number {
+  const lower = modelId.toLowerCase();
+  if (lower.includes("405b")) return 50;
+  if (lower.includes("70b") || lower.includes("72b")) return 25;
+  if (lower.includes("34b") || lower.includes("30b")) return 10;
+  if (lower.includes("14b")) return 4;
+  if (lower.includes("8b") || lower.includes("7b")) return 2;
+  return 1;
+}
+
+function quotaMultiplier(modelId: string): number {
+  if (isOllama(state.provider)) {
+    return ollamaGpuMultiplier(modelId);
+  }
+  if (isZai(state.provider) && isPeakHours()) {
+    return 3;
+  }
+  return 1;
+}
+
+function isPeakHours(): boolean {
+  const now = new Date();
+  const utc8Hour = (now.getUTCHours() + 8) % 24;
+  return utc8Hour >= 14 && utc8Hour < 18;
+}
+
+function isCycleExpired(): boolean {
+  if (!state.cycleStart5h) return false;
+  return Date.now() - state.cycleStart5h >= 5 * 60 * 60 * 1000;
+}
+
+function maybeRotateCycle(): boolean {
+  if (!isCycleExpired()) return false;
+  state.turnsUsed5h = 0;
+  state.quotaUsed5h = 0;
+  state.cycleStart5h = Date.now();
+  state.headerPromptsLimit = null;
+  return true;
+}
+
+function maybeRotateWeekly(): void {
+  if (!state.weeklyStart) {
+    state.weeklyStart = Date.now();
+    return;
+  }
+  const weekMs = 7 * 24 * 60 * 60 * 1000;
+  if (Date.now() - state.weeklyStart >= weekMs) {
+    state.turnsUsedWeekly = 0;
+    state.weeklyStart = Date.now();
+  }
+}
+
+function relativeTime(targetMs: number | null): string {
+  if (!targetMs) return "—";
+  const diff = targetMs - Date.now();
+  if (diff <= 0) return "0m";
+  const hours = Math.floor(diff / (60 * 60 * 1000));
+  const mins = Math.floor((diff % (60 * 60 * 1000)) / (60 * 1000));
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${mins}m`;
+  return `${mins}m`;
+}
+
+function readApiKey(provider: string): string | null {
+  try {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    const authPath = `${home}/.pi/agent/auth.json`;
+    const { existsSync, readFileSync } = require("node:fs");
+    if (!existsSync(authPath)) {
+      const envKey = process.env[`${provider.toUpperCase().replace(/[- ]/g, "_")}_API_KEY`];
+      return envKey || null;
+    }
+    const raw = readFileSync(authPath, "utf8");
+    const json = JSON.parse(raw);
+    const aliases: Record<string, string[]> = {
+      zai: ["zai", "zai-api", "glm"],
+      "kimi-coding": ["kimi-coding", "kimi", "moonshot"],
+      deepseek: ["deepseek", "deepseek-api"],
+      ollama: ["ollama", "ollama-cloud"],
+    };
+    const keys = aliases[provider] || [provider];
+    for (const key of keys) {
+      if (json[key]?.key) return json[key].key;
+      if (json[key]?.apiKey) return json[key].apiKey;
+    }
+    const envName = provider.toUpperCase().replace(/[- ]/g, "_") + "_API_KEY";
+    return process.env[envName] || null;
+  } catch {
+    return null;
+  }
+}
+
+function readKimiWebJwt(): string | null {
+  try {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    const settingsPath = `${home}/.pi/agent/settings.json`;
+    const authPath = `${home}/.pi/agent/auth.json`;
+    const { existsSync, readFileSync } = require("node:fs");
+    
+    // Check settings.json first (deprecated location, but supported)
+    if (existsSync(settingsPath)) {
+      const raw = readFileSync(settingsPath, "utf8");
+      const json = JSON.parse(raw);
+      if (typeof json.kimiWebJwt === "string" && json.kimiWebJwt.length > 0) {
+        return json.kimiWebJwt;
+      }
+    }
+    
+    // Check auth.json
+    if (existsSync(authPath)) {
+      const raw = readFileSync(authPath, "utf8");
+      const json = JSON.parse(raw);
+      if (json["kimi-web"]?.key) return json["kimi-web"].key;
+      if (json["kimi-web-jwt"]?.key) return json["kimi-web-jwt"].key;
+    }
+    
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function base64UrlDecode(str: string): string {
+  let s = str.replace(/-/g, "+").replace(/_/g, "/");
+  while (s.length % 4) s += "=";
+  return Buffer.from(s, "base64").toString("utf8");
+}
+
+function getJwtExpiry(jwt: string): number | null {
+  try {
+    const parts = jwt.split(".");
+    if (parts.length !== 3) return null;
+    const payload = JSON.parse(base64UrlDecode(parts[1]));
+    const exp = payload.exp;
+    if (typeof exp === "number" && exp > 0) return exp;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function dsCurrencyPrefix(currency: string | null): string {
+  if (currency === "CNY") return "¥";
+  return "$";
+}
+
+// =============================================================================
+// API Calls
+// =============================================================================
+
+async function fetchLiveQuota(apiKey: string): Promise<unknown> {
+  try {
+    const res = await fetch("https://z.ai/api/monitor/usage/quota/limit", {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+      },
+      signal: AbortSignal.timeout(8000),
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+function applyLiveData(data: unknown, apiState: QuotaState): boolean {
+  if (!data || typeof data !== "object") return false;
+  const d = data as Record<string, unknown>;
+  if (typeof d.level === "string") {
+    apiState.livePlan = d.level;
+  }
+  if (Array.isArray(d.limits)) {
+    let found5h = false;
+    let foundWeekly = false;
+    for (const limit of d.limits) {
+      if (!limit || typeof limit !== "object") continue;
+      const l = limit as Record<string, unknown>;
+      if (l.type === "TOKENS_LIMIT" && l.unit === 3 && !found5h) {
+        if (typeof l.percentage === "number") apiState.live5hPercentage = l.percentage;
+        if (typeof l.nextResetTime === "number") apiState.live5hResetAt = l.nextResetTime;
+        found5h = true;
+      }
+      if (l.type === "TOKENS_LIMIT" && l.unit === 6 && !foundWeekly) {
+        if (typeof l.percentage === "number") apiState.liveWeeklyPercentage = l.percentage;
+        if (typeof l.nextResetTime === "number") apiState.liveWeeklyResetAt = l.nextResetTime;
+        foundWeekly = true;
+      }
+      if (l.type === "TIME_LIMIT" && l.unit === 5) {
+        if (Array.isArray(l.usageDetails)) {
+          apiState.liveMcpDetails = l.usageDetails.map((item: unknown) => {
+            const i = item as Record<string, unknown>;
+            return {
+              modelCode: String(i.modelCode ?? ""),
+              usage: typeof i.usage === "number" ? i.usage : 0,
+            };
+          });
+        }
+      }
+    }
+  }
+  return true;
+}
+
+async function fetchKimiLiveQuota(webJwt: string): Promise<unknown> {
+  try {
+    const res = await fetch("https://www.kimi.com/apiv2/kimi.gateway.billing.v1.BillingService/GetUsages", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${webJwt}`,
+        "connect-protocol-version": "1",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ scope: ["FEATURE_CODING"] }),
+      signal: AbortSignal.timeout(8000),
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+function applyKimiLiveData(data: unknown, apiState: QuotaState): boolean {
+  if (!data || typeof data !== "object") return false;
+  const d = data as Record<string, unknown>;
+  
+  if (Array.isArray(d.usages)) {
+    const codingUsage = d.usages.find((u: unknown) => {
+      const usage = u as Record<string, unknown>;
+      return usage.scope === "FEATURE_CODING";
+    });
+    
+    if (codingUsage && typeof codingUsage === "object") {
+      const cu = codingUsage as Record<string, unknown>;
+      
+      // Weekly data
+      if (cu.detail && typeof cu.detail === "object") {
+        const detail = cu.detail as Record<string, unknown>;
+        const remaining = parseInt(String(detail.remaining ?? ""), 10);
+        if (!Number.isNaN(remaining)) {
+          apiState.liveKimiWeeklyRemaining = remaining;
+        }
+        const resetTime = detail.resetTime;
+        if (typeof resetTime === "string" && resetTime) {
+          const ts = new Date(resetTime).getTime();
+          if (!Number.isNaN(ts)) {
+            apiState.liveKimiWeeklyResetAt = ts;
+          }
+        }
+      }
+      
+      // 5h rate limit
+      if (Array.isArray(cu.limits)) {
+        const windowLimit = cu.limits.find((l: unknown) => {
+          const limit = l as Record<string, unknown>;
+          return limit.window?.duration === 300;
+        });
+        if (windowLimit && typeof windowLimit === "object") {
+          const wl = windowLimit as Record<string, unknown>;
+          if (wl.detail && typeof wl.detail === "object") {
+            const wld = wl.detail as Record<string, unknown>;
+            const remaining = parseInt(String(wld.remaining ?? ""), 10);
+            if (!Number.isNaN(remaining)) {
+              apiState.liveKimi5hRemaining = remaining;
+            }
+          }
+        }
+      }
+    }
+  }
+  
+  // Update plan from limit
+  if (typeof d.totalQuota === "object" && d.totalQuota) {
+    const tq = d.totalQuota as Record<string, unknown>;
+    const limit = parseInt(String(tq.limit ?? ""), 10);
+    if (!Number.isNaN(limit)) {
+      if (limit >= 1200) apiState.livePlan = "vivace";
+      else if (limit >= 600) apiState.livePlan = "allegretto";
+      else if (limit >= 100) apiState.livePlan = "moderato";
+    }
+  }
+  
+  return true;
+}
+
+async function fetchDeepSeekBalance(apiKey: string): Promise<unknown> {
+  try {
+    const res = await fetch("https://api.deepseek.com/user/balance", {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+      },
+      signal: AbortSignal.timeout(8000),
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+function applyDeepSeekData(data: unknown, apiState: QuotaState): boolean {
+  if (!data || typeof data !== "object") return false;
+  const d = data as Record<string, unknown>;
+  
+  if (typeof d.is_available === "boolean") {
+    apiState.liveDsAvailable = d.is_available;
+  }
+  
+  if (Array.isArray(d.balance_infos) && d.balance_infos.length > 0) {
+    const info = d.balance_infos.find((i: unknown) => {
+      const item = i as Record<string, unknown>;
+      return item.currency === "USD" || item.currency === "CNY";
+    }) || d.balance_infos[0];
+    
+    if (info && typeof info === "object") {
+      const i = info as Record<string, unknown>;
+      if (typeof i.total_balance === "string") {
+        apiState.liveDsTotalBalance = i.total_balance;
+      }
+      if (typeof i.currency === "string") {
+        apiState.liveDsCurrency = i.currency;
+      }
+    }
+  }
+  
+  return true;
+}
+
+// =============================================================================
+// Ollama Cloud Session Cookie & Live Quota
+// =============================================================================
+
+type OllamaCookieResult =
+  | { ok: true; session: string; aid: string | null }
+  | { ok: false; error: string };
+
+function readOllamaSessionCookie(): OllamaCookieResult {
+  try {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    const authPath = `${home}/.pi/agent/auth.json`;
+    const { existsSync, readFileSync } = require("node:fs");
+    
+    if (!existsSync(authPath)) {
+      return { ok: false, error: "auth.json not found" };
+    }
+    let json: Record<string, unknown>;
+    try {
+      json = JSON.parse(readFileSync(authPath, "utf8"));
+    } catch {
+      return { ok: false, error: "auth.json is corrupted" };
+    }
+    const ollamaSession = json["ollama-session"] as Record<string, unknown> | undefined;
+    const ollamaGeneral = json["ollama"] as Record<string, unknown> | undefined;
+    if (ollamaSession?.key) {
+      return {
+        ok: true,
+        session: ollamaSession.key as string,
+        aid: (ollamaSession.aid as string | null) ?? null,
+      };
+    }
+    if (ollamaGeneral?.session) {
+      return {
+        ok: true,
+        session: ollamaGeneral.session as string,
+        aid: (ollamaGeneral.aid as string | null) ?? null,
+      };
+    }
+    return { ok: false, error: "No ollama-session key in auth.json" };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : "Failed to read auth.json" };
+  }
+}
+
+type OllamaQuotaResult =
+  | { ok: true; sessionPercentage: number | null; weeklyPercentage: number | null; sessionResetAt: number | null; weeklyResetAt: number | null; plan: string | null }
+  | { ok: false; error: string };
+
+async function fetchOllamaLiveQuota(sessionCookie: string, aidCookie?: string | null): Promise<OllamaQuotaResult> {
+  try {
+    let cookie = `__Secure-session=${sessionCookie}`;
+    if (aidCookie) cookie += `; aid=${aidCookie}`;
+    
+    const res = await fetch("https://ollama.com/settings", {
+      headers: {
+        accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "accept-language": "en-US,en;q=0.9",
+        cookie,
+        "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
+      },
+      signal: AbortSignal.timeout(10000),
+    });
+
+    if (!res.ok) {
+      return { ok: false, error: `HTTP ${res.status}` };
+    }
+
+    const html = await res.text();
+
+    // Strip HTML tags to get clean text content — collapse to single-line prose
+    // so regexes can match naturally across inline elements like <span>54.1</span>%
+    const text = html
+      .replace(/<script[>\s][\s\S]*?<\/script>/g, " ")
+      .replace(/<style[>\s][\s\S]*?<\/style>/g, " ")
+      .replace(/<svg[\s\S]*?<\/svg>/g, " ")
+      .replace(/<[^>]+>/g, " ")
+      .replace(/\s+/g, " ")
+      .trim();
+
+    // Extract usage percentages and reset times from the collapsed text
+    const sessionMatch = text.match(/Session\s+usage[\s:]+(\d+\.?\d*)\s*%/i);
+    const weeklyMatch = text.match(/Weekly\s+usage[\s:]+(\d+\.?\d*)\s*%/i);
+    const sessionResetMatch = text.match(/Session.*?Resets?\s+in\s+(\d+)\s*(?:hours?|hrs?|h)/i);
+    const weeklyResetMatch = text.match(/Weekly.*?Resets?\s+in\s+(\d+)\s*(?:days?|d)/i);
+
+    if (!sessionMatch && !weeklyMatch) {
+      return { ok: false, error: "Quota data not found in page" };
+    }
+
+    const rawSession = sessionMatch ? parseFloat(sessionMatch[1]) : null;
+    const rawWeekly = weeklyMatch ? parseFloat(weeklyMatch[1]) : null;
+    if ((rawSession !== null && !Number.isFinite(rawSession)) || (rawWeekly !== null && !Number.isFinite(rawWeekly))) {
+      return { ok: false, error: "Invalid quota data" };
+    }
+    const sessionPct = rawSession;
+    const weeklyPct = rawWeekly;
+
+    // Compute reset timestamps from relative offsets
+    let sessionResetAt: number | null = null;
+    let weeklyResetAt: number | null = null;
+    if (sessionResetMatch) {
+      sessionResetAt = Date.now() + parseInt(sessionResetMatch[1], 10) * 3600 * 1000;
+    }
+    if (weeklyResetMatch) {
+      weeklyResetAt = Date.now() + parseInt(weeklyResetMatch[1], 10) * 86400 * 1000;
+    }
+
+    // Detect plan tier from the page (e.g. "Usage pro Cloud models...")
+    const planMatch = text.match(/\bUsage\s+(free|pro|max)\b/i);
+    const plan = planMatch ? planMatch[1].toLowerCase() : null;
+
+    return {
+      ok: true,
+      sessionPercentage: sessionPct,
+      weeklyPercentage: weeklyPct,
+      sessionResetAt,
+      weeklyResetAt,
+      plan,
+    };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : "Network/timeout error" };
+  }
+}
+
+function applyOllamaLiveData(result: Extract<OllamaQuotaResult, { ok: true }>, apiState: QuotaState): void {
+  if (result.sessionPercentage !== null) apiState.liveOllama5hPercentage = result.sessionPercentage;
+  if (result.weeklyPercentage !== null) apiState.liveOllamaWeeklyPercentage = result.weeklyPercentage;
+  if (result.sessionResetAt !== null) apiState.liveOllamaResetAt = result.sessionResetAt;
+  if (result.weeklyResetAt !== null) apiState.liveOllamaWeeklyResetAt = result.weeklyResetAt;
+  if (result.plan !== null) apiState.livePlan = result.plan;
+}
+
+// =============================================================================
+// Header Parsing
+// =============================================================================
+
+const QUOTA_HEADER_KEYS = new Set([
+  "x-usage-total-tokens",
+  "x-usage-prompt-tokens",
+  "x-usage-completion-tokens",
+  "x-quota-limit",
+  "x-quota-used",
+  "x-ratelimit-limit-tokens",
+  "x-ratelimit-remaining-tokens",
+  "x-ratelimit-reset",
+]);
+
+function applyHeaderRules(headers: Record<string, string>, apiState: QuotaState): void {
+  for (const [key, value] of Object.entries(headers)) {
+    const normalized = key.toLowerCase();
+    if (QUOTA_HEADER_KEYS.has(normalized)) {
+      apiState.rawHeaders[normalized] = value;
+    }
+  }
+  
+  if (apiState.rawHeaders["x-quota-limit"]) {
+    const limit = parseInt(apiState.rawHeaders["x-quota-limit"], 10);
+    if (!Number.isNaN(limit) && limit > 0) {
+      apiState.headerPromptsLimit = limit;
+    }
+  }
+}
+
+// =============================================================================
+// Formatting
+// =============================================================================
+
+function progressBar(pct: number, width: number): string {
+  const filled = Math.round((pct / 100) * Math.max(0, Math.min(100, pct)) * width / 100);
+  return "█".repeat(Math.max(0, filled)) + "░".repeat(Math.max(0, width - filled));
+}
+
+function formatStatus(apiState: QuotaState): string {
+  if (!apiState.provider || !isTrackedProvider(apiState.provider)) {
+    return "";
+  }
+  
+  const plan = apiState.plan || apiState.livePlan || "";
+  const planLabel = plan ? ` ${plan}` : "";
+  
+  if (isDeepseek(apiState.provider)) {
+    const balance = apiState.liveDsTotalBalance ?? "—";
+    const prefix = dsCurrencyPrefix(apiState.liveDsCurrency);
+    const available = apiState.liveDsAvailable === false ? " · ❌ No" : "";
+    const error = apiState.lastFetchError ? ` · ⚠️ ${apiState.lastFetchError}` : "";
+    return `quota: ds${planLabel}${available} · ${prefix}${balance}${error}`;
+  }
+  
+  if (isOllama(apiState.provider)) {
+    // Ollama: prefer live quota data if available, otherwise use turn counting
+    if (apiState.liveOllama5hPercentage !== null) {
+      // Use live data from Ollama settings page
+      const pct5h = apiState.liveOllama5hPercentage;
+      const pctWk = apiState.liveOllamaWeeklyPercentage ?? 0;
+      const reset5h = apiState.liveOllamaResetAt ? ` · reset ${relativeTime(apiState.liveOllamaResetAt)}` : "";
+      const resetWk = apiState.liveOllamaWeeklyResetAt ? ` · wk reset ${relativeTime(apiState.liveOllamaWeeklyResetAt)}` : "";
+
+      const color5h = pct5h >= 80 ? "🔴" : pct5h >= 50 ? "🟡" : "🟢";
+      const colorWk = pctWk >= 80 ? "🔴" : pctWk >= 50 ? "🟡" : "🟢";
+
+      return `quota: ollama${planLabel} · 5h: ${color5h} ${Math.round(pct5h)}%${reset5h} · wk: ${colorWk} ${Math.round(pctWk)}%${resetWk}`;
+    }
+    
+    // Fall back to turn counting with GPU-time weighted units
+    const limit = getLimit();
+    const weeklyLimit = getWeeklyLimit();
+    const pct5h = limit ? Math.min(100, (apiState.ollamaGpuUnitsUsed / limit) * 100) : 0;
+    const pctWk = weeklyLimit ? Math.min(100, (apiState.turnsUsedWeekly / weeklyLimit) * 100) : 0;
+    const mult = ollamaGpuMultiplier(apiState.model);
+    const multLabel = mult > 1 ? ` · ${mult}×` : "";
+    
+    const color5h = pct5h >= 80 ? "🔴" : pct5h >= 50 ? "🟡" : "🟢";
+    const colorWk = pctWk >= 80 ? "🔴" : pctWk >= 50 ? "🟡" : "🟢";
+    
+    const resetLabel = apiState.cycleStart5h ? ` · reset ${relativeTime(apiState.cycleStart5h + 5 * 60 * 60 * 1000)}` : "";
+    const errorLabel = apiState.lastFetchError ? ` · ⚠️ ${apiState.lastFetchError}` : "";
+    
+    return `quota: ollama${planLabel} · 5h: ${color5h} ${Math.round(pct5h)}% · wk: ${colorWk} ${Math.round(pctWk)}%${resetLabel}${multLabel}${errorLabel}`;
+  }
+  
+  if (isKimi(apiState.provider)) {
+    // Kimi: show live data or turn counting
+    if (apiState.liveKimi5hRemaining !== null) {
+      const error = apiState.kimiJwtExpired ? " · ⚠️ JWT expired" : "";
+      return `quota: kimi${planLabel} · 5h: 🟢 ${apiState.liveKimi5hRemaining} remaining${error}`;
+    }
+    
+    const limit = getLimit() ?? 100;
+    const pct = Math.min(100, (apiState.turnsUsed5h / limit) * 100);
+    const color = pct >= 80 ? "🔴" : pct >= 50 ? "🟡" : "🟢";
+    return `quota: kimi${planLabel} · 5h: ${color} ${Math.round(pct)}%`;
+  }
+  
+  // Z.Ai: show live data or turn counting
+  if (apiState.live5hPercentage !== null) {
+    const pct5h = apiState.live5hPercentage;
+    const pctWk = apiState.liveWeeklyPercentage ?? 0;
+    const resetLabel = apiState.live5hResetAt ? ` · reset ${relativeTime(apiState.live5hResetAt)}` : "";
+    const color5h = pct5h >= 80 ? "🔴" : pct5h >= 50 ? "🟡" : "🟢";
+    const colorWk = pctWk >= 80 ? "🔴" : pctWk >= 50 ? "🟡" : "🟢";
+    return `quota: zai${planLabel} · 5h: ${color5h} ${Math.round(pct5h)}% · wk: ${colorWk} ${Math.round(pctWk)}%${resetLabel}`;
+  }
+  
+  // Fallback to turn counting
+  const limit = getLimit();
+  const weeklyLimit = getWeeklyLimit();
+  const pct5h = limit ? Math.min(100, (apiState.quotaUsed5h / limit) * 100) : 0;
+  const pctWk = weeklyLimit ? Math.min(100, (apiState.turnsUsedWeekly / weeklyLimit) * 100) : 0;
+  const mult = quotaMultiplier(apiState.model);
+  const multLabel = mult > 1 ? ` · ${mult}×` : "";
+  
+  const color5h = pct5h >= 80 ? "🔴" : pct5h >= 50 ? "🟡" : "🟢";
+  const colorWk = pctWk >= 80 ? "🔴" : pctWk >= 50 ? "🟡" : "🟢";
+  
+  return `quota: zai${planLabel} · 5h: ${color5h} ${Math.round(pct5h)}% · wk: ${colorWk} ${Math.round(pctWk)}%${multLabel}`;
+}
+
+// =============================================================================
+// Polling
+// =============================================================================
+
+let pollTimer: ReturnType<typeof setInterval> | null = null;
+const POLL_INTERVAL_MS = 30_000; // 30 seconds
+
+async function refreshLiveQuota(): Promise<void> {
+  if (!isTrackedProvider(state.provider)) return;
+  
+  // For Ollama, try to fetch live quota from session cookie, otherwise use turn counting
+  if (isOllama(state.provider)) {
+    const cookieResult = readOllamaSessionCookie();
+    if (!cookieResult.ok) {
+      state.liveOllama5hPercentage = null;
+      state.liveOllamaWeeklyPercentage = null;
+      state.liveOllamaResetAt = null;
+      state.liveOllamaWeeklyResetAt = null;
+      state.lastFetchError = `No ollama-session cookie: ${cookieResult.error} (see ~/.pi/agent/auth.json)`;
+      refreshStatus();
+      return;
+    }
+    const { session, aid } = cookieResult;
+    const result = await fetchOllamaLiveQuota(session, aid);
+    if (result.ok) {
+      applyOllamaLiveData(result, state);
+      state.lastSuccessfulFetchAt = Date.now();
+      state.lastFetchError = null;
+    } else {
+      state.liveOllama5hPercentage = null;
+      state.liveOllamaWeeklyPercentage = null;
+      state.liveOllamaResetAt = null;
+      state.liveOllamaWeeklyResetAt = null;
+      state.lastFetchError = `Ollama fetch failed: ${result.error}`;
+    }
+    refreshStatus();
+    return;
+  }
+  
+  if (isZai(state.provider)) {
+    const apiKey = readApiKey("zai");
+    if (apiKey) {
+      const data = await fetchLiveQuota(apiKey);
+      if (data) {
+        applyLiveData(data, state);
+        state.lastSuccessfulFetchAt = Date.now();
+        state.lastFetchError = null;
+      }
+    }
+    refreshStatus();
+    return;
+  }
+  
+  if (isKimi(state.provider)) {
+    if (state.kimiJwtExpired) {
+      refreshStatus();
+      return;
+    }
+    const webJwt = readKimiWebJwt();
+    if (webJwt) {
+      const exp = getJwtExpiry(webJwt);
+      if (exp && exp * 1000 < Date.now()) {
+        state.kimiJwtExpired = true;
+        refreshStatus();
+        return;
+      }
+      const data = await fetchKimiLiveQuota(webJwt);
+      if (data) {
+        applyKimiLiveData(data, state);
+        state.lastSuccessfulFetchAt = Date.now();
+        state.lastFetchError = null;
+      }
+    }
+    refreshStatus();
+    return;
+  }
+  
+  if (isDeepseek(state.provider)) {
+    const apiKey = readApiKey("deepseek");
+    if (apiKey) {
+      const data = await fetchDeepSeekBalance(apiKey);
+      if (data) {
+        applyDeepSeekData(data, state);
+        state.lastSuccessfulFetchAt = Date.now();
+        state.lastFetchError = null;
+      }
+    }
+    refreshStatus();
+    return;
+  }
+}
+
+function startPolling(): void {
+  if (pollTimer) return;
+  pollTimer = setInterval(async () => {
+    await refreshLiveQuota();
+  }, POLL_INTERVAL_MS);
+  if (pollTimer && "unref" in pollTimer) pollTimer.unref();
+}
+
+function stopPolling(): void {
+  if (pollTimer) {
+    clearInterval(pollTimer);
+    pollTimer = null;
+  }
+}
+
+function refreshStatus(): void {
+  const status = formatStatus(state);
+  if (status) {
+    pi.ui.setStatus("provider-quota", status);
+  } else {
+    pi.ui.setStatus("provider-quota", undefined);
+  }
+}
+
+// =============================================================================
+// Default Export
+// =============================================================================
+
+export default function (pi: ExtensionAPI): void {
+  (globalThis as unknown as { pi: ExtensionAPI }).pi = pi;
+  
+  // Session start - restore state
+  pi.on("session_start", async (_event, ctx) => {
+    for (const entry of ctx.sessionManager.getEntries()) {
+      if (entry.type === "custom" && entry.customType === "provider-quota") {
+        const safe = sanitizeState(entry.data);
+        state = { ...createFreshState(), ...safe };
+        break;
+      }
+    }
+    
+    if (state.provider && isTrackedProvider(state.provider)) {
+      startPolling();
+      await refreshLiveQuota();
+    }
+  });
+  
+  // Model select - switch provider
+  pi.on("model_select", async (event, ctx) => {
+    const { provider, model } = event;
+    
+    if (!isTrackedProvider(provider)) {
+      resetProviderData();
+      state.provider = "";
+      state.model = "";
+      stopPolling();
+      refreshStatus();
+      return;
+    }
+    
+    resetProviderData();
+    state.provider = provider;
+    state.model = model;
+    state.cycleStart5h = state.cycleStart5h ?? Date.now();
+    state.weeklyStart = state.weeklyStart ?? Date.now();
+    
+    startPolling();
+    await refreshLiveQuota();
+  });
+  
+  // Turn start - rotate cycles
+  pi.on("turn_start", async () => {
+    maybeRotateCycle();
+    maybeRotateWeekly();
+    refreshStatus();
+  });
+  
+  // Turn end - count usage
+  pi.on("turn_end", async (event) => {
+    maybeRotateCycle();
+    maybeRotateWeekly();
+    
+    const multiplier = quotaMultiplier(state.model);
+    state.turnsUsed5h++;
+    state.quotaUsed5h += multiplier;
+    state.turnsUsedWeekly++;
+    
+    if (isOllama(state.provider)) {
+      state.ollamaGpuUnitsUsed += ollamaGpuMultiplier(state.model);
+    }
+    
+    refreshStatus();
+  });
+  
+  // After provider response - parse headers
+  pi.on("after_provider_response", async (event) => {
+    const headers = event.response?.headers;
+    if (headers && typeof headers === "object") {
+      const headerObj: Record<string, string> = {};
+      for (const [key, value] of Object.entries(headers)) {
+        if (typeof value === "string") {
+          headerObj[key] = value;
+        } else if (Array.isArray(value)) {
+          headerObj[key] = value.join(", ");
+        }
+      }
+      applyHeaderRules(headerObj, state);
+    }
+    state.lastResponseAt = Date.now();
+    refreshStatus();
+  });
+  
+  // Session shutdown - persist state
+  pi.on("session_shutdown", async () => {
+    stopPolling();
+    const persist = { ...state, rawHeaders: {} };
+    pi.appendEntry("provider-quota", persist);
+  });
+  
+  // Commands
+  pi.registerCommand("quota", {
+    description: "Show quota usage details",
+    handler: async (_args, ctx) => {
+      await refreshLiveQuota();
+      const lines: string[] = [];
+      lines.push(`Provider: ${state.provider || "—"}`);
+      lines.push(`Model: ${state.model || "—"}`);
+      lines.push(`Plan: ${state.plan || state.livePlan || "—"}`);
+      
+      if (isZai(state.provider)) {
+        lines.push(`Live 5h: ${state.live5hPercentage !== null ? `${Math.round(state.live5hPercentage)}%` : "—"}${state.live5hResetAt ? ` (resets ${relativeTime(state.live5hResetAt)})` : ""}`);
+        lines.push(`Live wk: ${state.liveWeeklyPercentage !== null ? `${Math.round(state.liveWeeklyPercentage)}%` : "—"}`);
+        if (state.liveMcpDetails.length > 0) {
+          lines.push("MCP Usage:");
+          for (const d of state.liveMcpDetails) {
+            if (d.usage > 0) lines.push(`  ${d.modelCode}: ${d.usage}`);
+          }
+        }
+      }
+      
+      if (isKimi(state.provider)) {
+        lines.push(`5h remaining: ${state.liveKimi5hRemaining ?? "—"}`);
+        lines.push(`Weekly remaining: ${state.liveKimiWeeklyRemaining ?? "—"}`);
+        if (state.kimiJwtExpired) lines.push("⚠️ JWT expired");
+      }
+      
+      if (isOllama(state.provider)) {
+        if (state.liveOllama5hPercentage !== null) {
+          lines.push(`Live session: ${Math.round(state.liveOllama5hPercentage)}% used`);
+          lines.push(`Live weekly: ${state.liveOllamaWeeklyPercentage !== null ? Math.round(state.liveOllamaWeeklyPercentage) + "% used" : "—"}`);
+          if (state.liveOllamaResetAt) lines.push(`Session resets: ${relativeTime(state.liveOllamaResetAt)}`);
+          if (state.liveOllamaWeeklyResetAt) lines.push(`Weekly resets: ${relativeTime(state.liveOllamaWeeklyResetAt)}`);
+        } else {
+          const cookieResult = readOllamaSessionCookie();
+          lines.push(`GPU units (5h): ${state.ollamaGpuUnitsUsed}`);
+          lines.push(`Weekly turns: ${state.turnsUsedWeekly}`);
+          lines.push(`Session cookie: ${cookieResult.ok ? "✅ found" : "❌ " + cookieResult.error}`);
+        }
+      }
+      
+      if (isDeepseek(state.provider)) {
+        lines.push(`Balance: ${dsCurrencyPrefix(state.liveDsCurrency)}${state.liveDsTotalBalance ?? "—"}`);
+        lines.push(`Available: ${state.liveDsAvailable === false ? "No" : state.liveDsAvailable === true ? "Yes" : "—"}`);
+      }
+      
+      lines.push(`Local 5h: ${state.quotaUsed5h} units (${state.turnsUsed5h} turns)`);
+      lines.push(`Local wk: ${state.turnsUsedWeekly} turns`);
+      
+      if (Object.keys(state.rawHeaders).length > 0) {
+        lines.push("Headers:");
+        for (const key of Object.keys(state.rawHeaders).sort()) {
+          lines.push(`  ${key}: ${state.rawHeaders[key]}`);
+        }
+      }
+      
+      if (state.lastFetchError) {
+        lines.push(`Error: ${state.lastFetchError}`);
+      }
+      
+      ctx.ui.notify(lines.join("\n"), "info");
+    },
+  });
+  
+  pi.registerCommand("quota-plan", {
+    description: "Set plan tier",
+    getArgumentCompletions: () => {
+      if (isZai(state.provider)) return ["lite", "pro", "max"];
+      if (isKimi(state.provider)) return ["moderato", "allegretto", "vivace"];
+      if (isOllama(state.provider)) return ["free", "pro", "max"];
+      return [];
+    },
+    handler: async (args, ctx) => {
+      if (isDeepseek(state.provider)) {
+        ctx.ui.notify("DeepSeek uses pay-as-you-go billing with no plan tiers.", "info");
+        return;
+      }
+      const plan = args.plan?.toLowerCase();
+      if (!plan) {
+        ctx.ui.notify(`Current plan: ${state.plan || "not set"}`, "info");
+        return;
+      }
+      state.plan = plan;
+      ctx.ui.notify(`Plan set to: ${plan}`, "info");
+      refreshStatus();
+    },
+  });
+  
+  // Tool for LLM
+  pi.registerTool({
+    name: "provider_quota",
+    label: "Check Provider Quota",
+    description: "Check current quota usage for the active provider",
+    parameters: Type.Object({}),
+    execute: async () => {
+      await refreshLiveQuota();
+      return {
+        provider: state.provider,
+        model: state.model,
+        plan: state.plan || state.livePlan,
+        live5hPercentage: state.live5hPercentage,
+        liveWeeklyPercentage: state.liveWeeklyPercentage,
+        livePlan: state.livePlan,
+        turnsUsed5h: state.turnsUsed5h,
+        quotaUsed5h: state.quotaUsed5h,
+        turnsUsedWeekly: state.turnsUsedWeekly,
+        kimi5hRemaining: state.liveKimi5hRemaining,
+        kimiWeeklyRemaining: state.liveKimiWeeklyRemaining,
+        kimiJwtExpired: state.kimiJwtExpired,
+        deepseekBalance: state.liveDsTotalBalance ? `${dsCurrencyPrefix(state.liveDsCurrency)}${state.liveDsTotalBalance}` : null,
+        deepseekAvailable: state.liveDsAvailable,
+        ollamaGpuUnitsUsed: state.ollamaGpuUnitsUsed,
+        ollamaLiveSessionPct: state.liveOllama5hPercentage,
+        ollamaLiveWeeklyPct: state.liveOllamaWeeklyPercentage,
+        ollamaSessionResetAt: state.liveOllamaResetAt,
+        ollamaWeeklyResetAt: state.liveOllamaWeeklyResetAt,
+        lastFetchError: state.lastFetchError,
+        lastResponseAt: state.lastResponseAt,
+      };
+    },
+  });
+}
+
+// TypeScript needs this reference
+declare const pi: ExtensionAPI;
+(globalThis as unknown as { pi: ExtensionAPI }).pi = {} as ExtensionAPI;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "pi-provider-quota",
+  "version": "0.1.0",
+  "description": "Track Z.Ai, Kimi Code, Ollama Cloud, and DeepSeek quota in pi's status bar",
+  "type": "module",
+  "main": "extensions/provider-quota.ts",
+  "license": "MIT",
+  "author": "",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ronnieops/pi-provider-quota.git"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "quota",
+    "ollama",
+    "deepseek",
+    "kimi",
+    "zai",
+    "status-bar"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions/provider-quota.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*"
+  },
+  "dependencies": {
+    "typebox": "^1.1.24"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3"
+  }
+}