usagemax 0.1.1 → 0.3.0

package/src/core.js

@@ -22,15 +22,103 @@ function text(value, fallback, maximum = 120) {
 }
 
 function providerFor(model, source) {
-  const name = model.toLowerCase();
+  const displayName = model.toLowerCase().replace(/^\[[^\]]+\]\s*/, "");
+  const name = displayName.replace(/^api[-_:]/, "");
+  if (name.startsWith("openrouter/")) return "openrouter";
+  if (name.startsWith("azure/") || name.startsWith("azure-openai/")) return "azure-openai";
+  if (name.startsWith("bedrock/") || name.startsWith("aws/")) return "aws-bedrock";
+  if (name.startsWith("vertex/") || name.startsWith("vertex_ai/") || name.startsWith("google/")) return "google";
   if (name.includes("claude")) return "anthropic";
   if (/^(?:gpt|o[1345]|codex)/.test(name) || name.includes("openai")) return "openai";
   if (name.includes("gemini")) return "google";
   if (name.includes("grok")) return "xai";
   if (name.includes("deepseek")) return "deepseek";
+  if (name.includes("kimi") || name.includes("moonshot")) return "moonshot";
+  if (name.includes("qwen")) return "alibaba";
+  if (name.includes("glm") || name.includes("zai") || name.includes("z.ai")) return "zai";
+  if (name.includes("mistral") || name.includes("codestral")) return "mistral";
+  if (name.includes("llama") || name.includes("meta/")) return "meta";
+  if (name.includes("minimax")) return "minimax";
+  if (name.includes("command-r") || name.includes("cohere")) return "cohere";
   return source;
 }
 
+const snapshotCounterFields = [
+  "inputTokens",
+  "outputTokens",
+  "cacheReadTokens",
+  "cacheWriteTokens",
+  "reasoningTokens",
+  "unclassifiedTokens",
+  "totalTokens",
+  "costMicros",
+  "requests",
+  "errors",
+];
+
+function snapshotCounters(value = {}) {
+  const inputTokens = number(value.inputTokens);
+  const outputTokens = number(value.outputTokens);
+  const cacheReadTokens = number(value.cacheReadTokens);
+  const cacheWriteTokens = number(value.cacheWriteTokens);
+  const reasoningTokens = number(value.reasoningTokens);
+  const suppliedTotal = number(value.totalTokens);
+  const classified = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens + reasoningTokens;
+  const unclassifiedTokens = value.unclassifiedTokens === undefined
+    ? Math.max(0, suppliedTotal - classified)
+    : number(value.unclassifiedTokens);
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheWriteTokens,
+    reasoningTokens,
+    unclassifiedTokens,
+    totalTokens: classified + unclassifiedTokens,
+    costMicros: number(value.costMicros, MAX_SAFE_COST_MICROS),
+    requests: number(value.requests),
+    errors: number(value.errors),
+  };
+}
+
+function sameCounters(left, right) {
+  return snapshotCounterFields.every((field) => left[field] === right[field]);
+}
+
+function snapshotKey(source, period, provider, model) {
+  return `${source}\u001f${period}\u001f${provider}\u001f${model}`;
+}
+
+function readSnapshotKey(key) {
+  const parts = String(key).split("\u001f");
+  if (parts.length === 4) return { source: parts[0], period: parts[1], provider: parts[2], model: parts[3] };
+  if (parts.length === 3) return { source: parts[0], period: parts[1], provider: providerFor(parts[2], parts[0]), model: parts[2] };
+  return null;
+}
+
+function normalizedSnapshotRows(report) {
+  const rows = new Map();
+  for (const row of currentRows(report)) {
+    const provider = providerFor(row.model, row.source);
+    const key = snapshotKey(row.source, row.period, provider, row.model);
+    const current = snapshotCounters(row.current);
+    const existing = rows.get(key);
+    if (existing) {
+      for (const field of snapshotCounterFields) existing.current[field] += current[field];
+    } else {
+      rows.set(key, {
+        key,
+        source: row.source,
+        period: row.period,
+        provider,
+        model: row.model,
+        current,
+      });
+    }
+  }
+  return rows;
+}
+
 function sha256(value) {
   return createHash("sha256").update(value).digest("hex");
 }
@@ -74,6 +162,8 @@ function currentRows(report) {
             cacheReadTokens: rawAgent.cacheReadTokens,
             cost: rawAgent.totalCost,
           }];
+      let allocatedTokens = 0;
+      let allocatedCostMicros = 0;
       for (const rawBreakdown of breakdowns) {
         if (!rawBreakdown || typeof rawBreakdown !== "object") continue;
         const model = text(rawBreakdown.modelName, "unknown", 120);
@@ -82,6 +172,10 @@ function currentRows(report) {
         const cacheWriteTokens = number(rawBreakdown.cacheCreationTokens);
         const cacheReadTokens = number(rawBreakdown.cacheReadTokens);
         const costMicros = moneyMicros(rawBreakdown.cost);
+        const classifiedTokens = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+        const totalTokens = Math.max(classifiedTokens, number(rawBreakdown.totalTokens));
+        allocatedTokens += totalTokens;
+        allocatedCostMicros += costMicros;
         rows.push({
           key: `${source}\u001f${period}\u001f${model}`,
           source,
@@ -92,11 +186,29 @@ function currentRows(report) {
             outputTokens,
             cacheReadTokens,
             cacheWriteTokens,
-            totalTokens: inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens,
+            totalTokens,
             costMicros,
           },
         });
       }
+      const residualTokens = Math.max(0, number(rawAgent.totalTokens) - allocatedTokens);
+      const residualCostMicros = Math.max(0, moneyMicros(rawAgent.totalCost) - allocatedCostMicros);
+      if (residualTokens > 0 || residualCostMicros > 0) {
+        rows.push({
+          key: `${source}\u001f${period}\u001funattributed`,
+          source,
+          period,
+          model: "unattributed",
+          current: {
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            cacheWriteTokens: 0,
+            totalTokens: residualTokens,
+            costMicros: residualCostMicros,
+          },
+        });
+      }
     }
   }
   return rows;
@@ -159,6 +271,118 @@ export function buildDeltaPlan(report, priorSnapshots, deviceId, pricingVersion
   return { plan, regressions };
 }
 
+export function buildSnapshotPlan(report, priorSnapshots, {
+  bootstrap = false,
+  complete = true,
+  full = false,
+  pricingVersion = "ccusage",
+  revision = Date.now(),
+  runId = randomPlanId(),
+} = {}) {
+  const rows = normalizedSnapshotRows(report);
+  const priorRows = new Map();
+  const snapshots = priorSnapshots && typeof priorSnapshots === "object" ? priorSnapshots : {};
+  for (const [rawKey, rawValue] of Object.entries(snapshots)) {
+    const identity = readSnapshotKey(rawKey);
+    if (!identity || !/^\d{4}-\d{2}-\d{2}$/.test(identity.period)) continue;
+    const key = snapshotKey(identity.source, identity.period, identity.provider, identity.model);
+    priorRows.set(key, {
+      key,
+      ...identity,
+      current: snapshotCounters(rawValue),
+    });
+  }
+
+  const currentPartitions = new Set([...rows.values()].map((row) => `${row.source}\u001f${row.period}`));
+  const allKeys = new Set(rows.keys());
+  for (const [key, prior] of priorRows) {
+    if (full || currentPartitions.has(`${prior.source}\u001f${prior.period}`)) allKeys.add(key);
+  }
+
+  const grouped = new Map();
+  const nextSnapshots = {};
+  const regressions = [];
+  for (const key of allKeys) {
+    const currentRow = rows.get(key);
+    const priorRow = priorRows.get(key);
+    const identity = currentRow || priorRow;
+    if (!identity) continue;
+    const previous = priorRow?.current ?? snapshotCounters();
+    const current = currentRow?.current ?? snapshotCounters();
+    if (snapshotCounterFields.some((field) => current[field] < previous[field])) regressions.push(key);
+    if (!sameCounters(current, snapshotCounters())) nextSnapshots[key] = current;
+    const partitionKey = `${identity.source}\u001f${identity.period}`;
+    const rowsForPartition = grouped.get(partitionKey) ?? [];
+    rowsForPartition.push({
+      snapshotKey: key,
+      provider: identity.provider,
+      model: identity.model,
+      previous,
+      current,
+      costBasis: "estimated",
+      contentHash: sha256(`${key}\u001f${JSON.stringify(current)}`),
+      lastUsedAt: Date.parse(`${identity.period}T12:00:00.000Z`),
+    });
+    grouped.set(partitionKey, rowsForPartition);
+  }
+
+  const partitions = [];
+  for (const [partitionKey, partitionRows] of grouped) {
+    const [source, day] = partitionKey.split("\u001f");
+    const changed = partitionRows.some((row) => !sameCounters(row.previous, row.current));
+    if (!bootstrap && !full && !changed) continue;
+    partitionRows.sort((left, right) => `${left.provider}/${left.model}`.localeCompare(`${right.provider}/${right.model}`));
+    const wireRows = partitionRows.map(({ provider, model, previous, current, costBasis, contentHash, lastUsedAt }) => ({
+      provider,
+      model,
+      previous,
+      current,
+      costBasis,
+      contentHash,
+      lastUsedAt,
+    }));
+    const payloadHash = sha256(JSON.stringify({ source, day, complete, pricingVersion, rows: wireRows }));
+    partitions.push({
+      partitionId: `${runId}:${sha256(partitionKey).slice(0, 24)}`,
+      payloadHash,
+      revision,
+      source,
+      day,
+      complete,
+      pricingVersion,
+      rows: wireRows,
+    });
+  }
+  partitions.sort((left, right) => left.day === right.day ? left.source.localeCompare(right.source) : left.day.localeCompare(right.day));
+  return { partitions, nextSnapshots, regressions };
+}
+
+function randomPlanId() {
+  return `run-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+export function buildSessionPlan(report, deviceId) {
+  const sessionRows = Array.isArray(report?.session) ? report.session : [];
+  const sessions = new Map();
+  for (const row of sessionRows) {
+    if (!row || typeof row !== "object") continue;
+    const source = text(row.agent, "unknown", 60).toLowerCase();
+    const stableIdentity = text(row.period ?? row.sessionId ?? row.id, "", 1000);
+    if (!stableIdentity) continue;
+    const metadata = row.metadata && typeof row.metadata === "object" ? row.metadata : {};
+    const firstActivityAt = Date.parse(metadata.firstActivity ?? metadata.createdAt ?? "");
+    const lastActivityAt = Date.parse(metadata.lastActivity ?? row.lastActivity ?? "");
+    const sessionKey = sha256(`${deviceId}\u001f${source}\u001f${stableIdentity}`);
+    sessions.set(`${source}\u001f${sessionKey}`, {
+      source,
+      sessionKey,
+      ...(Number.isFinite(firstActivityAt) ? { firstActivityAt } : {}),
+      ...(Number.isFinite(lastActivityAt) ? { lastActivityAt } : {}),
+    });
+  }
+  return [...sessions.values()].sort((left, right) => `${left.source}/${left.sessionKey}`.localeCompare(`${right.source}/${right.sessionKey}`));
+}
+
 export function batchId(deviceId, events) {
   const identity = events.map((event) => event.eventKey).join("\u001f");
   return `cli:${deviceId}:${sha256(identity).slice(0, 32)}`;