llm-usage-metrics 0.7.0 → 0.7.1

package/README.md

@@ -214,6 +214,9 @@ llm-usage monthly --pricing-offline
 
 # Continue even if pricing fetch fails
 llm-usage monthly --ignore-pricing-failures
+
+# Override per-model pricing from a local JSON file
+llm-usage monthly --pricing-overrides ./pricing-overrides.json
 ```
 
 ## 🧪 Production Benchmarks
@@ -313,8 +316,8 @@ See full environment variable reference in the [documentation](https://ayagmar.g
 The CLI performs lightweight update checks with smart defaults:
 
 - 1-hour cache TTL
-- Fresh cached update results are used immediately
-- Stale or missing cache refreshes in the background instead of blocking report execution
+- Fresh cached update results are used immediately without any network call
+- Stale or missing cache triggers a bounded fetch (default 1s timeout) so the update prompt stays consistent across commands, instead of silently skipping the run that refreshes the cache
 - Skipped for `--help`, `--version`, `npx`, and direct source/development runs
 - Prompts only in interactive TTY sessions
 

package/dist/index.js

@@ -106,9 +106,6 @@ function getParsingRuntimeConfig(env = process.env) {
   };
 }
 
-// src/update/update-notifier.ts
-import { spawn as spawn2 } from "child_process";
-
 // src/update/update-cache-repository.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
 import path2 from "path";
@@ -529,7 +526,6 @@ async function runInteractiveInstallAndRestart(options) {
 
 // src/update/update-notifier.ts
 var UPDATE_CHECK_SKIP_ENV_VAR = "LLM_USAGE_SKIP_UPDATE_CHECK";
-var UPDATE_CHECK_REFRESH_ENV_VAR = "LLM_USAGE_REFRESH_UPDATE_CHECK";
 function isTruthyEnvFlag(value) {
   if (value === void 0) {
     return false;
@@ -588,32 +584,6 @@ function toResolveLatestVersionOptions(options, env) {
     now: options.now
   };
 }
-function runDetachedCommandWithSpawn(command, args, options = {}) {
-  const child = spawn2(command, args, {
-    env: options.env,
-    stdio: options.stdio ?? "ignore",
-    detached: true
-  });
-  child.on("error", () => void 0);
-  child.unref();
-}
-function scheduleBackgroundUpdateRefresh(options, env, argv) {
-  const spawnDetachedCommand = options.spawnDetachedCommand ?? runDetachedCommandWithSpawn;
-  spawnDetachedCommand(options.execPath ?? process.execPath, argv.slice(1), {
-    env: {
-      ...env,
-      [UPDATE_CHECK_REFRESH_ENV_VAR]: "1"
-    },
-    stdio: "ignore"
-  });
-}
-async function refreshUpdateCheckCache(options) {
-  try {
-    const env = options.env ?? process.env;
-    await resolveLatestVersion(toResolveLatestVersionOptions(options, env));
-  } catch {
-  }
-}
 async function checkForUpdatesAndMaybeRestart(options) {
   const env = options.env ?? process.env;
   const argv = options.argv ?? process.argv;
@@ -630,19 +600,7 @@ async function checkForUpdatesAndMaybeRestart(options) {
     return { continueExecution: true };
   }
   try {
-    const resolveOptions = toResolveLatestVersionOptions(options, env);
-    const cacheFilePath = resolveOptions.cacheFilePath ?? getDefaultUpdateCheckCachePath();
-    const cachePayload = await readUpdateCheckCachePayload(cacheFilePath);
-    const cacheTtlMs = resolveOptions.cacheTtlMs ?? DEFAULT_UPDATE_CHECK_CACHE_TTL_MS;
-    const now = resolveOptions.now ?? Date.now;
-    if (!cachePayload || !isCacheFresh(cachePayload, cacheTtlMs, now)) {
-      try {
-        scheduleBackgroundUpdateRefresh(options, env, argv);
-      } catch {
-      }
-      return { continueExecution: true };
-    }
-    const latestVersion = cachePayload.latestVersion;
+    const latestVersion = await resolveLatestVersion(toResolveLatestVersionOptions(options, env));
     if (!latestVersion || !shouldOfferUpdate(options.currentVersion, latestVersion)) {
       return { continueExecution: true };
     }
@@ -2659,7 +2617,7 @@ function aggregateEfficiency(options) {
 }
 
 // src/efficiency/git-outcome-collector.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { createInterface as createInterface2 } from "readline";
 import path3 from "path";
 import { stat } from "fs/promises";
@@ -2858,7 +2816,7 @@ function parseGitLogShortstatLines(lines, authorEmail) {
 }
 async function runGitCommand(repoDir, args) {
   return await new Promise((resolve, reject) => {
-    const child = spawn3("git", args, {
+    const child = spawn2("git", args, {
       cwd: repoDir,
       env: {
         ...process.env,
@@ -3763,13 +3721,16 @@ function parseUsage(usage) {
     totalTokens
   };
 }
-function createDedupKey(filePath, line, message) {
+function createDedupKey(filePath, line, message, timestamp, model) {
   const messageId = asTrimmedText(message.id);
   if (messageId) {
     return `${filePath}\0${messageId}`;
   }
   const uuid = asTrimmedText(line.uuid);
-  return uuid ? `${filePath}\0${uuid}` : void 0;
+  if (uuid) {
+    return `${filePath}\0${uuid}`;
+  }
+  return `${filePath}\0${timestamp}\0${model ?? ""}`;
 }
 function comparePendingEvents(left, right) {
   if (left.timestamp !== right.timestamp) {
@@ -3842,12 +3803,7 @@ var ClaudeSourceAdapter = class {
         incrementSkippedReason(skippedRowReasons, "invalid_timestamp");
         continue;
       }
-      const dedupKey = createDedupKey(filePath, line, message);
-      if (!dedupKey) {
-        skippedRows++;
-        incrementSkippedReason(skippedRowReasons, "missing_message_id");
-        continue;
-      }
+      const dedupKey = createDedupKey(filePath, line, message, timestamp, model);
       const sessionId = asTrimmedText(line.sessionId) ?? getFallbackSessionId(filePath);
       const repoRoot = asTrimmedText(line.cwd);
       const provider = resolveProvider(message, model);
@@ -6462,8 +6418,91 @@ function applyPricingToEvents(events, pricingSource) {
   });
 }
 
+// src/pricing/pricing-override-source.ts
+import { readFile as readFile5 } from "fs/promises";
+function toFiniteUsdRate(value) {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return void 0;
+  }
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function normalizeReasoningBilling(value) {
+  if (value === "included-in-output" || value === "separate") {
+    return value;
+  }
+  return void 0;
+}
+function normalizePricingOverride(raw) {
+  const inputPer1MUsd = toFiniteUsdRate(toNumberLike(raw.inputPer1MUsd));
+  const outputPer1MUsd = toFiniteUsdRate(toNumberLike(raw.outputPer1MUsd));
+  if (inputPer1MUsd === void 0 || outputPer1MUsd === void 0) {
+    return void 0;
+  }
+  const cacheReadPer1MUsd = toFiniteUsdRate(toNumberLike(raw.cacheReadPer1MUsd));
+  const cacheWritePer1MUsd = toFiniteUsdRate(toNumberLike(raw.cacheWritePer1MUsd));
+  const reasoningPer1MUsd = toFiniteUsdRate(toNumberLike(raw.reasoningPer1MUsd));
+  const reasoningBilling = normalizeReasoningBilling(raw.reasoningBilling);
+  return {
+    inputPer1MUsd,
+    outputPer1MUsd,
+    ...cacheReadPer1MUsd !== void 0 ? { cacheReadPer1MUsd } : {},
+    ...cacheWritePer1MUsd !== void 0 ? { cacheWritePer1MUsd } : {},
+    ...reasoningPer1MUsd !== void 0 ? { reasoningPer1MUsd } : {},
+    ...reasoningBilling !== void 0 ? { reasoningBilling } : {}
+  };
+}
+function normalizeOverrideFile(payload) {
+  const root = asRecord(payload);
+  const overrides = /* @__PURE__ */ new Map();
+  const modelsRecord = asRecord(root?.models);
+  if (!modelsRecord) {
+    return overrides;
+  }
+  for (const [modelName, rawPricing] of Object.entries(modelsRecord)) {
+    const normalizedModelName = asTrimmedText(modelName)?.toLowerCase();
+    if (!normalizedModelName) {
+      continue;
+    }
+    const pricing = normalizePricingOverride(asRecord(rawPricing) ?? {});
+    if (pricing) {
+      overrides.set(normalizedModelName, pricing);
+    }
+  }
+  return overrides;
+}
+async function loadPricingOverrides(filePath) {
+  const fileContents = await readFile5(filePath, "utf8");
+  const parsed = JSON.parse(fileContents);
+  return normalizeOverrideFile(parsed);
+}
+var PricingOverrideSource = class {
+  overrides;
+  delegate;
+  constructor(overrides, delegate) {
+    this.overrides = overrides;
+    this.delegate = delegate;
+  }
+  resolveModelAlias(model) {
+    if (this.overrides.has(model.toLowerCase())) {
+      return model;
+    }
+    return this.delegate.resolveModelAlias(model);
+  }
+  getPricing(model) {
+    const override = this.overrides.get(model.toLowerCase());
+    if (override) {
+      return override;
+    }
+    return this.delegate.getPricing(model);
+  }
+};
+
 // src/pricing/litellm-pricing-fetcher.ts
-import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
 import path13 from "path";
 
 // src/pricing/litellm-model-map.json
@@ -7007,7 +7046,7 @@ var LiteLLMPricingFetcher = class {
   async readCachePayload() {
     let content;
     try {
-      content = await readFile5(this.cacheFilePath, "utf8");
+      content = await readFile6(this.cacheFilePath, "utf8");
     } catch {
       return void 0;
     }
@@ -7054,7 +7093,27 @@ var LiteLLMPricingFetcher = class {
 };
 
 // src/cli/build-usage-data-pricing.ts
+function wrapWithPricingOverrides(overrides, delegate) {
+  if (!overrides || overrides.size === 0) {
+    return delegate;
+  }
+  return new PricingOverrideSource(overrides, delegate);
+}
 async function resolvePricingSource(options, runtimeConfig) {
+  let pricingOverrides;
+  if (options.pricingOverrides) {
+    try {
+      pricingOverrides = await loadPricingOverrides(options.pricingOverrides);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Could not load --pricing-overrides from ${options.pricingOverrides}: ${reason}`,
+        {
+          cause: error
+        }
+      );
+    }
+  }
   const litellmPricingFetcher = new LiteLLMPricingFetcher({
     sourceUrl: options.pricingUrl,
     offline: options.pricingOffline,
@@ -7063,10 +7122,11 @@ async function resolvePricingSource(options, runtimeConfig) {
   });
   try {
     const fromCache = await litellmPricingFetcher.load();
+    const source = wrapWithPricingOverrides(pricingOverrides, litellmPricingFetcher);
     if (options.pricingOffline) {
-      return { source: litellmPricingFetcher, origin: "offline-cache" };
+      return { source, origin: "offline-cache" };
     }
-    return { source: litellmPricingFetcher, origin: fromCache ? "cache" : "network" };
+    return { source, origin: fromCache ? "cache" : "network" };
   } catch (error) {
     if (options.pricingOffline) {
       throw new Error("Offline pricing mode enabled but cached pricing is unavailable", {
@@ -7634,7 +7694,7 @@ function emitEnvVarOverrides(activeEnvOverrides, diagnosticsLogger) {
 }
 
 // src/cli/share-artifact.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { constants as constants3 } from "fs";
 import { access as access3, writeFile as writeFile4 } from "fs/promises";
 import path14 from "path";
@@ -7716,7 +7776,7 @@ async function resolveOpenCommand(filePath, platform) {
 }
 async function spawnDetached(command, args) {
   await new Promise((resolve, reject) => {
-    const child = spawn4(command, args, {
+    const child = spawn3(command, args, {
       detached: true,
       stdio: "ignore",
       windowsHide: true
@@ -9916,7 +9976,10 @@ function registerSharedReportOptions(command, profile) {
     "--model <name>",
     "Filter by model (repeatable/comma-separated; exact when exact match exists after source/provider/date filters, otherwise substring)",
     collectRepeatedOption
-  ).option("--pricing-url <url>", "Override LiteLLM pricing source URL").option("--pricing-offline", "Use cached LiteLLM pricing only (no network fetch)").option(
+  ).option("--pricing-url <url>", "Override LiteLLM pricing source URL").option(
+    "--pricing-overrides <path>",
+    "Path to a JSON file of per-model pricing overrides (takes precedence over LiteLLM)"
+  ).option("--pricing-offline", "Use cached LiteLLM pricing only (no network fetch)").option(
     "--ignore-pricing-failures",
     "Continue without estimated costs when pricing cannot be loaded"
   ).option("--json", "Render output as JSON");
@@ -10230,15 +10293,6 @@ var { packageName, packageVersion } = loadPackageMetadataFromRuntime();
 var updateRuntimeConfig = getUpdateNotifierRuntimeConfig();
 var cli = createCli({ version: packageVersion });
 async function main() {
-  if (process.env[UPDATE_CHECK_REFRESH_ENV_VAR] === "1") {
-    await refreshUpdateCheckCache({
-      packageName,
-      currentVersion: packageVersion,
-      cacheTtlMs: updateRuntimeConfig.cacheTtlMs,
-      fetchTimeoutMs: updateRuntimeConfig.fetchTimeoutMs
-    });
-    return;
-  }
   const updateResult = await checkForUpdatesAndMaybeRestart({
     packageName,
     currentVersion: packageVersion,