@hashimkarim/usagestat-linux-x64-gnu 2.0.0-alpha.1 → 2.0.0-alpha.4

package/plugins/kimi/plugin.js

@@ -1,11 +1,11 @@
 (function () {
-  const CRED_PATH = "~/.kimi/credentials/kimi-code.json"
-  const USAGE_URL = "https://api.kimi.com/coding/v1/usages"
-  const REFRESH_URL = "https://auth.kimi.com/api/oauth/token"
-  const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098"
-  const REFRESH_BUFFER_SEC = 5 * 60
+  const WEB_USAGE_URL = "https://www.kimi.com/apiv2/kimi.gateway.billing.v1.BillingService/GetUsages"
+  const MEMBERSHIP_URL = "https://www.kimi.com/apiv2/kimi.gateway.membership.v2.MembershipService/"
+  const WEEK_MS = 7 * 86400000
 
   function readNumber(value) {
+    if (typeof value !== "number" && typeof value !== "string") return null
+    if (typeof value === "string" && !value.trim()) return null
     const n = Number(value)
     return Number.isFinite(n) ? n : null
   }
@@ -29,119 +29,109 @@
         : null
     if (!level) return null
 
+    if (level === "LEVEL_UNSPECIFIED") return null
+    const names = { LEVEL_FREE: "Adagio", LEVEL_TRIAL: "Andante", LEVEL_BASIC: "Moderato", LEVEL_INTERMEDIATE: "Allegretto", LEVEL_ADVANCED: "Allegro" }
+    if (data.version != null && data.version !== "GOODS_VERSION_V1") return level
+    if (names[level]) return names[level]
     const cleaned = level.replace(/^LEVEL_/, "").replace(/_/g, " ")
     const label = titleCaseWords(cleaned)
     return label || null
   }
 
-  function loadCredentials(ctx) {
-    if (!ctx.host.fs.exists(CRED_PATH)) {
-      ctx.host.log.warn("credentials file not found: " + CRED_PATH)
-      return null
-    }
-
-    try {
-      const text = ctx.host.fs.readText(CRED_PATH)
-      const parsed = ctx.util.tryParseJson(text)
-      if (!parsed || typeof parsed !== "object") {
-        ctx.host.log.warn("credentials file is not valid json")
-        return null
-      }
-      if (!parsed.access_token && !parsed.refresh_token) {
-        ctx.host.log.warn("credentials missing access_token and refresh_token")
-        return null
-      }
-      return parsed
-    } catch (e) {
-      ctx.host.log.warn("credentials read failed: " + String(e))
-      return null
-    }
+  function clean(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null
   }
 
-  function saveCredentials(ctx, creds) {
-    try {
-      ctx.host.fs.writeText(CRED_PATH, JSON.stringify(creds))
-    } catch (e) {
-      ctx.host.log.warn("failed to persist credentials: " + String(e))
-    }
+  function env(ctx, name) {
+    try { return clean(ctx.host.env.get(name)) } catch (_) { return null }
   }
 
-  function needsRefresh(creds, nowSec) {
-    if (!creds.access_token) return true
-    const expiresAt = readNumber(creds.expires_at)
-    if (expiresAt === null) return true
-    return nowSec + REFRESH_BUFFER_SEC >= expiresAt
+  function readText(ctx, path) {
+    try { return clean(ctx.host.fs.readText(path)) } catch (_) { return null }
   }
 
-  function refreshToken(ctx, creds) {
-    if (!creds.refresh_token) {
-      ctx.host.log.warn("refresh skipped: no refresh token")
-      return null
-    }
-
-    ctx.host.log.info("attempting token refresh")
-    let resp
-    try {
-      resp = ctx.util.request({
-        method: "POST",
-        url: REFRESH_URL,
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-          Accept: "application/json",
-        },
-        bodyText:
-          "client_id=" +
-          encodeURIComponent(CLIENT_ID) +
-          "&grant_type=refresh_token" +
-          "&refresh_token=" +
-          encodeURIComponent(creds.refresh_token),
-        timeoutMs: 15000,
-      })
-    } catch (e) {
-      ctx.host.log.error("refresh exception: " + String(e))
-      return null
-    }
-
-    if (ctx.util.isAuthStatus(resp.status)) {
-      throw "Session expired. Run `kimi login` to authenticate."
+  function cliSession(ctx) {
+    const override = env(ctx, "KIMI_CODE_HOME")
+    const homes = override ? [override] : ["~/.kimi-code", "~/.kimi"]
+    for (const home of homes) {
+      const raw = readText(ctx, home + "/credentials/kimi-code.json")
+      if (!raw) continue
+      const credential = ctx.util.tryParseJson(raw)
+      const expires = credential && readNumber(credential.expires_at)
+      if (!credential || !clean(credential.access_token) || expires === null || expires <= Date.parse(ctx.nowIso) / 1000 + 60) continue
+      let deviceId = readText(ctx, home + "/device_id")
+      if (!deviceId) {
+        // This is a client identity, not an authentication secret.
+        deviceId = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+          const n = Math.floor(Math.random() * 16)
+          return (c === "x" ? n : (n & 3) | 8).toString(16)
+        })
+        try { ctx.host.fs.writeText(home + "/device_id", deviceId) } catch (_) {}
+      }
+      return { token: credential.access_token, headers: {
+        "X-Msh-Platform": "kimi_code_cli", "X-Msh-Version": ctx.app.version,
+        "X-Msh-Device-Model": ctx.app.platform,
+        "X-Msh-Device-Id": deviceId.replace(/[^\x20-\x7e]/g, ""),
+      } }
     }
+    return null
+  }
 
-    if (resp.status < 200 || resp.status >= 300) {
-      ctx.host.log.warn("refresh returned unexpected status: " + resp.status)
-      return null
-    }
+  function webToken(ctx) {
+    const raw = clean(ctx.provider.cookieHeader) || env(ctx, "KIMI_AUTH_TOKEN")
+    if (!raw) return null
+    const cookie = raw.replace(/^Cookie:\s*/i, "")
+    const match = /(?:^|;)\s*kimi-auth=([^;]+)/.exec(cookie)
+    if (match) return clean(match[1])
+    return cookie.includes("=") ? null : clean(cookie.replace(/^Bearer\s+/i, ""))
+  }
 
-    const body = ctx.util.tryParseJson(resp.bodyText)
-    if (!body || !body.access_token) {
-      ctx.host.log.warn("refresh response missing access_token")
-      return null
+  function webRequest(ctx, token, url, body, timeoutMs) {
+    const payload = ctx.jwt.decodePayload(token) || {}
+    const headers = {
+      Authorization: "Bearer " + token, Cookie: "kimi-auth=" + token,
+      "Content-Type": "application/json", Accept: "application/json",
+      Origin: "https://www.kimi.com", Referer: "https://www.kimi.com/code/console",
+      "connect-protocol-version": "1", "x-msh-platform": "web", "x-language": "en-US", "r-timezone": "UTC",
     }
-
-    creds.access_token = body.access_token
-    if (body.refresh_token) creds.refresh_token = body.refresh_token
-    if (typeof body.expires_in === "number") {
-      creds.expires_at = Date.now() / 1000 + body.expires_in
+    for (const pair of [["device_id", "x-msh-device-id"], ["ssid", "x-msh-session-id"], ["sub", "x-traffic-id"]]) {
+      if (clean(payload[pair[0]])) headers[pair[1]] = payload[pair[0]].replace(/[^\x20-\x7e]/g, "")
     }
-    if (typeof body.scope === "string") creds.scope = body.scope
-    if (typeof body.token_type === "string") creds.token_type = body.token_type
-
-    saveCredentials(ctx, creds)
-    return creds.access_token
-  }
-
-  function fetchUsage(ctx, accessToken) {
     return ctx.util.request({
-      method: "GET",
-      url: USAGE_URL,
-      headers: {
-        Authorization: "Bearer " + accessToken,
-        Accept: "application/json",
-        "User-Agent": "OpenUsage",
-      },
-      timeoutMs: 10000,
+      method: "POST", url, headers, bodyText: JSON.stringify(body), timeoutMs,
     })
   }
 
+  function enrichMembership(ctx, result, token) {
+    if (!token || ctx.provider.settings && ctx.provider.settings.cookieSource === "off") return result
+    try {
+      const response = webRequest(ctx, token, MEMBERSHIP_URL + "GetSubscriptionStats", {}, 2000)
+      const data = response.status === 200 && ctx.util.tryParseJson(response.bodyText)
+      if (!data) return result
+      const pool = data.subscriptionBalance
+      const ratio = pool && readNumber(pool.amountUsedRatio)
+      if (Number.isFinite(ratio) && pool && (!pool.feature || pool.feature === "FEATURE_OMNI") && (!pool.type || pool.type === "SUBSCRIPTION")) {
+        const reset = ctx.util.toIso(pool.expireTime)
+        const monthly = ctx.line.progress({ label: "Monthly", used: Math.max(0, Math.min(100, ratio * 100)), limit: 100,
+          format: { kind: "percent" }, resetsAt: reset, periodDurationMs: ctx.util.calendarMonthDuration(reset) })
+        // Automatic summaries use the first quota. Reset Code windows cannot
+        // make an exhausted membership pool available again.
+        if (ratio >= 1) result.lines.unshift(monthly)
+        else result.lines.push(monthly)
+      }
+      const weekly = data.ratelimitCode7d
+      const weeklyRatio = weekly && readNumber(weekly.ratio)
+      if (weekly && weekly.enabled !== false && Number.isFinite(weeklyRatio)) {
+        const reset = ctx.util.toIso(weekly.resetTime)
+        const used = Math.max(0, Math.min(100, weeklyRatio * 100))
+        if (!result.lines.some((line) => line.label === "Weekly" && Math.abs(line.used - used) < 0.01 && (line.resetsAt || null) === reset)) {
+          result.lines.push(ctx.line.progress({ label: "Code 7-day", used, limit: 100, format: { kind: "percent" }, resetsAt: reset, periodDurationMs: WEEK_MS }))
+        }
+      }
+    } catch (_) { ctx.host.log.warn("Kimi membership enrichment unavailable") }
+    return result
+  }
+
   function parseWindowPeriodMs(window) {
     if (!window || typeof window !== "object") return null
     const duration = readNumber(window.duration)
@@ -164,11 +154,11 @@
     let used = readNumber(row.used)
     if (used === null) {
       const remaining = readNumber(row.remaining)
-      if (remaining !== null) {
+      if (remaining !== null && remaining >= 0 && remaining <= limit) {
         used = limit - remaining
       }
     }
-    if (used === null) return null
+    if (used === null || used < 0) return null
 
     return {
       used,
@@ -240,43 +230,29 @@
   }
 
   function probe(ctx) {
-    const creds = loadCredentials(ctx)
-    if (!creds) {
-      throw "Not logged in. Run `kimi login` to authenticate."
-    }
-
-    const nowSec = Date.now() / 1000
-    let accessToken = creds.access_token || ""
-
-    if (needsRefresh(creds, nowSec)) {
-      const refreshed = refreshToken(ctx, creds)
-      if (refreshed) {
-        accessToken = refreshed
-      } else if (!accessToken) {
-        throw "Not logged in. Run `kimi login` to authenticate."
-      }
-    }
-
-    let didRefresh = false
+    const mode = ctx.sourceMode || "auto"
+    if (mode === "local") throw "Kimi quotas require a live source. Select api, oauth, cli, or web."
+    const key = clean(ctx.provider.apiKey) || env(ctx, "KIMI_CODE_API_KEY")
+    const baseOverride = clean(ctx.provider.settings && ctx.provider.settings.baseUrl) || env(ctx, "KIMI_CODE_BASE_URL")
+    const hasOverride = baseOverride || env(ctx, "KIMI_CODE_OAUTH_HOST") || env(ctx, "KIMI_OAUTH_HOST")
+    const token = webToken(ctx)
+    let source
     let resp
-    try {
-      resp = ctx.util.retryOnceOnAuth({
-        request: function (token) {
-          return fetchUsage(ctx, token || accessToken)
-        },
-        refresh: function () {
-          didRefresh = true
-          const refreshed = refreshToken(ctx, creds)
-          if (refreshed) accessToken = refreshed
-          return refreshed
-        },
-      })
-    } catch (e) {
-      if (typeof e === "string") throw e
-      if (didRefresh) {
-        throw "Usage request failed after refresh. Try again."
-      }
-      throw "Usage request failed. Check your connection."
+    if (mode === "api" && !key) throw "Set KIMI_CODE_API_KEY to a Kimi Code key, not an Open Platform key."
+    const useKey = key && (mode === "auto" || mode === "api")
+    const session = mode !== "web" && !useKey && !hasOverride ? cliSession(ctx) : null
+    if (useKey || session) {
+      const base = ctx.host.http.validateBaseUrl(baseOverride || "https://api.kimi.com", false)
+      const url = base + (/\/coding\/v1$/.test(base) ? "/usages" : /\/coding$/.test(base) ? "/v1/usages" : "/coding/v1/usages")
+      resp = ctx.util.request({ method: "GET", url, headers: Object.assign({}, session && session.headers,
+        { Authorization: "Bearer " + (useKey ? key : session.token), Accept: "application/json", "User-Agent": "usagestat/" + ctx.app.version }), timeoutMs: 10000 })
+      source = useKey ? "api" : "oauth"
+    } else if (token && (mode === "web" || mode === "auto")) {
+      resp = webRequest(ctx, token, WEB_USAGE_URL, { scope: ["FEATURE_CODING"] }, 10000)
+      source = "web"
+    } else {
+      if (hasOverride) throw "Kimi endpoint overrides require an explicit API key; CLI credentials are never forwarded."
+      throw "No fresh Kimi Code credentials. Run `kimi login`, set KIMI_CODE_API_KEY, or configure a web session."
     }
 
     if (ctx.util.isAuthStatus(resp.status)) {
@@ -286,7 +262,11 @@
       throw "Usage request failed (HTTP " + String(resp.status) + "). Try again later."
     }
 
-    const data = ctx.util.tryParseJson(resp.bodyText)
+    let data = ctx.util.tryParseJson(resp.bodyText)
+    if (source === "web") {
+      const coding = data && Array.isArray(data.usages) && data.usages.find((item) => item.scope === "FEATURE_CODING")
+      data = coding ? { usage: coding.detail, limits: coding.limits } : null
+    }
     if (!data || typeof data !== "object") {
       throw "Usage response invalid. Try again later."
     }
@@ -298,7 +278,7 @@
     let weeklyCandidate = null
     const usageQuota = parseQuota(data.usage, ctx)
     if (usageQuota) {
-      weeklyCandidate = { quota: usageQuota, periodMs: null }
+      weeklyCandidate = { quota: usageQuota, periodMs: WEEK_MS }
     } else {
       const withoutSession = candidates.filter(function (candidate) {
         return candidate !== sessionCandidate
@@ -345,13 +325,14 @@
     }
 
     if (lines.length === 0) {
-      lines.push(ctx.line.badge({ label: "Status", text: "No usage data", color: "#a3a3a3" }))
+      throw "Kimi usage response did not contain measurable quota counters."
     }
 
-    return {
+    return enrichMembership(ctx, {
+      source,
       plan: parsePlanLabel(data),
       lines,
-    }
+    }, token)
   }
 
   globalThis.__openusage_plugin = { id: "kimi", probe }

package/plugins/kimi/plugin.json

@@ -6,10 +6,13 @@
   "entry": "plugin.js",
   "icon": "icon.svg",
   "brandColor": "#000000",
-  "supportedModes": ["oauth", "local"],
+  "supportedModes": ["api", "oauth", "cli", "web"],
   "autoMode": "oauth",
+  "envVars": ["KIMI_CODE_API_KEY", "KIMI_CODE_HOME", "KIMI_CODE_BASE_URL", "KIMI_CODE_OAUTH_HOST", "KIMI_OAUTH_HOST", "KIMI_AUTH_TOKEN"],
   "lines": [
     { "type": "progress", "label": "Session", "scope": "overview", "primaryOrder": 1 },
-    { "type": "progress", "label": "Weekly", "scope": "overview", "primaryOrder": 2 }
+    { "type": "progress", "label": "Weekly", "scope": "overview", "primaryOrder": 2 },
+    { "type": "progress", "label": "Monthly", "scope": "overview" },
+    { "type": "progress", "label": "Code 7-day", "scope": "detail" }
   ]
 }

package/plugins/kiro/plugin.js

@@ -88,7 +88,13 @@
   }
   function regionFromArn(profileArn) {
     const parts = String(profileArn || "").split(":")
-    return parts.length > 3 && parts[3] ? parts[3] : DEFAULT_REGION
+    if (parts.length !== 6 || parts[0] !== "arn" || parts[1] !== "aws" ||
+        parts[2] !== "codewhisperer" || !/^profile\/.+/.test(parts[5]) ||
+        /[\s\x00-\x1f\x7f]/.test(profileArn) ||
+        ["us-east-1", "eu-central-1"].indexOf(parts[3]) === -1) {
+      throw "Kiro profile ARN is invalid or uses an unsupported region. Sign in again with Kiro."
+    }
+    return parts[3]
   }
   function readStateValue(ctx, key) {
     try {
@@ -118,9 +124,12 @@
   }
   function normalizeBreakdown(ctx, raw) {
     if (!raw || typeof raw !== "object") return null
-    const currentUsage = first(raw.currentUsageWithPrecision, raw.currentUsage)
+    const totalUsage = first(raw.currentUsageWithPrecision, raw.currentUsage)
     const usageLimit = first(raw.usageLimitWithPrecision, raw.usageLimit)
-    if (currentUsage === null || usageLimit === null || usageLimit <= 0) return null
+    const overageUsed = first(raw.currentOveragesWithPrecision, raw.currentOverages)
+    if (totalUsage === null || totalUsage < 0 || usageLimit === null || usageLimit < 0) return null
+    if (overageUsed !== null && (overageUsed < 0 || overageUsed > totalUsage)) return null
+    const currentUsage = totalUsage - (overageUsed || 0)
     const bonuses = Array.isArray(raw.bonuses)
       ? raw.bonuses
           .map((item) =>
@@ -143,6 +152,11 @@
       currentUsage,
       usageLimit,
       resetDate: iso(ctx, raw.nextDateReset || raw.resetDate),
+      overageUsed,
+      overageCap: first(raw.overageCapWithPrecision, raw.overageCap),
+      overageCharges: num(raw.overageCharges),
+      overageRate: num(raw.overageRate),
+      currency: typeof raw.currency === "string" ? raw.currency : "USD",
       freeTrialUsage: normalizePool(ctx, raw.freeTrialInfo || raw.freeTrialUsage, {
         current: "currentUsage",
         preciseCurrent: "currentUsageWithPrecision",
@@ -169,11 +183,14 @@
     if (!raw || typeof raw !== "object") return null
     return {
       usageBreakdowns: Array.isArray(raw.usageBreakdownList)
-        ? raw.usageBreakdownList.map((item) => normalizeBreakdown(ctx, item)).filter(Boolean)
+        ? raw.usageBreakdownList.map((item) => normalizeBreakdown(ctx, {
+            ...item, nextDateReset: item.nextDateReset || raw.nextDateReset,
+          })).filter(Boolean)
         : [],
       timestampMs: timestampMs !== null ? timestampMs : null,
       plan: title(raw.subscriptionInfo && raw.subscriptionInfo.subscriptionTitle),
-      overageEnabled: raw.overageConfiguration ? raw.overageConfiguration.overageStatus === "ENABLED" : null,
+      overageEnabled: raw.overageConfiguration && raw.overageConfiguration.overageStatus === "ENABLED"
+        ? true : raw.overageConfiguration && raw.overageConfiguration.overageStatus === "DISABLED" ? false : null,
     }
   }
   function parseUsageLogText(ctx, text) {
@@ -274,7 +291,7 @@
       encodeURIComponent("AGENTIC_REQUEST")
 
     let accessToken = authState.token && authState.token.accessToken
-    if (!accessToken || needsRefresh(ctx, authState, nowMs)) {
+    if (!accessToken || authState.token.refreshToken && needsRefresh(ctx, authState, nowMs)) {
       const refreshed = refreshAccessToken(ctx, authState, nowMs)
       if (refreshed) accessToken = refreshed
     }
@@ -326,6 +343,7 @@
             : null,
       usageBreakdowns: usageSource.usageBreakdowns,
       timestampMs: usageSource.timestampMs !== null ? usageSource.timestampMs : nowMs,
+      source: usageSource === liveState ? "api" : "local",
     }
   }
   function pickPrimaryBreakdown(usageBreakdowns) {
@@ -347,7 +365,9 @@
   function buildOutput(ctx, snapshot, nowMs) {
     const primary = pickPrimaryBreakdown(snapshot.usageBreakdowns)
     if (!primary) throw DATA_HINT
-    const lines = [ctx.line.progress({ label: "Credits", used: primary.currentUsage, limit: primary.usageLimit, format: COUNT_FORMAT, resetsAt: primary.resetDate || undefined })]
+    const lines = [primary.usageLimit > 0
+      ? ctx.line.progress({ label: "Credits", used: primary.currentUsage, limit: primary.usageLimit, format: COUNT_FORMAT, resetsAt: primary.resetDate || undefined })
+      : ctx.line.text({ label: "Credits", value: String(primary.currentUsage) + " used; no included credits" })]
     const bonusUsage = pickBonusUsage(primary)
     if (bonusUsage) {
       lines.push(
@@ -361,17 +381,36 @@
       )
     }
     if (snapshot.overageEnabled !== null) lines.push(ctx.line.badge({ label: "Overages", text: snapshot.overageEnabled ? "Enabled" : "Disabled" }))
-    return { plan: snapshot.plan || undefined, lines }
+    if (primary.overageUsed !== null && primary.overageUsed !== undefined) {
+      if (snapshot.overageEnabled === true && primary.overageCap > 0) {
+        lines.push(ctx.line.progress({ label: "Overage Credits", used: primary.overageUsed,
+          limit: primary.overageCap, format: COUNT_FORMAT, resetsAt: primary.resetDate || undefined }))
+      } else if (primary.overageUsed > 0) {
+        lines.push(ctx.line.text({ label: "Overage Credits", value: String(primary.overageUsed) + " credits" }))
+      }
+    }
+    if (primary.overageCharges !== null && primary.overageCharges >= 0) {
+      const cap = snapshot.overageEnabled === true && primary.overageCap > 0 && primary.overageRate > 0
+        ? primary.overageCap * primary.overageRate : null
+      if (primary.currency === "USD" && cap > 0) {
+        lines.push(ctx.line.progress({ label: "Overage Charges", used: primary.overageCharges,
+          limit: cap, format: { kind: "dollars" }, resetsAt: primary.resetDate || undefined }))
+      } else {
+        lines.push(ctx.line.text({ label: "Overage Charges",
+          value: primary.currency + " " + primary.overageCharges.toFixed(2) }))
+      }
+    }
+    return { plan: snapshot.plan || undefined, lines, source: snapshot.source, fetchedAt: ctx.util.toIso(snapshot.timestampMs) }
   }
   function probe(ctx) {
     const nowMs = ctx.util.parseDateMs(ctx.nowIso) || Date.now()
     const authState = loadAuthState(ctx)
-    if (!authState || !authState.token || !authState.token.refreshToken) throw LOGIN_HINT
+    if (ctx.sourceMode !== "local" && (!authState || !authState.token)) throw LOGIN_HINT
     const localState = normalizeCachedState(ctx)
     const loggedState = loadLoggedState(ctx)
     let liveState = null
     let liveError = null
-    if (shouldTryLive(localState, loggedState, nowMs)) {
+    if (ctx.sourceMode !== "local" && shouldTryLive(localState, loggedState, nowMs)) {
       try {
         liveState = fetchLiveState(ctx, authState, nowMs)
       } catch (e) {

package/plugins/kiro/plugin.json

@@ -11,6 +11,8 @@
   "lines": [
     { "type": "progress", "label": "Credits", "scope": "overview", "primaryOrder": 1 },
     { "type": "progress", "label": "Bonus Credits", "scope": "overview" },
-    { "type": "badge", "label": "Overages", "scope": "detail" }
+    { "type": "badge", "label": "Overages", "scope": "detail" },
+    { "type": "progress", "label": "Overage Credits", "scope": "detail" },
+    { "type": "progress", "label": "Overage Charges", "scope": "detail" }
   ]
 }

package/plugins/litellm/plugin.js

@@ -9,6 +9,8 @@
   }
 
   function apiKey(ctx) {
+    if (Object.prototype.hasOwnProperty.call(ctx.provider || {}, 'apiKey')) return ctx.provider.apiKey;
+    if (ctx.provider && ctx.provider.instanceId && ctx.provider.instanceId !== 'litellm') return null;
     var configured = ctx.provider && typeof ctx.provider.apiKey === "string" ? ctx.provider.apiKey.trim() : "";
     return configured || env(ctx, "LITELLM_API_KEY");
   }
@@ -51,13 +53,14 @@
     return Number.isFinite(ms) ? new Date(ms) : null;
   }
 
-  function requestJson(ctx, base, path, key) {
+  function requestJson(ctx, base, path, key, optional) {
     var resp = ctx.util.request({
       method: "GET",
       url: base + path,
       headers: { Authorization: "Bearer " + key, Accept: "application/json" },
       timeoutMs: 15000,
     });
+    if (optional && [401,403,404].includes(resp.status)) return null;
     if (ctx.util.isAuthStatus(resp.status)) throw "LiteLLM API key was rejected.";
     if (resp.status < 200 || resp.status >= 300) {
       throw "LiteLLM API request failed (HTTP " + resp.status + ").";
@@ -189,10 +192,58 @@
     var key = apiKey(ctx);
     if (!key) throw "Missing LiteLLM API key. Set LITELLM_API_KEY or provider apiKey.";
     var base = baseUrl(ctx);
-    var info = keyInfo(requestJson(ctx, base, "/key/info", key));
+    var keyData = requestJson(ctx, base, "/key/info", key, true);
+    if (keyData === null) {
+      var end = ctx.nowIso.slice(0,10), start = end.slice(0,7)+'-01';
+      var query = '?start_date='+start+'&end_date='+end;
+      var rows = requestJson(ctx, base, '/key/spend/report'+query, key, true);
+      if (rows === null) rows = requestJson(ctx, base, '/user/spend/report'+query, key);
+      if (!Array.isArray(rows) || !rows.length) throw new Error('LiteLLM spend report is empty or invalid.');
+      var cost = 0;
+      for (var row of rows) {
+        if (typeof row.total_cost !== 'number' || !Number.isFinite(row.total_cost) || row.total_cost < 0) throw new Error('Invalid LiteLLM spend.');
+        cost += row.total_cost;
+      }
+      if (!Number.isFinite(cost)) throw new Error('Invalid LiteLLM spend total.');
+      return {source:'api',lines:[ctx.line.text({label:'Month to date',value:usd(cost),subtitle:start+' to '+end+' UTC'})]};
+    }
+    var info = keyInfo(keyData);
     var snapshot = info.userID ? userSnapshot(ctx, base, key, info) : teamSnapshot(ctx, base, key, info);
     var plan = snapshot.team && snapshot.team.alias ? snapshot.team.alias : null;
-    return { displayName: "LiteLLM", source: "api", plan: plan, lines: linesFor(snapshot) };
+    var lines = linesFor(snapshot);
+    if (info.userID && (ctx.provider?.settings?.modelUsage === true || ctx.provider?.settings?.LITELLM_MODEL_USAGE_ENABLED === 'true')) {
+      try { lines.push.apply(lines, modelActivity(ctx,base,key,info.userID)); } catch (_) { ctx.host.log.warn('LiteLLM optional model activity unavailable.'); }
+    }
+    return { displayName: "LiteLLM", source: "api", plan: plan, lines: lines };
+  }
+
+  function modelActivity(ctx,base,key,user) {
+    var end=ctx.nowIso.slice(0,10),start=new Date(Date.parse(end)-29*86400000).toISOString().slice(0,10),totals={};
+    for(var page=1;page<=3;page++) {
+      var response=ctx.host.http.request({method:'GET',url:base+'/user/daily/activity?user_id='+encodeURIComponent(user)+'&start_date='+start+'&end_date='+end+'&page='+page+'&page_size=1000',
+        headers:{Authorization:'Bearer '+key,Accept:'application/json'},timeoutMs:2000});
+      if(response.status!==200) throw new Error('Unavailable');
+      var data=ctx.util.tryParseJson(response.bodyText);
+      if(!Array.isArray(data?.results)||data.results.length>31) throw new Error('Invalid activity');
+      for(var row of data.results) {
+        if(!/^\d{4}-\d{2}-\d{2}$/.test(row.date)||row.date<start||row.date>end||!row.breakdown?.models) throw new Error('Invalid day');
+        for(var [name, value] of Object.entries(row.breakdown.models)) {
+          if(!name.trim()||name.length>256||/[\x00-\x1f]/.test(name)||['__proto__','constructor','prototype'].includes(name)) throw new Error('Invalid model');
+          var metrics=value.metrics||value,prior=totals[name]||[0,0,0,0];
+          totals[name]=['prompt_tokens','completion_tokens','total_tokens','api_requests'].map(function(field,i){
+            var n=metrics[field]; if(!Number.isSafeInteger(n)||n<0||!Number.isSafeInteger(n+prior[i])) throw new Error('Invalid count'); return n+prior[i];
+          });
+          if(Object.keys(totals).length>1000) throw new Error('Too many models');
+        }
+      }
+      var metadata=data.metadata||{};
+      if(metadata.page!=null&&metadata.page!==page) throw new Error('Repeated page');
+      if(metadata.has_more!=null&&typeof metadata.has_more!=='boolean') throw new Error('Invalid page');
+      if(metadata.total_pages!=null&&(!Number.isSafeInteger(metadata.total_pages)||metadata.total_pages<1)) throw new Error('Invalid page');
+      if(metadata.has_more!==true&&page>=(metadata.total_pages||1)) return Object.entries(totals).sort((a,b)=>b[1][2]-a[1][2]).slice(0,20)
+        .map(([name,n])=>ctx.line.text({label:name,value:n[2]+' tokens / '+n[3]+' requests',subtitle:'30d UTC: '+n[0]+' input / '+n[1]+' output'}));
+    }
+    throw new Error('Incomplete activity');
   }
 
   globalThis.__openusage_plugin = { id: "litellm", probe: probe };

package/plugins/llmman/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peter Steinberger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.