@hanzo/browser-extension 1.9.31 → 1.9.34

package/dist/browser-extension/firefox/background.js

@@ -1317,6 +1317,1403 @@
     });
   }
 
+  // ../../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) => {
+    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 = strategy.shouldFallback?.(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) {
+      const auth = await readJsonFile(ctx.host, `${codexHome(ctx)}/auth.json`);
+      return Boolean(auth?.tokens?.access_token);
+    },
+    async fetch(ctx) {
+      const auth = await readJsonFile(ctx.host, `${codexHome(ctx)}/auth.json`);
+      const token = auth?.tokens?.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 (auth?.tokens?.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(body.rate_limit?.primary_window),
+        secondary: toWindow(body.rate_limit?.secondary_window),
+        extraRateWindows: (body.additional_rate_limits ?? []).map((extra) => {
+          const window2 = toWindow(extra.rate_limit?.primary_window);
+          if (!window2 || !extra.limit_name)
+            return void 0;
+          return { id: extra.limit_name, title: extra.limit_name, window: window2, usageKnown: true };
+        }).filter((w) => Boolean(w)),
+        identity: { providerId: "codex", plan: body.plan_type, loginMethod: "oauth" },
+        dataConfidence: "percentOnly",
+        updatedAt: now
+      };
+      let credits;
+      if (body.credits?.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?.utilization ?? w?.used_percent;
+    if (typeof used !== "number")
+      return void 0;
+    return { usedPercent: used, windowMinutes: WINDOW_MINUTES[key], resetsAt: 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 window2 = toWindow2(key, body[key]);
+      if (window2)
+        extras.push({ id: key, title, window: window2, 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) => {
+    for (const path of credentialPaths) {
+      const file = await readJsonFile(ctx.host, path);
+      if (file?.claudeAiOauth?.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?.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) {
+      return typeof ctx.settings?.cookieHeader === "string";
+    },
+    async fetch(ctx) {
+      const cookie = String(ctx.settings?.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 = orgs[0]?.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) {
+      return Boolean(ctx.settings?.getToken || ctx.settings?.apiKey);
+    },
+    async fetch(ctx) {
+      const base = ctx.settings?.baseUrl ?? "https://api.hanzo.ai";
+      const token = await ctx.settings?.getToken?.() ?? ctx.settings?.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) {
+      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 (item.payload?.type === "token_count")
+            payload = item.payload;
+        } catch {
+        }
+      }
+      const now = ctx.host.now();
+      const totals = payload?.info?.total_token_usage;
+      const usage = {
+        providerId: "hanzo",
+        primary: toRateWindow(payload?.rate_limits?.primary, now),
+        secondary: toRateWindow(payload?.rate_limits?.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 = []) => {
+    const fromSettings = ctx.settings?.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 = []) => {
+    const fromSettings = ctx.settings?.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) => {
+    if (body.status !== "success")
+      return 0;
+    let total = 0;
+    for (const series of body.data?.result ?? []) {
+      const raw = series.value?.[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) {
+      const key = resolveApiKey(ctx, ENV_KEYS);
+      if (!key)
+        throw new Error("groq: no API key");
+      const base = ctx.settings?.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) {
+      const key = resolveApiKey(ctx, ENV_KEYS2);
+      if (!key)
+        throw new Error("deepgram: no API key");
+      const base = ctx.settings?.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 ctx.settings?.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?.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?.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 () => {
+    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(body.rate_limit?.primary_window),
+        secondary: toWindow3(body.rate_limit?.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/shared/evaluable.ts
   function pickEvaluable(params) {
     const p = params ?? {};
@@ -4513,6 +5910,16 @@
         case "listTabFS":
           sendResponse({ success: false, error: "Tab filesystem requires CDP bridge." });
           break;
+        // AI provider usage (Claude + Codex, via @hanzo/usage)
+        case "usage.fetch": {
+          try {
+            const providers = await fetchAllUsage();
+            sendResponse({ success: true, providers });
+          } catch (e) {
+            sendResponse({ success: false, error: e.message });
+          }
+          break;
+        }
         default:
           sendResponse({ success: false, error: `Unknown action: ${request.action}` });
           break;
@@ -4552,5 +5959,25 @@
       void hanzoExtension.stopControlSession();
     }
   });
+  try {
+    const omnibox = browser.omnibox;
+    if (omnibox) {
+      omnibox.setDefaultSuggestion({
+        description: "Search Hanzo AI \u2014 AI answers with sources and realtime news"
+      });
+      omnibox.onInputEntered.addListener((text, disposition) => {
+        const url = browser.runtime.getURL("newtab.html") + "?q=" + encodeURIComponent(text);
+        if (disposition === "newForegroundTab") {
+          void browser.tabs.create({ url });
+        } else if (disposition === "newBackgroundTab") {
+          void browser.tabs.create({ url, active: false });
+        } else {
+          void browser.tabs.update({ url });
+        }
+      });
+    }
+  } catch (e) {
+    console.warn("[Hanzo] omnibox unavailable:", e);
+  }
   console.log("[Hanzo] Firefox background script loaded");
 })();