@nyte-ai/host 0.0.0-stage → 0.0.19

package/src/usage-service.ts

@@ -0,0 +1,82 @@
+import { join } from "node:path";
+import { FileModelsStore, nyteProviders } from "@nyte-ai/ai";
+import { createModels } from "@nyte-ai/ai/models";
+import type { Models } from "@nyte-ai/ai";
+import { serial } from "@nyte-ai/schema/serial";
+import type { Api, Model } from "@nyte-ai/schema/model";
+import { readNyteUsage } from "./store-usage.ts";
+import {
+  loadUsageScanCaches,
+  readLocalUsage,
+  saveUsageScanCaches,
+  type UsageScanCaches,
+} from "./usage.ts";
+import type { UsageSnapshot, UsageWindow } from "./usage-types.ts";
+
+export interface UsageScanRequest {
+  readonly window: UsageWindow;
+  readonly catalog?: readonly Model<Api>[];
+}
+
+export type UsageScan = UsageSnapshot;
+
+export interface UsageScanReader {
+  scan(request: UsageScanRequest): Promise<UsageScan>;
+  close(): Promise<void>;
+}
+
+export function catalogForUsage(models: Pick<Models, "getModels">): readonly Model<Api>[] {
+  return [...models.getModels("anthropic"), ...models.getModels("openai-codex")];
+}
+
+export class UsageScanner implements UsageScanReader {
+  private readonly home: string;
+  private readonly cachePath: string;
+  private caches: UsageScanCaches | undefined;
+  private readonly models: ReturnType<typeof createModels>;
+  private readonly scans = serial();
+
+  constructor(home: string) {
+    this.home = home;
+    this.cachePath = join(home, ".nyte", "usage-scan-cache.json");
+    this.models = createModels({
+      modelsStore: new FileModelsStore(join(home, ".nyte", "models-store.json")),
+    });
+
+    for (const provider of nyteProviders()) this.models.setProvider(provider);
+  }
+
+  scan(request: UsageScanRequest): Promise<UsageScan> {
+    return this.scans.run(async () => {
+      if (request.catalog === undefined)
+        await this.models.refresh({
+          providers: ["anthropic", "openai-codex"],
+          allowNetwork: false,
+        });
+      const catalog = request.catalog;
+
+      const models: Pick<Models, "getModels"> =
+        catalog === undefined
+          ? this.models
+          : {
+              getModels: (provider) =>
+                catalog.filter((model) => provider === undefined || model.provider === provider),
+            };
+
+      const caches = (this.caches ??= await loadUsageScanCaches(this.cachePath));
+      const local = await readLocalUsage({ models, window: request.window, caches });
+      const report = readNyteUsage(this.home, request.window);
+      void this.scans.run(() => saveUsageScanCaches(this.cachePath, caches));
+
+      return {
+        ...report,
+        ...local,
+        nyteError: report.sources.find((source) => source.status === "failed")?.message ?? null,
+      };
+    });
+  }
+
+  close(): Promise<void> {
+    return this.scans.settled();
+  }
+}

package/src/usage-summary.ts

@@ -0,0 +1,79 @@
+import { addUsage } from "@nyte-ai/core/server";
+import type { Usage } from "@nyte-ai/schema";
+import type { Usage as ModelUsageCounts } from "@nyte-ai/schema/model";
+import type { ModelUsage, UsageSummary } from "./usage-types.ts";
+
+export function emptyModelUsage(): ModelUsageCounts {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+  };
+}
+
+export function recordedUsage(usage: ModelUsageCounts): Usage {
+  return {
+    input: usage.input,
+    output: usage.output,
+    cacheRead: usage.cacheRead,
+    cacheWrite: usage.cacheWrite,
+    reasoning: usage.reasoning ?? null,
+    total: usage.totalTokens,
+    cost: { ...usage.cost },
+  };
+}
+
+export function emptyUsageSummary(): UsageSummary {
+  return {
+    models: [],
+    compaction: recordedUsage(emptyModelUsage()),
+    tools: recordedUsage(emptyModelUsage()),
+    total: recordedUsage(emptyModelUsage()),
+    cacheSavings: 0,
+  };
+}
+
+export function summarizeModels(rows: readonly ModelUsage[]): UsageSummary {
+  const models = new Map<string, ModelUsage>();
+  let total = recordedUsage(emptyModelUsage());
+  let savings = 0;
+
+  for (const row of rows) {
+    savings += cacheSavings(row.usage);
+    const key = JSON.stringify([row.provider, row.model]);
+    const previous = models.get(key);
+    models.set(
+      key,
+      previous === undefined
+        ? row
+        : { ...row, turns: previous.turns + row.turns, usage: addUsage(previous.usage, row.usage) },
+    );
+    total = addUsage(total, row.usage);
+  }
+
+  return {
+    ...emptyUsageSummary(),
+    models: [...models.values()].toSorted(
+      (left, right) =>
+        right.usage.cost.total - left.usage.cost.total ||
+        right.usage.total - left.usage.total ||
+        left.model.localeCompare(right.model) ||
+        left.provider.localeCompare(right.provider),
+    ),
+    total,
+    cacheSavings: savings,
+  };
+}
+
+export function cacheSavings(usage: Usage): number {
+  if (usage.input === 0) return 0;
+
+  return usage.cacheRead * (usage.cost.input / usage.input) - usage.cost.cacheRead;
+}
+
+export function usageTokens(usage: Usage): number {
+  return usage.total || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}

package/src/usage-types.ts

@@ -0,0 +1,87 @@
+import type { SessionId, Usage } from "@nyte-ai/schema";
+
+export interface UsageWindow {
+  readonly sinceDay: string | null;
+  readonly untilDay: string;
+}
+
+export interface UsageTotals {
+  readonly input: number;
+  readonly output: number;
+  readonly cacheRead: number;
+  readonly cacheWrite: number;
+  readonly reasoning: number;
+  readonly tokens: number;
+  readonly cost: number;
+  readonly cacheSavings: number;
+}
+
+export type UsageSubject =
+  | { readonly kind: "model"; readonly provider: string; readonly model: string }
+  | { readonly kind: "tool" }
+  | { readonly kind: "compaction" };
+
+export interface UsageEntry {
+  readonly day: string;
+  readonly workspacePath: string | null;
+  readonly sessionId: SessionId;
+  readonly subject: UsageSubject;
+  readonly totals: UsageTotals;
+}
+
+export interface UsageSession {
+  readonly sessionId: SessionId;
+  readonly name?: string;
+  readonly workspacePath: string | null;
+  readonly lastActivityAt: number;
+}
+
+export interface UsageSource {
+  readonly workspacePath: string | null;
+  readonly status: "ok" | "failed";
+  readonly sessions: number;
+  readonly message: string | null;
+}
+
+export interface UsageReport {
+  readonly readAt: number;
+  readonly sinceDay: string;
+  readonly untilDay: string;
+  readonly entries: readonly UsageEntry[];
+  readonly sessions: readonly UsageSession[];
+  readonly sources: readonly UsageSource[];
+  readonly previous?: { readonly cost: number; readonly tokens: number };
+  readonly earliestDay?: string;
+}
+
+export interface ModelUsage {
+  readonly provider: string;
+  readonly model: string;
+  readonly turns: number;
+  readonly usage: Usage;
+}
+
+export interface UsageSummary {
+  readonly models: readonly ModelUsage[];
+  readonly compaction: Usage;
+  readonly tools: Usage;
+  readonly total: Usage;
+  readonly cacheSavings: number;
+}
+
+export type LocalHistoryUsage =
+  | { readonly kind: "missing" }
+  | { readonly kind: "failed"; readonly message: string }
+  | {
+      readonly kind: "ready";
+      readonly summary: UsageSummary;
+      readonly unpricedRecords: number;
+      readonly malformedRecords: number;
+      readonly unreadableFiles: number;
+    };
+
+export interface UsageSnapshot extends UsageReport {
+  readonly nyteError: string | null;
+  readonly claudeCode: LocalHistoryUsage;
+  readonly codex: LocalHistoryUsage;
+}

package/src/usage-worker.ts

@@ -0,0 +1,24 @@
+import { parentPort } from "node:worker_threads";
+import { UsageScanner } from "./usage-service.ts";
+import type { UsageWorkerReply, UsageWorkerRequest } from "./usage-scan.ts";
+
+const port = parentPort;
+
+if (port === null) throw new Error("The usage worker must run on a worker thread.");
+
+let scanner: UsageScanner | undefined;
+
+port.on("message", (request: UsageWorkerRequest) => {
+  scanner ??= new UsageScanner(request.home);
+  void scanner.scan(request).then(
+    (scan) => {
+      port.postMessage({ id: request.id, scan } satisfies UsageWorkerReply);
+    },
+    (cause: unknown) => {
+      port.postMessage({
+        id: request.id,
+        error: cause instanceof Error ? cause.message : String(cause),
+      } satisfies UsageWorkerReply);
+    },
+  );
+});