@hanzo/browser-extension 1.9.31 → 1.9.34

package/dist/browser-extension/background.js

@@ -3306,8 +3306,8 @@ var WebGPUAI = class {
         chunks.push(value);
         received += value.byteLength;
         if (total > 0 && received >= nextLog) {
-          const pct = Math.floor(received / total * 100);
-          console.log(`[Hanzo AI] ${label}: ${pct}% (${received}/${total} bytes)`);
+          const pct2 = Math.floor(received / total * 100);
+          console.log(`[Hanzo AI] ${label}: ${pct2}% (${received}/${total} bytes)`);
           nextLog = received + Math.floor(total * 0.05);
         }
       }
@@ -3585,14 +3585,14 @@ function parseTabId(raw) {
 function unwrapEvaluateResult(raw) {
   if (raw === null || raw === void 0) return raw;
   if (typeof raw !== "object") return raw;
-  const obj = raw;
-  const inner = obj.result;
+  const obj3 = raw;
+  const inner = obj3.result;
   if (inner && typeof inner === "object" && "value" in inner) {
     return inner.value;
   }
-  if ("result" in obj) return obj.result;
-  if ("value" in obj) return obj.value;
-  if (Object.keys(obj).length === 0 && !Array.isArray(obj)) return void 0;
+  if ("result" in obj3) return obj3.result;
+  if ("value" in obj3) return obj3.value;
+  if (Object.keys(obj3).length === 0 && !Array.isArray(obj3)) return void 0;
   return raw;
 }
 
@@ -4377,6 +4377,1419 @@ async function getAuthStatus2() {
   return getAuthStatus(adapter.storage);
 }
 
+// ../../node_modules/.pnpm/@hanzo+usage@0.1.6_react@18.3.1/node_modules/@hanzo/usage/dist/host.js
+var expandHome = (host, path) => path.startsWith("~/") ? `${host.homeDir()}/${path.slice(2)}` : path;
+var readJsonFile = async (host, path) => {
+  const text = await host.readTextFile(expandHome(host, path));
+  if (text === void 0)
+    return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+};
+
+// ../../node_modules/.pnpm/@hanzo+usage@0.1.6_react@18.3.1/node_modules/@hanzo/usage/dist/provider.js
+var matchesMode = (kind, mode) => {
+  if (mode === "auto")
+    return true;
+  if (mode === "web")
+    return kind === "web";
+  if (mode === "cli")
+    return kind === "cli" || kind === "localProbe";
+  if (mode === "oauth")
+    return kind === "oauth";
+  return kind === "apiToken";
+};
+var forMode = (all, mode) => all.filter((s) => matchesMode(s.kind, mode));
+var runPipeline = async (descriptor, ctx) => {
+  var _a;
+  const attempts = [];
+  let lastError;
+  for (const strategy of descriptor.strategies(ctx.sourceMode)) {
+    if (!await strategy.isAvailable(ctx)) {
+      attempts.push({ strategyId: strategy.id, ok: false, skipped: true });
+      continue;
+    }
+    try {
+      const result = await strategy.fetch(ctx);
+      attempts.push({ strategyId: strategy.id, ok: true });
+      return { result, attempts };
+    } catch (error) {
+      attempts.push({
+        strategyId: strategy.id,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      lastError = error;
+      const fallback = ((_a = strategy.shouldFallback) == null ? void 0 : _a.call(strategy, error, ctx)) ?? true;
+      if (!fallback)
+        break;
+    }
+  }
+  return { error: lastError ?? new Error(`${descriptor.id}: no strategy available`), attempts };
+};
+
+// ../../node_modules/.pnpm/@hanzo+usage@0.1.6_react@18.3.1/node_modules/@hanzo/usage/dist/providers/codex.js
+var codexHome = (ctx) => ctx.host.env("CODEX_HOME") ?? expandHome(ctx.host, "~/.codex");
+var toWindow = (w) => {
+  if (!w || typeof w.used_percent !== "number")
+    return void 0;
+  return {
+    usedPercent: w.used_percent,
+    windowMinutes: w.limit_window_seconds ? Math.round(w.limit_window_seconds / 60) : void 0,
+    resetsAt: w.reset_at ? new Date(w.reset_at * 1e3).toISOString() : void 0
+  };
+};
+var oauthStrategy = {
+  id: "codex.oauth",
+  kind: "oauth",
+  async isAvailable(ctx) {
+    var _a;
+    const auth = await readJsonFile(ctx.host, `${codexHome(ctx)}/auth.json`);
+    return Boolean((_a = auth == null ? void 0 : auth.tokens) == null ? void 0 : _a.access_token);
+  },
+  async fetch(ctx) {
+    var _a, _b, _c, _d, _e;
+    const auth = await readJsonFile(ctx.host, `${codexHome(ctx)}/auth.json`);
+    const token = (_a = auth == null ? void 0 : auth.tokens) == null ? void 0 : _a.access_token;
+    if (!token)
+      throw new Error("codex: no access token in auth.json");
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json",
+      "User-Agent": "HanzoUsage"
+    };
+    if ((_b = auth == null ? void 0 : auth.tokens) == null ? void 0 : _b.account_id)
+      headers["ChatGPT-Account-Id"] = auth.tokens.account_id;
+    const res = await ctx.host.http({
+      url: "https://chatgpt.com/backend-api/wham/usage",
+      headers,
+      timeoutMs: 3e4
+    });
+    if (res.status !== 200)
+      throw new Error(`codex usage HTTP ${res.status}`);
+    const body = JSON.parse(res.text);
+    const now = ctx.host.now().toISOString();
+    const usage = {
+      providerId: "codex",
+      primary: toWindow((_c = body.rate_limit) == null ? void 0 : _c.primary_window),
+      secondary: toWindow((_d = body.rate_limit) == null ? void 0 : _d.secondary_window),
+      extraRateWindows: (body.additional_rate_limits ?? []).map((extra) => {
+        var _a2;
+        const window = toWindow((_a2 = extra.rate_limit) == null ? void 0 : _a2.primary_window);
+        if (!window || !extra.limit_name)
+          return void 0;
+        return { id: extra.limit_name, title: extra.limit_name, window, usageKnown: true };
+      }).filter((w) => Boolean(w)),
+      identity: { providerId: "codex", plan: body.plan_type, loginMethod: "oauth" },
+      dataConfidence: "percentOnly",
+      updatedAt: now
+    };
+    let credits;
+    if ((_e = body.credits) == null ? void 0 : _e.has_credits) {
+      credits = {
+        remaining: body.credits.balance ?? 0,
+        unlimited: body.credits.unlimited,
+        updatedAt: now
+      };
+    }
+    return {
+      usage,
+      credits,
+      sourceLabel: "OpenAI OAuth",
+      strategyId: this.id,
+      strategyKind: this.kind
+    };
+  }
+};
+var codexProvider = {
+  id: "codex",
+  metadata: {
+    displayName: "Codex",
+    sessionLabel: "5h limit",
+    weeklyLabel: "Weekly limit",
+    supportsCredits: true,
+    defaultEnabled: true,
+    dashboardUrl: "https://chatgpt.com/codex/settings/usage",
+    statusPageUrl: "https://status.openai.com",
+    color: "#10a37f"
+  },
+  strategies: (mode) => forMode([oauthStrategy], mode)
+};
+
+// ../../node_modules/.pnpm/@hanzo+usage@0.1.6_react@18.3.1/node_modules/@hanzo/usage/dist/providers/claude.js
+var WINDOW_MINUTES = {
+  five_hour: 300,
+  seven_day: 10080,
+  seven_day_sonnet: 10080,
+  seven_day_opus: 10080
+};
+var toWindow2 = (key, w) => {
+  const used = (w == null ? void 0 : w.utilization) ?? (w == null ? void 0 : w.used_percent);
+  if (typeof used !== "number")
+    return void 0;
+  return { usedPercent: used, windowMinutes: WINDOW_MINUTES[key], resetsAt: w == null ? void 0 : w.resets_at };
+};
+var mapUsage = (body, now, loginMethod, plan) => {
+  const extras = [];
+  for (const [key, title] of [
+    ["seven_day_sonnet", "Sonnet weekly"],
+    ["seven_day_opus", "Opus weekly"]
+  ]) {
+    const window = toWindow2(key, body[key]);
+    if (window)
+      extras.push({ id: key, title, window, usageKnown: true });
+  }
+  return {
+    providerId: "claude",
+    primary: toWindow2("five_hour", body.five_hour),
+    secondary: toWindow2("seven_day", body.seven_day),
+    extraRateWindows: extras.length ? extras : void 0,
+    identity: {
+      providerId: "claude",
+      plan: plan ?? body.subscriptionType ?? body.rate_limit_tier,
+      loginMethod
+    },
+    providerCost: body.extra_usage && typeof body.extra_usage.used_cents === "number" ? {
+      used: body.extra_usage.used_cents / 100,
+      limit: typeof body.extra_usage.limit_cents === "number" ? body.extra_usage.limit_cents / 100 : void 0,
+      currencyCode: "USD",
+      period: "monthly",
+      updatedAt: now
+    } : void 0,
+    dataConfidence: "percentOnly",
+    updatedAt: now
+  };
+};
+var credentialPaths = ["~/.claude/.credentials.json", "~/.config/claude/.credentials.json"];
+var readCredentials = async (ctx) => {
+  var _a;
+  for (const path of credentialPaths) {
+    const file = await readJsonFile(ctx.host, path);
+    if ((_a = file == null ? void 0 : file.claudeAiOauth) == null ? void 0 : _a.accessToken)
+      return file.claudeAiOauth;
+  }
+  return void 0;
+};
+var oauthStrategy2 = {
+  id: "claude.oauth",
+  kind: "oauth",
+  async isAvailable(ctx) {
+    return Boolean(await readCredentials(ctx));
+  },
+  async fetch(ctx) {
+    const creds = await readCredentials(ctx);
+    if (!(creds == null ? void 0 : creds.accessToken))
+      throw new Error("claude: no OAuth credentials");
+    const res = await ctx.host.http({
+      url: "https://api.anthropic.com/api/oauth/usage",
+      headers: {
+        Authorization: `Bearer ${creds.accessToken}`,
+        "anthropic-beta": "oauth-2025-04-20",
+        Accept: "application/json"
+      },
+      timeoutMs: 3e4
+    });
+    if (res.status !== 200)
+      throw new Error(`claude usage HTTP ${res.status}`);
+    const body = JSON.parse(res.text);
+    return {
+      usage: mapUsage(body, ctx.host.now().toISOString(), "oauth", creds.subscriptionType),
+      sourceLabel: "Claude OAuth",
+      strategyId: this.id,
+      strategyKind: this.kind
+    };
+  }
+};
+var webStrategy = {
+  id: "claude.web",
+  kind: "web",
+  async isAvailable(ctx) {
+    var _a;
+    return typeof ((_a = ctx.settings) == null ? void 0 : _a.cookieHeader) === "string";
+  },
+  async fetch(ctx) {
+    var _a, _b;
+    const cookie = String((_a = ctx.settings) == null ? void 0 : _a.cookieHeader);
+    const get = async (path) => {
+      const res = await ctx.host.http({
+        url: `https://claude.ai/api${path}`,
+        headers: { Cookie: cookie, Accept: "application/json" },
+        timeoutMs: 3e4
+      });
+      if (res.status !== 200)
+        throw new Error(`claude.ai${path} HTTP ${res.status}`);
+      return JSON.parse(res.text);
+    };
+    const orgs = await get("/organizations");
+    const orgId = (_b = orgs[0]) == null ? void 0 : _b.uuid;
+    if (!orgId)
+      throw new Error("claude: no organization for session");
+    const body = await get(`/organizations/${orgId}/usage`);
+    return {
+      usage: mapUsage(body, ctx.host.now().toISOString(), "web"),
+      sourceLabel: "claude.ai session",
+      strategyId: this.id,
+      strategyKind: this.kind
+    };
+  }
+};
+var claudeProvider = {
+  id: "claude",
+  metadata: {
+    displayName: "Claude",
+    sessionLabel: "Session (5h)",
+    weeklyLabel: "Weekly limit",
+    defaultEnabled: true,
+    dashboardUrl: "https://claude.ai/settings/usage",
+    statusPageUrl: "https://status.anthropic.com",
+    color: "#d97757"
+  },
+  strategies: (mode) => forMode([oauthStrategy2, webStrategy], mode)
+};
+
+// ../../node_modules/.pnpm/@hanzo+usage@0.1.6_react@18.3.1/node_modules/@hanzo/usage/dist/providers/hanzo.js
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var cloudStrategy = {
+  id: "hanzo.cloud",
+  kind: "apiToken",
+  async isAvailable(ctx) {
+    var _a, _b;
+    return Boolean(((_a = ctx.settings) == null ? void 0 : _a.getToken) || ((_b = ctx.settings) == null ? void 0 : _b.apiKey));
+  },
+  async fetch(ctx) {
+    var _a, _b, _c, _d;
+    const base = ((_a = ctx.settings) == null ? void 0 : _a.baseUrl) ?? "https://api.hanzo.ai";
+    const token = await ((_c = (_b = ctx.settings) == null ? void 0 : _b.getToken) == null ? void 0 : _c.call(_b)) ?? ((_d = ctx.settings) == null ? void 0 : _d.apiKey);
+    if (!token)
+      throw new Error("hanzo: no token for cloud usage");
+    const res = await ctx.host.http({
+      url: `${base}/v1/billing/usage`,
+      headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+      timeoutMs: 3e4
+    });
+    if (res.status !== 200)
+      throw new Error(`hanzo billing usage HTTP ${res.status}`);
+    const body = JSON.parse(res.text);
+    const entries = Array.isArray(body.usage) ? body.usage : Array.isArray(body.data) ? body.data : [];
+    let tokens = num(body.total_tokens ?? body.totalTokens);
+    let spendCents = num(body.spend_cents ?? body.spendCents);
+    let requests = num(body.total_requests ?? body.requests);
+    for (const e of entries) {
+      tokens += num(e.total_tokens ?? e.totalTokens ?? e.tokens);
+      spendCents += num(e.spend_cents ?? e.spendCents ?? e.cost_cents);
+      requests += num(e.requests ?? e.request_count ?? 1) - (e.requests === void 0 && e.request_count === void 0 ? 1 : 0);
+    }
+    const now = ctx.host.now().toISOString();
+    const usage = {
+      providerId: "hanzo",
+      identity: { providerId: "hanzo", loginMethod: "iam" },
+      providerCost: {
+        used: spendCents / 100,
+        currencyCode: "USD",
+        period: "monthly",
+        updatedAt: now
+      },
+      totals: { tokens, requests },
+      dataConfidence: "exact",
+      updatedAt: now
+    };
+    return {
+      usage,
+      sourceLabel: "Hanzo Cloud",
+      strategyId: this.id,
+      strategyKind: this.kind
+    };
+  }
+};
+var devHome = async (ctx) => {
+  const candidates = [
+    ctx.host.env("HANZO_HOME"),
+    ctx.host.env("CODEX_HOME"),
+    expandHome(ctx.host, "~/.hanzo"),
+    expandHome(ctx.host, "~/.codex")
+  ].filter((c) => Boolean(c));
+  for (const dir of candidates) {
+    if ((await ctx.host.listDir(`${dir}/sessions`)).length > 0)
+      return dir;
+  }
+  return void 0;
+};
+var newest = (names) => names.filter((n) => /^\d+$/.test(n)).sort().at(-1);
+var toRateWindow = (w, now) => {
+  if (!w || typeof w.used_percent !== "number")
+    return void 0;
+  return {
+    usedPercent: w.used_percent,
+    windowMinutes: w.window_minutes,
+    resetsAt: typeof w.resets_in_seconds === "number" ? new Date(now.getTime() + w.resets_in_seconds * 1e3).toISOString() : void 0
+  };
+};
+var devStrategy = {
+  id: "hanzo.dev",
+  kind: "localProbe",
+  async isAvailable(ctx) {
+    return Boolean(await devHome(ctx));
+  },
+  async fetch(ctx) {
+    var _a, _b, _c, _d;
+    const home = await devHome(ctx);
+    if (!home)
+      throw new Error("hanzo: no dev CLI home with sessions");
+    const sessions = `${home}/sessions`;
+    const year = newest(await ctx.host.listDir(sessions));
+    const month = year && newest(await ctx.host.listDir(`${sessions}/${year}`));
+    const day = month && newest(await ctx.host.listDir(`${sessions}/${year}/${month}`));
+    if (!day)
+      throw new Error("hanzo: no dev sessions found");
+    const dayDir = `${sessions}/${year}/${month}/${day}`;
+    const rollouts = (await ctx.host.listDir(dayDir)).filter((f) => f.endsWith(".jsonl")).sort();
+    const latest = rollouts.at(-1);
+    if (!latest)
+      throw new Error("hanzo: no rollout files today");
+    const text = await ctx.host.readTextFile(`${dayDir}/${latest}`) ?? "";
+    let payload;
+    for (const line of text.split("\n")) {
+      if (!line.includes('"token_count"'))
+        continue;
+      try {
+        const item = JSON.parse(line);
+        if (((_a = item.payload) == null ? void 0 : _a.type) === "token_count")
+          payload = item.payload;
+      } catch {
+      }
+    }
+    const now = ctx.host.now();
+    const totals = (_b = payload == null ? void 0 : payload.info) == null ? void 0 : _b.total_token_usage;
+    const usage = {
+      providerId: "hanzo",
+      primary: toRateWindow((_c = payload == null ? void 0 : payload.rate_limits) == null ? void 0 : _c.primary, now),
+      secondary: toRateWindow((_d = payload == null ? void 0 : payload.rate_limits) == null ? void 0 : _d.secondary, now),
+      identity: { providerId: "hanzo", loginMethod: "dev-cli" },
+      totals: totals ? {
+        tokens: totals.total_tokens ?? 0,
+        inputTokens: totals.input_tokens ?? 0,
+        outputTokens: totals.output_tokens ?? 0,
+        cachedInputTokens: totals.cached_input_tokens ?? 0
+      } : void 0,
+      dataConfidence: totals ? "exact" : "unknown",
+      updatedAt: now.toISOString()
+    };
+    return {
+      usage,
+      sourceLabel: "Hanzo Dev CLI",
+      strategyId: this.id,
+      strategyKind: this.kind
+    };
+  }
+};
+var hanzoProvider = {
+  id: "hanzo",
+  metadata: {
+    displayName: "Hanzo",
+    sessionLabel: "5h limit",
+    weeklyLabel: "Weekly limit",
+    defaultEnabled: true,
+    dashboardUrl: "https://console.hanzo.ai/billing/usage",
+    color: "#ff2d55"
+  },
+  strategies: (mode) => forMode([cloudStrategy, devStrategy], mode)
+};
+
+// ../../node_modules/.pnpm/@hanzo+usage@0.1.6_react@18.3.1/node_modules/@hanzo/usage/dist/providers/api-token.js
+var resolveBaseUrl = (ctx, envKeys = []) => {
+  var _a;
+  const fromSettings = (_a = ctx.settings) == null ? void 0 : _a.baseUrl;
+  if (typeof fromSettings === "string" && fromSettings.length > 0)
+    return fromSettings;
+  for (const name of envKeys) {
+    const value = ctx.host.env(name);
+    if (value)
+      return value;
+  }
+  return void 0;
+};
+var resolveApiKey = (ctx, envKeys = []) => {
+  var _a;
+  const fromSettings = (_a = ctx.settings) == null ? void 0 : _a.apiKey;
+  if (typeof fromSettings === "string" && fromSettings.length > 0)
+    return fromSettings;
+  for (const name of envKeys) {
+    const value = ctx.host.env(name);
+    if (value)
+      return value;
+  }
+  return void 0;
+};
+var makeApiTokenStrategy = (config) => {
+  const label = config.sourceLabel ?? config.metadata.displayName;
+  return {
+    id: `${config.id}.apiToken`,
+    kind: "apiToken",
+    async isAvailable(ctx) {
+      if (!resolveApiKey(ctx, config.envKeys))
+        return false;
+      if (config.requireBaseUrl && !resolveBaseUrl(ctx, config.baseUrlEnv))
+        return false;
+      return true;
+    },
+    async fetch(ctx) {
+      const apiKey = resolveApiKey(ctx, config.envKeys);
+      if (!apiKey)
+        throw new Error(`${config.id}: no API key`);
+      const baseUrl = resolveBaseUrl(ctx, config.baseUrlEnv);
+      if (config.requireBaseUrl && !baseUrl)
+        throw new Error(`${config.id}: no base URL`);
+      const settings = { ...ctx.settings, apiKey, ...baseUrl ? { baseUrl } : {} };
+      const req = config.request(settings, ctx);
+      const res = await ctx.host.http({ method: "GET", timeoutMs: 3e4, ...req });
+      if (res.status !== 200)
+        throw new Error(`${config.id} HTTP ${res.status}`);
+      let body;
+      try {
+        body = JSON.parse(res.text);
+      } catch {
+        throw new Error(`${config.id}: invalid JSON body`);
+      }
+      const now = ctx.host.now();
+      const iso = now.toISOString();
+      const { usage, credits } = config.map(body, now, settings);
+      return {
+        usage: { ...usage, providerId: config.id, updatedAt: iso },
+        credits: credits ? { ...credits, updatedAt: iso } : void 0,
+        sourceLabel: label,
+        strategyId: `${config.id}.apiToken`,
+        strategyKind: "apiToken"
+      };
+    },
+    // API-key providers have exactly one source; nothing to fall back to.
+    shouldFallback() {
+      return false;
+    }
+  };
+};
+var makeApiTokenProvider = (config) => {
+  const strategy = makeApiTokenStrategy(config);
+  return {
+    id: config.id,
+    metadata: config.metadata,
+    strategies: (mode) => forMode([strategy], mode)
+  };
+};
+var numberOrUndefined = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+var bearer = (key) => ({
+  Authorization: `Bearer ${key}`,
+  Accept: "application/json"
+});
+
+// ../../node_modules/.pnpm/@hanzo+usage@0.1.6_react@18.3.1/node_modules/@hanzo/usage/dist/providers/groq.js
+var ENV_KEYS = ["GROQ_API_KEY"];
+var ENV_URL = "GROQ_API_URL";
+var DEFAULT_BASE = "https://api.groq.com/v1";
+var QUERIES = {
+  requests: "sum(model_project_id_status_code:requests:rate5m)",
+  tokensIn: "sum(model_project_id:tokens_in:rate5m)",
+  tokensOut: "sum(model_project_id:tokens_out:rate5m)"
+};
+var sumRate = (body) => {
+  var _a, _b;
+  if (body.status !== "success")
+    return 0;
+  let total = 0;
+  for (const series of ((_a = body.data) == null ? void 0 : _a.result) ?? []) {
+    const raw = (_b = series.value) == null ? void 0 : _b[1];
+    const n = typeof raw === "number" ? raw : Number(raw);
+    if (Number.isFinite(n))
+      total += n;
+  }
+  return total;
+};
+var groqStrategy = {
+  id: "groq.apiToken",
+  kind: "apiToken",
+  async isAvailable(ctx) {
+    return Boolean(resolveApiKey(ctx, ENV_KEYS));
+  },
+  async fetch(ctx) {
+    var _a;
+    const key = resolveApiKey(ctx, ENV_KEYS);
+    if (!key)
+      throw new Error("groq: no API key");
+    const base = ((_a = ctx.settings) == null ? void 0 : _a.baseUrl) ?? ctx.host.env(ENV_URL) ?? DEFAULT_BASE;
+    const query = async (promql) => {
+      const res = await ctx.host.http({
+        url: `${base}/metrics/prometheus/api/v1/query?query=${encodeURIComponent(promql)}`,
+        headers: bearer(key),
+        timeoutMs: 3e4
+      });
+      if (res.status !== 200)
+        throw new Error(`groq metrics HTTP ${res.status}`);
+      return JSON.parse(res.text);
+    };
+    const [requests, tokensIn, tokensOut] = await Promise.all([
+      query(QUERIES.requests),
+      query(QUERIES.tokensIn),
+      query(QUERIES.tokensOut)
+    ]);
+    const requestsPerMin = Math.round(sumRate(requests) * 60);
+    const tokensPerMin = Math.round((sumRate(tokensIn) + sumRate(tokensOut)) * 60);
+    const now = ctx.host.now().toISOString();
+    const usage = {
+      providerId: "groq",
+      identity: { providerId: "groq", loginMethod: "api" },
+      totals: { tokens: tokensPerMin, requests: requestsPerMin },
+      dataConfidence: "estimated",
+      updatedAt: now
+    };
+    return { usage, sourceLabel: "Groq metrics", strategyId: this.id, strategyKind: this.kind };
+  },
+  shouldFallback() {
+    return false;
+  }
+};
+var groqProvider = {
+  id: "groq",
+  metadata: {
+    displayName: "Groq",
+    sessionLabel: "Throughput (req/min)",
+    weeklyLabel: "Tokens/min",
+    dashboardUrl: "https://console.groq.com/metrics",
+    color: "#f55036"
+  },
+  strategies: (mode) => forMode([groqStrategy], mode)
+};
+
+// ../../node_modules/.pnpm/@hanzo+usage@0.1.6_react@18.3.1/node_modules/@hanzo/usage/dist/providers/deepgram.js
+var ENV_KEYS2 = ["DEEPGRAM_API_KEY"];
+var ENV_URL2 = "DEEPGRAM_API_URL";
+var ENV_PROJECT = "DEEPGRAM_PROJECT_ID";
+var DEFAULT_BASE2 = "https://api.deepgram.com/v1";
+var num2 = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var deepgramStrategy = {
+  id: "deepgram.apiToken",
+  kind: "apiToken",
+  async isAvailable(ctx) {
+    return Boolean(resolveApiKey(ctx, ENV_KEYS2));
+  },
+  async fetch(ctx) {
+    var _a, _b;
+    const key = resolveApiKey(ctx, ENV_KEYS2);
+    if (!key)
+      throw new Error("deepgram: no API key");
+    const base = ((_a = ctx.settings) == null ? void 0 : _a.baseUrl) ?? ctx.host.env(ENV_URL2) ?? DEFAULT_BASE2;
+    const headers = { Authorization: `Token ${key}`, Accept: "application/json" };
+    const get = async (path) => {
+      const res = await ctx.host.http({ url: `${base}${path}`, headers, timeoutMs: 3e4 });
+      if (res.status !== 200)
+        throw new Error(`deepgram ${path} HTTP ${res.status}`);
+      return JSON.parse(res.text);
+    };
+    const configured = (typeof ((_b = ctx.settings) == null ? void 0 : _b.projectId) === "string" ? ctx.settings.projectId : void 0) ?? ctx.host.env(ENV_PROJECT);
+    let projectIds;
+    if (configured) {
+      projectIds = [configured];
+    } else {
+      const body = await get("/projects");
+      const projects = Array.isArray(body.projects) ? body.projects : [];
+      projectIds = projects.map((p) => p.project_id).filter((id) => Boolean(id));
+    }
+    let hours = 0;
+    let tokens = 0;
+    let requests = 0;
+    for (const id of projectIds) {
+      const body = await get(`/projects/${id}/usage/breakdown`);
+      for (const r of Array.isArray(body.results) ? body.results : []) {
+        hours += num2(r.total_hours);
+        tokens += num2(r.tokens_in) + num2(r.tokens_out);
+        requests += num2(r.requests);
+      }
+    }
+    const now = ctx.host.now().toISOString();
+    const usage = {
+      providerId: "deepgram",
+      identity: {
+        providerId: "deepgram",
+        loginMethod: "api",
+        accountOrganization: projectIds.length === 1 ? projectIds[0] : `${projectIds.length} projects`
+      },
+      totals: { tokens, requests },
+      dataConfidence: tokens > 0 || requests > 0 || hours > 0 ? "exact" : "unknown",
+      updatedAt: now
+    };
+    return { usage, sourceLabel: "Deepgram usage", strategyId: this.id, strategyKind: this.kind };
+  },
+  shouldFallback() {
+    return false;
+  }
+};
+var deepgramProvider = {
+  id: "deepgram",
+  metadata: {
+    displayName: "Deepgram",
+    sessionLabel: "Usage",
+    weeklyLabel: "Requests",
+    dashboardUrl: "https://console.deepgram.com/usage",
+    color: "#13ef93"
+  },
+  strategies: (mode) => forMode([deepgramStrategy], mode)
+};
+
+// ../../node_modules/.pnpm/@hanzo+usage@0.1.6_react@18.3.1/node_modules/@hanzo/usage/dist/providers/byo.js
+var ENV_KEYS3 = ["BYO_API_KEY"];
+var ENV_URL3 = ["BYO_BASE_URL"];
+var num3 = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var obj = (v) => v && typeof v === "object" ? v : {};
+var stripV1 = (base) => base.replace(/\/v1\/?$/, "").replace(/\/$/, "");
+var keyInfo = async (ctx, base, key, now) => {
+  const res = await ctx.host.http({
+    url: `${stripV1(base)}/key/info`,
+    headers: bearer(key),
+    timeoutMs: 15e3
+  });
+  if (res.status !== 200)
+    return void 0;
+  let info;
+  try {
+    info = obj(obj(JSON.parse(res.text)).info);
+  } catch {
+    return void 0;
+  }
+  if (Object.keys(info).length === 0)
+    return void 0;
+  const spend = num3(info.spend);
+  return {
+    providerId: "byo",
+    identity: {
+      providerId: "byo",
+      loginMethod: "api",
+      accountEmail: typeof info.user_id === "string" ? info.user_id : void 0,
+      accountOrganization: typeof info.team_id === "string" ? info.team_id : void 0,
+      plan: typeof info.key_name === "string" ? info.key_name : void 0
+    },
+    providerCost: { used: spend, currencyCode: "USD", period: "key", updatedAt: now.toISOString() },
+    subscriptionExpiresAt: typeof info.expires === "string" ? info.expires : void 0,
+    dataConfidence: "exact",
+    updatedAt: now.toISOString()
+  };
+};
+var modelsLiveness = async (ctx, base, key, now) => {
+  const root = stripV1(base);
+  const res = await ctx.host.http({
+    url: `${root}/v1/models`,
+    headers: bearer(key),
+    timeoutMs: 15e3
+  });
+  if (res.status !== 200)
+    throw new Error(`byo: /v1/models HTTP ${res.status}`);
+  let count;
+  try {
+    const data = obj(JSON.parse(res.text)).data;
+    if (Array.isArray(data))
+      count = data.length;
+  } catch {
+  }
+  return {
+    providerId: "byo",
+    identity: {
+      providerId: "byo",
+      loginMethod: "api",
+      accountOrganization: count !== void 0 ? `${count} models` : void 0
+    },
+    dataConfidence: "unknown",
+    updatedAt: now.toISOString()
+  };
+};
+var byoStrategy = {
+  id: "byo.apiToken",
+  kind: "apiToken",
+  async isAvailable(ctx) {
+    return Boolean(resolveApiKey(ctx, ENV_KEYS3) && resolveBaseUrl(ctx, ENV_URL3));
+  },
+  async fetch(ctx) {
+    const key = resolveApiKey(ctx, ENV_KEYS3);
+    const base = resolveBaseUrl(ctx, ENV_URL3);
+    if (!key || !base)
+      throw new Error("byo: baseUrl and apiKey are required");
+    const now = ctx.host.now();
+    const info = await keyInfo(ctx, base, key, now);
+    if (info) {
+      return { usage: info, sourceLabel: "BYO /key/info", strategyId: this.id, strategyKind: this.kind };
+    }
+    const usage = await modelsLiveness(ctx, base, key, now);
+    return { usage, sourceLabel: "BYO liveness", strategyId: this.id, strategyKind: this.kind };
+  },
+  shouldFallback() {
+    return false;
+  }
+};
+var byoProvider = {
+  id: "byo",
+  metadata: {
+    displayName: "BYO endpoint",
+    sessionLabel: "Key spend",
+    weeklyLabel: "Liveness",
+    dashboardUrl: "https://docs.hanzo.ai/docs/gateway",
+    color: "#64748b"
+  },
+  strategies: (mode) => forMode([byoStrategy], mode)
+};
+
+// ../../node_modules/.pnpm/@hanzo+usage@0.1.6_react@18.3.1/node_modules/@hanzo/usage/dist/providers/api-token-providers.js
+var num4 = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var loose = (v) => {
+  if (typeof v === "number" && Number.isFinite(v))
+    return v;
+  if (typeof v === "string") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+};
+var pct = (used, limit) => limit > 0 ? Math.min(100, Math.max(0, used / limit * 100)) : 0;
+var obj2 = (v) => v && typeof v === "object" ? v : {};
+var openrouterProvider = makeApiTokenProvider({
+  id: "openrouter",
+  metadata: {
+    displayName: "OpenRouter",
+    sessionLabel: "Credits used",
+    weeklyLabel: "Credit limit",
+    supportsCredits: true,
+    dashboardUrl: "https://openrouter.ai/settings/credits",
+    color: "#6467f2"
+  },
+  envKeys: ["OPENROUTER_API_KEY"],
+  request: (s, ctx) => ({
+    url: `${s.baseUrl ?? ctx.host.env("OPENROUTER_API_URL") ?? "https://openrouter.ai/api/v1"}/credits`,
+    headers: bearer(s.apiKey)
+  }),
+  map: (json, now) => {
+    const d = obj2(obj2(json).data);
+    const total = num4(d.total_credits);
+    const used = num4(d.total_usage);
+    return {
+      usage: {
+        identity: { providerId: "openrouter", loginMethod: "api" },
+        providerCost: { used, limit: total, currencyCode: "USD", period: "total", updatedAt: now.toISOString() },
+        dataConfidence: "exact"
+      },
+      credits: { remaining: Math.max(0, total - used) }
+    };
+  }
+});
+var deepseekProvider = makeApiTokenProvider({
+  id: "deepseek",
+  metadata: {
+    displayName: "DeepSeek",
+    sessionLabel: "Balance",
+    weeklyLabel: "Balance",
+    supportsCredits: true,
+    dashboardUrl: "https://platform.deepseek.com/usage",
+    color: "#527df0"
+  },
+  envKeys: ["DEEPSEEK_API_KEY", "DEEPSEEK_KEY"],
+  request: (s) => ({ url: "https://api.deepseek.com/user/balance", headers: bearer(s.apiKey) }),
+  map: (json) => {
+    const infos = Array.isArray(obj2(json).balance_infos) ? obj2(json).balance_infos : [];
+    const bal = (r) => loose(r.total_balance) ?? 0;
+    const row = infos.find((r) => r.currency === "USD" && bal(r) > 0) ?? infos.find((r) => bal(r) > 0) ?? infos.find((r) => r.currency === "USD") ?? infos[0];
+    return {
+      usage: {
+        identity: { providerId: "deepseek", loginMethod: "api", plan: typeof (row == null ? void 0 : row.currency) === "string" ? row.currency : void 0 },
+        dataConfidence: "exact"
+      },
+      credits: { remaining: row ? bal(row) : 0 }
+    };
+  }
+});
+var elevenlabsProvider = makeApiTokenProvider({
+  id: "elevenlabs",
+  metadata: {
+    displayName: "ElevenLabs",
+    sessionLabel: "Characters",
+    weeklyLabel: "Character limit",
+    dashboardUrl: "https://elevenlabs.io/app/subscription",
+    color: "#ebebe6"
+  },
+  envKeys: ["ELEVENLABS_API_KEY", "XI_API_KEY"],
+  request: (s, ctx) => ({
+    url: `${s.baseUrl ?? ctx.host.env("ELEVENLABS_API_URL") ?? "https://api.elevenlabs.io"}/v1/user/subscription`,
+    headers: { "xi-api-key": s.apiKey, Accept: "application/json" }
+  }),
+  map: (json, now) => {
+    const b = obj2(json);
+    const count = num4(b.character_count);
+    const limit = num4(b.character_limit);
+    const resetUnix = numberOrUndefined(b.next_character_count_reset_unix);
+    const resetsAt = resetUnix !== void 0 ? new Date(resetUnix * 1e3).toISOString() : void 0;
+    const overage = obj2(b.current_overage);
+    const overageAmount = loose(overage.amount);
+    return {
+      usage: {
+        primary: { usedPercent: pct(count, limit), resetsAt },
+        identity: { providerId: "elevenlabs", loginMethod: "api", plan: typeof b.tier === "string" ? b.tier : void 0 },
+        subscriptionRenewsAt: resetsAt,
+        providerCost: overageAmount !== void 0 && overageAmount > 0 ? {
+          used: overageAmount,
+          currencyCode: typeof overage.currency === "string" ? overage.currency : "USD",
+          period: "overage",
+          updatedAt: now.toISOString()
+        } : void 0,
+        dataConfidence: "exact"
+      }
+    };
+  }
+});
+var poeProvider = makeApiTokenProvider({
+  id: "poe",
+  metadata: {
+    displayName: "Poe",
+    sessionLabel: "Points",
+    weeklyLabel: "Points",
+    supportsCredits: true,
+    dashboardUrl: "https://poe.com/api/keys",
+    color: "#5d5cde"
+  },
+  envKeys: ["POE_API_KEY"],
+  request: (s) => ({ url: "https://api.poe.com/usage/current_balance", headers: bearer(s.apiKey) }),
+  map: (json) => ({
+    usage: { identity: { providerId: "poe", loginMethod: "api" }, dataConfidence: "exact" },
+    credits: { remaining: num4(obj2(json).current_point_balance) }
+  })
+});
+var veniceProvider = makeApiTokenProvider({
+  id: "venice",
+  metadata: {
+    displayName: "Venice",
+    sessionLabel: "Balance",
+    weeklyLabel: "DIEM allocation",
+    supportsCredits: true,
+    dashboardUrl: "https://venice.ai/settings/api",
+    color: "#3399ff"
+  },
+  envKeys: ["VENICE_API_KEY", "VENICE_KEY"],
+  request: (s) => ({ url: "https://api.venice.ai/api/v1/billing/balance", headers: bearer(s.apiKey) }),
+  map: (json) => {
+    const b = obj2(json);
+    const balances = obj2(b.balances);
+    const canConsume = b.canConsume !== false;
+    const currency = (typeof b.consumptionCurrency === "string" ? b.consumptionCurrency : "USD").toUpperCase();
+    const usd = loose(balances.usd);
+    const diem = loose(balances.diem);
+    const alloc = loose(b.diemEpochAllocation);
+    const isDiem = currency === "DIEM";
+    const remaining = (isDiem ? diem : usd) ?? 0;
+    let usedPercent = 0;
+    if (!canConsume)
+      usedPercent = 100;
+    else if (isDiem && alloc && alloc > 0)
+      usedPercent = pct(Math.max(0, alloc - remaining), alloc);
+    return {
+      usage: {
+        primary: { usedPercent },
+        identity: { providerId: "venice", loginMethod: "api", plan: currency },
+        dataConfidence: "exact"
+      },
+      credits: { remaining }
+    };
+  }
+});
+var chutesWindow = (container, windowMinutes) => {
+  const w = obj2(container);
+  const pick = (keys) => {
+    for (const k of keys) {
+      const v = loose(w[k]);
+      if (v !== void 0)
+        return v;
+    }
+    return void 0;
+  };
+  const explicit = pick(["percent_used", "usage_percent", "used_percent", "utilization", "utilization_percent"]);
+  const remainingPct = pick(["percent_remaining", "remaining_percent"]);
+  const used = pick(["used", "usage", "consumed", "current", "requests", "tokens", "monthly_usage"]);
+  const limit = pick(["limit", "cap", "max", "maximum", "quota", "quota_limit", "monthly_limit", "total"]);
+  const remaining = pick(["remaining", "available", "balance", "left"]);
+  let usedPercent = explicit;
+  if (usedPercent === void 0 && remainingPct !== void 0)
+    usedPercent = 100 - remainingPct;
+  if (usedPercent !== void 0 && usedPercent <= 1 && usedPercent >= 0)
+    usedPercent *= 100;
+  if (usedPercent === void 0 && limit !== void 0) {
+    const u = used ?? (remaining !== void 0 ? limit - remaining : void 0);
+    if (u !== void 0)
+      usedPercent = pct(u, limit);
+  }
+  if (usedPercent === void 0)
+    return void 0;
+  const resetRaw = pick(["reset_at", "resets_at", "next_reset_at", "period_end", "current_period_end", "expires_at", "window_end"]);
+  return {
+    usedPercent: Math.min(100, Math.max(0, usedPercent)),
+    windowMinutes,
+    resetsAt: resetRaw !== void 0 ? new Date(resetRaw * 1e3).toISOString() : void 0
+  };
+};
+var chutesProvider = makeApiTokenProvider({
+  id: "chutes",
+  metadata: {
+    displayName: "Chutes",
+    sessionLabel: "4h quota",
+    weeklyLabel: "Monthly quota",
+    dashboardUrl: "https://chutes.ai",
+    color: "#eab308"
+  },
+  envKeys: ["CHUTES_API_KEY"],
+  request: (s, ctx) => ({
+    url: `${s.baseUrl ?? ctx.host.env("CHUTES_API_URL") ?? "https://api.chutes.ai"}/users/me/subscription_usage`,
+    headers: bearer(s.apiKey)
+  }),
+  map: (json) => {
+    const b = obj2(json);
+    const rolling = chutesWindow(b.rolling, 240) ?? chutesWindow(b.rolling_window, 240) ?? chutesWindow(b.four_hour, 240);
+    const monthly = chutesWindow(b.monthly, 43200) ?? chutesWindow(b.subscription, 43200) ?? chutesWindow(b.subscription_usage, 43200);
+    const plan = b.plan_name ?? b.plan ?? b.tier;
+    return {
+      usage: {
+        primary: rolling,
+        secondary: monthly,
+        identity: { providerId: "chutes", loginMethod: "api", plan: typeof plan === "string" ? plan : void 0 },
+        dataConfidence: rolling || monthly ? "percentOnly" : "unknown"
+      }
+    };
+  }
+});
+var moonshotBase = (region) => region === "china" ? "https://api.moonshot.cn" : "https://api.moonshot.ai";
+var moonshotProvider = makeApiTokenProvider({
+  id: "moonshot",
+  metadata: {
+    displayName: "Moonshot",
+    sessionLabel: "Balance",
+    weeklyLabel: "Balance",
+    supportsCredits: true,
+    dashboardUrl: "https://platform.moonshot.ai/console/info",
+    color: "#16a34a"
+  },
+  envKeys: ["MOONSHOT_API_KEY", "MOONSHOT_KEY"],
+  request: (s, ctx) => ({
+    url: `${s.baseUrl ?? moonshotBase(s.region ?? ctx.host.env("MOONSHOT_REGION"))}/v1/users/me/balance`,
+    headers: bearer(s.apiKey)
+  }),
+  map: (json) => {
+    const d = obj2(obj2(json).data);
+    return {
+      usage: { identity: { providerId: "moonshot", loginMethod: "api" }, dataConfidence: "exact" },
+      credits: { remaining: num4(d.available_balance) }
+    };
+  }
+});
+var kimiProvider = makeApiTokenProvider({
+  id: "kimi",
+  metadata: {
+    displayName: "Kimi",
+    sessionLabel: "Weekly",
+    weeklyLabel: "Rate (5h)",
+    dashboardUrl: "https://www.kimi.com/code/console",
+    color: "#111111"
+  },
+  envKeys: ["KIMI_CODE_API_KEY"],
+  request: (s, ctx) => ({
+    url: `${s.baseUrl ?? ctx.host.env("KIMI_CODE_BASE_URL") ?? "https://api.kimi.com"}/coding/v1/usages`,
+    headers: bearer(s.apiKey)
+  }),
+  map: (json) => {
+    const b = obj2(json);
+    const detail = obj2(b.usage);
+    const limit = loose(detail.limit) ?? 0;
+    const used = loose(detail.used) ?? (limit && loose(detail.remaining) !== void 0 ? limit - loose(detail.remaining) : 0);
+    const resetTime = detail.resetTime ?? detail.resetAt ?? detail.reset_time;
+    const rate = obj2(obj2(Array.isArray(b.limits) ? b.limits[0] : void 0).detail);
+    const rateLimit = loose(rate.limit);
+    const rateUsed = loose(rate.used);
+    const secondary = rateLimit !== void 0 ? { usedPercent: pct(rateUsed ?? 0, rateLimit), windowMinutes: 300 } : void 0;
+    return {
+      usage: {
+        primary: { usedPercent: pct(used, limit), resetsAt: typeof resetTime === "string" ? resetTime : void 0 },
+        secondary,
+        identity: { providerId: "kimi", loginMethod: "api" },
+        dataConfidence: "percentOnly"
+      }
+    };
+  }
+});
+var kimik2Provider = makeApiTokenProvider({
+  id: "kimik2",
+  metadata: {
+    displayName: "Kimi K2",
+    sessionLabel: "Credits",
+    weeklyLabel: "Credits",
+    supportsCredits: true,
+    dashboardUrl: "https://kimi-k2.ai",
+    color: "#111111"
+  },
+  envKeys: ["KIMI_K2_API_KEY", "KIMI_API_KEY", "KIMI_KEY"],
+  request: (s) => ({ url: "https://kimi-k2.ai/api/user/credits", headers: bearer(s.apiKey) }),
+  map: (json) => {
+    const b = obj2(json);
+    const nested = { ...obj2(b.data), ...obj2(b.result), ...obj2(b.usage), ...obj2(b.credits) };
+    const pick = (keys) => {
+      for (const k of keys) {
+        const v = loose(b[k]) ?? loose(nested[k]);
+        if (v !== void 0)
+          return v;
+      }
+      return void 0;
+    };
+    const remaining = pick([
+      "credits_remaining",
+      "creditsRemaining",
+      "remaining_credits",
+      "remainingCredits",
+      "available_credits",
+      "availableCredits",
+      "credits_left",
+      "creditsLeft",
+      "remaining"
+    ]) ?? 0;
+    return {
+      usage: { identity: { providerId: "kimik2", loginMethod: "api" }, dataConfidence: "exact" },
+      credits: { remaining }
+    };
+  }
+});
+var zaiBase = (region) => region === "bigmodel-cn" ? "https://open.bigmodel.cn" : "https://api.z.ai";
+var ZAI_UNIT_MINUTES = { 1: 1440, 3: 60, 5: 1, 6: 10080 };
+var zaiWindow = (raw) => {
+  const limit = loose(raw.usage) ?? 0;
+  const current = loose(raw.currentValue);
+  const remaining = loose(raw.remaining);
+  const used = current ?? (remaining !== void 0 ? Math.max(0, limit - remaining) : void 0);
+  const explicit = loose(raw.percentage);
+  const usedPercent = used !== void 0 && limit > 0 ? pct(used, limit) : explicit ?? 0;
+  const unit = loose(raw.unit);
+  const number = loose(raw.number);
+  const resetMs = loose(raw.nextResetTime);
+  return {
+    usedPercent,
+    windowMinutes: unit !== void 0 && number !== void 0 ? (ZAI_UNIT_MINUTES[unit] ?? 0) * number : void 0,
+    resetsAt: resetMs !== void 0 ? new Date(resetMs).toISOString() : void 0
+  };
+};
+var zaiProvider = makeApiTokenProvider({
+  id: "zai",
+  metadata: {
+    displayName: "z.ai",
+    sessionLabel: "Token quota",
+    weeklyLabel: "Time quota",
+    dashboardUrl: "https://z.ai/manage-apikey/coding-plan/personal/my-plan",
+    color: "#3b82f6"
+  },
+  envKeys: ["Z_AI_API_KEY"],
+  baseUrlEnv: ["Z_AI_API_HOST"],
+  request: (s, ctx) => ({
+    url: `${resolveZaiBase(s, ctx.host.env("Z_AI_API_HOST"))}/api/monitor/usage/quota/limit`,
+    headers: { ...bearer(s.apiKey), accept: "application/json" }
+  }),
+  map: (json) => {
+    const data = obj2(obj2(json).data);
+    const limits = Array.isArray(data.limits) ? data.limits : [];
+    const tokens = limits.filter((l) => l.type === "TOKENS_LIMIT").map(zaiWindow);
+    const time = limits.find((l) => l.type === "TIME_LIMIT");
+    const plan = data.planName ?? data.plan ?? data.planType ?? data.packageName;
+    return {
+      usage: {
+        primary: tokens[0],
+        secondary: time ? zaiWindow(time) : void 0,
+        tertiary: tokens[1],
+        identity: { providerId: "zai", loginMethod: "api", plan: typeof plan === "string" ? plan : void 0 },
+        dataConfidence: tokens.length || time ? "percentOnly" : "unknown"
+      }
+    };
+  }
+});
+var resolveZaiBase = (s, hostEnv) => s.baseUrl ?? hostEnv ?? zaiBase(s.region);
+var openaiProvider = makeApiTokenProvider({
+  id: "openai",
+  metadata: {
+    displayName: "OpenAI",
+    sessionLabel: "Credits used",
+    weeklyLabel: "Credit grant",
+    supportsCredits: true,
+    dashboardUrl: "https://platform.openai.com/usage",
+    statusPageUrl: "https://status.openai.com",
+    color: "#0f826e"
+  },
+  envKeys: ["OPENAI_ADMIN_KEY", "OPENAI_API_KEY"],
+  request: (s) => ({
+    url: "https://api.openai.com/v1/dashboard/billing/credit_grants",
+    headers: bearer(s.apiKey)
+  }),
+  map: (json, now) => {
+    const b = obj2(json);
+    const granted = num4(b.total_granted);
+    const used = num4(b.total_used);
+    const available = num4(b.total_available);
+    return {
+      usage: {
+        primary: { usedPercent: pct(used, granted) },
+        identity: { providerId: "openai", loginMethod: "api" },
+        providerCost: { used, limit: granted, currencyCode: "USD", period: "grant", updatedAt: now.toISOString() },
+        dataConfidence: "exact"
+      },
+      credits: { remaining: available }
+    };
+  }
+});
+var stripV12 = (base) => base.replace(/\/v1\/?$/, "");
+var litellmProvider = makeApiTokenProvider({
+  id: "litellm",
+  metadata: {
+    displayName: "LiteLLM",
+    sessionLabel: "Key spend",
+    weeklyLabel: "Budget",
+    dashboardUrl: "https://docs.litellm.ai/docs/proxy/cost_tracking",
+    color: "#22c55e"
+  },
+  envKeys: ["LITELLM_API_KEY"],
+  baseUrlEnv: ["LITELLM_BASE_URL"],
+  requireBaseUrl: true,
+  request: (s) => ({ url: `${stripV12(s.baseUrl)}/key/info`, headers: bearer(s.apiKey) }),
+  map: (json, now) => {
+    const info = obj2(obj2(json).info);
+    const spend = num4(info.spend);
+    return {
+      usage: {
+        identity: {
+          providerId: "litellm",
+          loginMethod: "api",
+          accountOrganization: typeof info.team_id === "string" ? info.team_id : void 0,
+          accountEmail: typeof info.user_id === "string" ? info.user_id : void 0,
+          plan: typeof info.key_name === "string" ? info.key_name : void 0
+        },
+        providerCost: { used: spend, currencyCode: "USD", period: "key", updatedAt: now.toISOString() },
+        subscriptionExpiresAt: typeof info.expires === "string" ? info.expires : void 0,
+        dataConfidence: "exact"
+      }
+    };
+  }
+});
+var llmProxyV1 = (base) => /\/v1\/?$/.test(base) ? base.replace(/\/$/, "") : `${base.replace(/\/$/, "")}/v1`;
+var llmproxyProvider = makeApiTokenProvider({
+  id: "llmproxy",
+  metadata: {
+    displayName: "LLM Proxy",
+    sessionLabel: "Quota used",
+    weeklyLabel: "Approx. spend",
+    dashboardUrl: "https://github.com/hzruo/LLM-API-Key-Proxy",
+    color: "#8b5cf6"
+  },
+  envKeys: ["LLM_PROXY_API_KEY"],
+  baseUrlEnv: ["LLM_PROXY_BASE_URL"],
+  requireBaseUrl: true,
+  request: (s) => ({ url: `${llmProxyV1(s.baseUrl)}/quota-stats`, headers: bearer(s.apiKey) }),
+  map: (json, now) => {
+    const b = obj2(json);
+    const providers = obj2(b.providers);
+    const summary = obj2(b.summary);
+    let minRemaining = 100;
+    let earliestReset;
+    let sumTokens = 0;
+    let sumRequests = 0;
+    let sumCost = 0;
+    for (const p of Object.values(providers)) {
+      const stats = obj2(p);
+      sumRequests += num4(stats.total_requests);
+      sumCost += num4(stats.approx_cost);
+      const t = obj2(stats.tokens);
+      sumTokens += num4(t.input_cached) + num4(t.input_uncached) + num4(t.output);
+      const groups = Array.isArray(stats.quota_groups) ? stats.quota_groups : Object.values(obj2(stats.quota_groups));
+      for (const g of groups) {
+        const grp = obj2(g);
+        const rem = loose(grp.remaining_percent);
+        if (rem !== void 0 && rem < minRemaining)
+          minRemaining = rem;
+        const reset = typeof grp.reset_time === "string" ? grp.reset_time : void 0;
+        if (reset && (!earliestReset || reset < earliestReset))
+          earliestReset = reset;
+      }
+    }
+    const totalRequests = numberOrUndefined(summary.total_requests) ?? sumRequests;
+    const totalTokens = numberOrUndefined(summary.total_tokens) ?? sumTokens;
+    const approxCost = numberOrUndefined(summary.approx_cost) ?? sumCost;
+    return {
+      usage: {
+        primary: { usedPercent: Math.min(100, Math.max(0, 100 - minRemaining)), resetsAt: earliestReset },
+        identity: { providerId: "llmproxy", loginMethod: "api" },
+        totals: { tokens: totalTokens, requests: totalRequests },
+        providerCost: approxCost > 0 ? { used: approxCost, currencyCode: "USD", period: "approx", updatedAt: now.toISOString() } : void 0,
+        dataConfidence: "exact"
+      }
+    };
+  }
+});
+var minimaxApiBase = (region) => region === "cn" || region === "china" ? "https://api.minimaxi.com" : "https://api.minimax.io";
+var minimaxWindow = (m, prefix, windowMinutes) => {
+  const remainingPct = loose(m[`${prefix}_remaining_percent`]);
+  const total = loose(m[`${prefix}_total_count`]);
+  const usedCount = loose(m[`${prefix}_usage_count`]);
+  let usedPercent;
+  if (remainingPct !== void 0)
+    usedPercent = 100 - remainingPct;
+  else if (total !== void 0 && usedCount !== void 0)
+    usedPercent = pct(usedCount, total);
+  if (usedPercent === void 0)
+    return void 0;
+  return { usedPercent: Math.min(100, Math.max(0, usedPercent)), windowMinutes };
+};
+var minimaxProvider = makeApiTokenProvider({
+  id: "minimax",
+  metadata: {
+    displayName: "MiniMax",
+    sessionLabel: "Interval",
+    weeklyLabel: "Weekly",
+    dashboardUrl: "https://platform.minimax.io/user-center/payment/coding-plan",
+    color: "#f43f5e"
+  },
+  envKeys: ["MINIMAX_CODING_API_KEY", "MINIMAX_API_KEY"],
+  request: (s, ctx) => ({
+    url: `${s.baseUrl ?? minimaxApiBase(s.region ?? ctx.host.env("MINIMAX_REGION"))}/v1/api/openplatform/coding_plan/remains`,
+    headers: { ...bearer(s.apiKey), accept: "application/json", "MM-API-Source": "HanzoUsage" }
+  }),
+  map: (json) => {
+    const data = obj2(obj2(json).data);
+    const models = Array.isArray(data.model_remains) ? data.model_remains : [];
+    const m = obj2(models[0]);
+    const plan = data.plan_name ?? data.current_plan_title ?? data.current_subscribe_title;
+    const points = loose(data.points_balance) ?? loose(data.balance);
+    return {
+      usage: {
+        primary: minimaxWindow(m, "current_interval", 0),
+        secondary: minimaxWindow(m, "current_weekly", 10080),
+        identity: { providerId: "minimax", loginMethod: "api", plan: typeof plan === "string" ? plan : void 0 },
+        dataConfidence: models.length ? "percentOnly" : "unknown"
+      },
+      credits: points !== void 0 ? { remaining: points } : void 0
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@hanzo+usage@0.1.6_react@18.3.1/node_modules/@hanzo/usage/dist/index.js
+var providerRegistry = {
+  hanzo: hanzoProvider,
+  codex: codexProvider,
+  claude: claudeProvider,
+  openai: openaiProvider,
+  openrouter: openrouterProvider,
+  deepseek: deepseekProvider,
+  elevenlabs: elevenlabsProvider,
+  deepgram: deepgramProvider,
+  groq: groqProvider,
+  poe: poeProvider,
+  venice: veniceProvider,
+  chutes: chutesProvider,
+  moonshot: moonshotProvider,
+  kimi: kimiProvider,
+  kimik2: kimik2Provider,
+  zai: zaiProvider,
+  litellm: litellmProvider,
+  llmproxy: llmproxyProvider,
+  minimax: minimaxProvider,
+  byo: byoProvider
+};
+var allProviders = Object.values(providerRegistry);
+var trackedProviderIds = Object.keys(providerRegistry);
+
+// src/shared/usage.ts
+var http = async (req) => {
+  const controller = new AbortController();
+  const timeout = req.timeoutMs ? setTimeout(() => controller.abort(), req.timeoutMs) : void 0;
+  try {
+    const res = await fetch(req.url, {
+      method: req.method ?? "GET",
+      headers: req.headers,
+      body: req.body,
+      credentials: "include",
+      signal: controller.signal
+    });
+    const headers = {};
+    res.headers.forEach((v, k) => {
+      headers[k] = v;
+    });
+    return { status: res.status, headers, text: await res.text() };
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+};
+var browserHost = {
+  readTextFile: async () => void 0,
+  listDir: async () => [],
+  writeTextFile: async () => {
+  },
+  http,
+  env: () => void 0,
+  homeDir: () => "",
+  now: () => /* @__PURE__ */ new Date()
+};
+var isAuthError = (text) => /\b(401|403)\b/.test(text);
+var outcomeError = (providerHost, outcome) => {
+  const attempt = [...outcome.attempts].reverse().find((a) => a.error);
+  const detail = (attempt == null ? void 0 : attempt.error) ?? "no data";
+  return isAuthError(detail) ? `Open ${providerHost} to sign in` : detail;
+};
+var fetchClaude = async () => {
+  const { displayName, color, dashboardUrl } = claudeProvider.metadata;
+  const base = { providerId: "claude", displayName, color, dashboardUrl };
+  try {
+    const outcome = await runPipeline(claudeProvider, {
+      host: browserHost,
+      sourceMode: "web",
+      settings: { cookieHeader: "" }
+    });
+    if (outcome.result) return { ...base, snapshot: outcome.result.usage };
+    return { ...base, error: outcomeError("claude.ai", outcome) };
+  } catch (e) {
+    return { ...base, error: e instanceof Error ? e.message : String(e) };
+  }
+};
+var toWindow3 = (w) => {
+  if (!w || typeof w.used_percent !== "number") return void 0;
+  return {
+    usedPercent: w.used_percent,
+    windowMinutes: w.limit_window_seconds ? Math.round(w.limit_window_seconds / 60) : void 0,
+    resetsAt: w.reset_at ? new Date(w.reset_at * 1e3).toISOString() : void 0
+  };
+};
+var fetchCodex = async () => {
+  var _a, _b;
+  const { displayName, color, dashboardUrl } = codexProvider.metadata;
+  const base = { providerId: "codex", displayName, color, dashboardUrl };
+  try {
+    const res = await http({
+      url: "https://chatgpt.com/backend-api/wham/usage",
+      headers: { Accept: "application/json" },
+      timeoutMs: 3e4
+    });
+    if (res.status !== 200) {
+      return {
+        ...base,
+        error: isAuthError(String(res.status)) ? "Open chatgpt.com to sign in" : `HTTP ${res.status}`
+      };
+    }
+    const body = JSON.parse(res.text);
+    const snapshot = {
+      providerId: "codex",
+      primary: toWindow3((_a = body.rate_limit) == null ? void 0 : _a.primary_window),
+      secondary: toWindow3((_b = body.rate_limit) == null ? void 0 : _b.secondary_window),
+      identity: { providerId: "codex", plan: body.plan_type, loginMethod: "web" },
+      dataConfidence: "percentOnly",
+      updatedAt: browserHost.now().toISOString()
+    };
+    return { ...base, snapshot };
+  } catch (e) {
+    return { ...base, error: e instanceof Error ? e.message : String(e) };
+  }
+};
+var fetchAllUsage = async () => Promise.all([fetchClaude(), fetchCodex()]);
+
 // src/chat-client.ts
 var API_BASE = API_BASE_URL;
 async function listModels(token) {
@@ -4676,19 +6089,19 @@ var PageMonitor = class {
     Object.assign(this.config, config);
   }
   // --- Helpers ---
-  formatRemoteObject(obj) {
-    if (!obj) return "undefined";
-    if (obj.value !== void 0) return String(obj.value);
-    if (obj.description) return obj.description;
-    if (obj.type === "undefined") return "undefined";
-    if (obj.type === "object" && obj.subtype === "null") return "null";
-    if (obj.unserializableValue) return obj.unserializableValue;
-    if (obj.preview) {
-      const props = obj.preview.properties || [];
+  formatRemoteObject(obj3) {
+    if (!obj3) return "undefined";
+    if (obj3.value !== void 0) return String(obj3.value);
+    if (obj3.description) return obj3.description;
+    if (obj3.type === "undefined") return "undefined";
+    if (obj3.type === "object" && obj3.subtype === "null") return "null";
+    if (obj3.unserializableValue) return obj3.unserializableValue;
+    if (obj3.preview) {
+      const props = obj3.preview.properties || [];
       const pairs = props.map((p) => `${p.name}: ${p.value ?? p.type}`).join(", ");
-      return obj.preview.type === "object" ? `{${pairs}}` : `[${pairs}]`;
+      return obj3.preview.type === "object" ? `{${pairs}}` : `[${pairs}]`;
     }
-    return obj.type || "unknown";
+    return obj3.type || "unknown";
   }
   truncate(str) {
     if (str.length <= this.config.stringSizeLimit) return str;
@@ -7204,6 +8617,18 @@ async function handleMessage(request, sender, sendResponse) {
       })();
       break;
     }
+    // --- AI provider usage (Claude + Codex, via @hanzo/usage) ---
+    case "usage.fetch": {
+      (async () => {
+        try {
+          const providers = await fetchAllUsage();
+          sendResponse({ success: true, providers });
+        } catch (e) {
+          sendResponse({ success: false, error: e.message });
+        }
+      })();
+      break;
+    }
   }
 }
 chrome.tabs.onRemoved.addListener((tabId) => {