@nyte-ai/host 0.0.0-stage → 0.0.18

package/src/store-rows.ts

@@ -0,0 +1,110 @@
+import { asId, SdkError } from "@nyte-ai/schema";
+import type { ByteReader, Ref, Revision, SessionEvent } from "@nyte-ai/schema";
+import { loggedEvent } from "@nyte-ai/core/store";
+import type { LoggedRow, StoredObject, StoredRecord } from "@nyte-ai/core/store";
+
+export function prefixEnd(prefix: string): string | null {
+  const points = Array.from(prefix);
+  const last = points.pop()?.codePointAt(0);
+
+  if (last === undefined) return null;
+
+  if (last === 0x10ffff) return prefixEnd(points.join(""));
+
+  return points.join("") + String.fromCodePoint(last === 0xd7ff ? 0xe000 : last + 1);
+}
+
+export function mintRevision(): Revision {
+  return asId<"revision">(crypto.randomUUID());
+}
+
+export function decodeEvent(seq: number, at: number, text: string): SessionEvent {
+  return loggedEvent(seq, at, JSON.parse(text));
+}
+
+export function parseNumber(value: unknown): number {
+  if (typeof value === "number") return value;
+
+  if (typeof value === "bigint" || typeof value === "string") return Number(value);
+
+  throw new SdkError("internal", "A stored number is malformed.");
+}
+
+export function parseText(value: unknown): string | null {
+  if (value === null || value === undefined) return null;
+
+  if (typeof value === "string") return value;
+
+  throw new SdkError("internal", "A stored text column is malformed.");
+}
+
+export function parseRef(row: Readonly<Record<string, unknown>>): Ref {
+  const name = parseText(row.name);
+  const revision = parseText(row.revision);
+  const target = parseText(row.target);
+
+  if (name === null || revision === null)
+    throw new SdkError("internal", "A stored ref is malformed.");
+
+  return {
+    name,
+    target: target === null ? null : asId<"object">(target),
+    revision: asId<"revision">(revision),
+  };
+}
+
+export function parseStoredRecord(row: Readonly<Record<string, unknown>>): StoredRecord {
+  const name = parseText(row.name);
+  const target = parseText(row.target);
+  const revision = parseText(row.revision);
+  const body = parseText(row.body);
+
+  if (name === null || target === null || revision === null || body === null)
+    throw new SdkError("internal", "A stored ref is malformed.");
+
+  return { name, target: asId<"object">(target), revision, body };
+}
+
+export function parseStoredObject(row: Readonly<Record<string, unknown>>): StoredObject {
+  const id = parseText(row.id);
+  const body = parseText(row.body);
+
+  if (id === null || body === null) throw new SdkError("internal", "A stored object is malformed.");
+
+  return { id: asId<"object">(id), body };
+}
+
+export function loggedRow(row: Readonly<Record<string, unknown>>): LoggedRow {
+  const event = parseText(row.event);
+
+  if (event === null) throw new SdkError("internal", "A logged event is malformed.");
+
+  return { seq: parseNumber(row.seq), event };
+}
+
+export async function collect(bytes: AsyncIterable<Uint8Array>): Promise<Uint8Array> {
+  const chunks: Uint8Array[] = [];
+
+  for await (const chunk of bytes) chunks.push(chunk);
+  const joined = new Uint8Array(chunks.reduce((size, chunk) => size + chunk.byteLength, 0));
+  let offset = 0;
+
+  for (const chunk of chunks) {
+    joined.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  return joined;
+}
+
+export function memoryReader(bytes: Uint8Array): ByteReader {
+  return {
+    size: bytes.byteLength,
+    mime: null,
+    async *chunks() {
+      yield bytes;
+    },
+    close: async () => undefined,
+    [Symbol.asyncDispose]: async () => undefined,
+  };
+}

package/src/store-usage.ts

@@ -0,0 +1,344 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import {
+  decodeObject,
+  decodeSessionRecord,
+  decodeWorkspaceRecord,
+  parseSessionRef,
+} from "@nyte-ai/core/store";
+import type { ModelRef, SessionId, Usage } from "@nyte-ai/schema";
+import type {
+  UsageEntry,
+  UsageReport,
+  UsageSession,
+  UsageSource,
+  UsageSubject,
+  UsageTotals,
+  UsageWindow,
+} from "./usage-types.ts";
+import { cacheSavings, usageTokens } from "./usage-summary.ts";
+import { decodeEvent, parseNumber, parseText } from "./store-rows.ts";
+
+export interface UsageRecord {
+  readonly at: number;
+  readonly subject: UsageSubject;
+  readonly usage: Usage;
+}
+
+export interface SessionUsage {
+  readonly sessionId: SessionId;
+  readonly name: string | undefined;
+  readonly records: readonly UsageRecord[];
+  readonly lastActivityAt?: number;
+}
+
+export interface StoreRead {
+  readonly workspacePath: string | null;
+  readonly sessions: readonly SessionUsage[];
+  readonly failure: { readonly message: string } | null;
+}
+
+const EMPTY_TOTALS: UsageTotals = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  reasoning: 0,
+  tokens: 0,
+  cost: 0,
+  cacheSavings: 0,
+};
+
+function add(totals: UsageTotals, usage: Usage): UsageTotals {
+  return {
+    input: totals.input + usage.input,
+    output: totals.output + usage.output,
+    cacheRead: totals.cacheRead + usage.cacheRead,
+    cacheWrite: totals.cacheWrite + usage.cacheWrite,
+    reasoning: totals.reasoning + (usage.reasoning ?? 0),
+    tokens: totals.tokens + usageTokens(usage),
+    cost: totals.cost + usage.cost.total,
+    cacheSavings: totals.cacheSavings + cacheSavings(usage),
+  };
+}
+
+export const USAGE_EVENTS =
+  "SELECT session, seq, at, event FROM log WHERE json_extract(event, '$.kind') = 'request' OR (json_extract(event, '$.kind') = 'run' AND json_extract(event, '$.change') = 'started') ORDER BY session, seq";
+
+export function localDay(at: number): string {
+  const date = new Date(at);
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+
+  return `${String(date.getFullYear())}-${month}-${day}`;
+}
+
+export function shiftDay(day: string, delta: number): string {
+  const date = new Date(`${day}T00:00:00`);
+  date.setDate(date.getDate() + delta);
+
+  return localDay(date.getTime());
+}
+
+function priorWindow(
+  sinceDay: string | null,
+  untilDay: string,
+): { readonly sinceDay: string; readonly untilDay: string } | undefined {
+  if (sinceDay === null) return undefined;
+  const priorUntil = shiftDay(sinceDay, -1);
+
+  const span =
+    (Date.parse(`${untilDay}T00:00:00Z`) - Date.parse(`${sinceDay}T00:00:00Z`)) / 86_400_000 + 1;
+
+  return { sinceDay: shiftDay(priorUntil, -(span - 1)), untilDay: priorUntil };
+}
+
+export function projectUsageReport(
+  stores: readonly StoreRead[],
+  window: UsageWindow,
+  readAt: number,
+): UsageReport {
+  const requestedSince = window.sinceDay;
+  const untilDay = window.untilDay;
+  const prior = priorWindow(requestedSince, untilDay);
+
+  const cells = new Map<
+    string,
+    { readonly entry: Omit<UsageEntry, "totals">; totals: UsageTotals }
+  >();
+
+  const sessions = new Map<SessionId, UsageSession>();
+  const sources: UsageSource[] = [];
+  let priorCost = 0;
+  let priorTokens = 0;
+  let sawPrior = false;
+  let earliestDay: string | undefined;
+
+  for (const store of stores) {
+    sources.push({
+      workspacePath: store.workspacePath,
+      status: store.failure === null ? "ok" : "failed",
+      sessions: store.sessions.length,
+      message: store.failure?.message ?? null,
+    });
+
+    for (const session of store.sessions) {
+      let lastActivityAt = 0;
+      let spentInWindow = false;
+
+      for (const spend of session.records) {
+        const { usage } = spend;
+        const amounts = [
+          usage.total,
+          usage.input,
+          usage.output,
+          usage.cacheRead,
+          usage.cacheWrite,
+          usage.cost.total,
+        ];
+
+        if (!amounts.some((amount) => amount > 0)) continue;
+        const day = localDay(spend.at);
+
+        if (earliestDay === undefined || day < earliestDay) earliestDay = day;
+
+        if (prior !== undefined && day >= prior.sinceDay && day <= prior.untilDay) {
+          sawPrior = true;
+          priorCost += spend.usage.cost.total;
+          priorTokens += usageTokens(spend.usage);
+        }
+
+        if (day > untilDay) continue;
+
+        if (requestedSince !== null && day < requestedSince) continue;
+
+        const key = JSON.stringify([day, store.workspacePath, session.sessionId, spend.subject]);
+        const cell = cells.get(key);
+
+        if (cell === undefined) {
+          cells.set(key, {
+            entry: {
+              day,
+              workspacePath: store.workspacePath,
+              sessionId: session.sessionId,
+              subject: spend.subject,
+            },
+            totals: add(EMPTY_TOTALS, spend.usage),
+          });
+        } else {
+          cell.totals = add(cell.totals, spend.usage);
+        }
+
+        spentInWindow = true;
+        lastActivityAt = Math.max(lastActivityAt, spend.at);
+      }
+
+      if (spentInWindow) {
+        sessions.set(session.sessionId, {
+          sessionId: session.sessionId,
+          name: session.name,
+          workspacePath: store.workspacePath,
+          lastActivityAt: session.lastActivityAt ?? lastActivityAt,
+        });
+      }
+    }
+  }
+
+  return {
+    readAt,
+    sinceDay: requestedSince ?? earliestDay ?? untilDay,
+    untilDay,
+    entries: [...cells.values()]
+      .map((cell) => ({ ...cell.entry, totals: cell.totals }))
+      .toSorted((left, right) => left.day.localeCompare(right.day)),
+    sessions: [...sessions.values()],
+    sources,
+    previous: sawPrior ? { cost: priorCost, tokens: priorTokens } : undefined,
+    earliestDay,
+  };
+}
+
+export function readNyteUsage(home: string, window: UsageWindow): UsageReport {
+  const readAt = Date.now();
+  const path = join(home, ".nyte", "nyte.db");
+
+  if (!existsSync(path)) return projectUsageReport([], window, readAt);
+  let database: DatabaseSync | undefined;
+
+  try {
+    database = new DatabaseSync(path, { readOnly: true, timeout: 5_000 });
+    database.exec("BEGIN");
+    const workspaces = new Map<string, string | null>();
+
+    const sessions = new Map<
+      SessionId,
+      {
+        readonly workspacePath: string | null;
+        readonly name: string | undefined;
+        readonly lastActivityAt: number | undefined;
+        readonly records: UsageRecord[];
+      }
+    >();
+
+    const refs = database
+      .prepare(
+        "SELECT refs.name, objects.body FROM refs JOIN objects ON objects.id = refs.target WHERE refs.name LIKE 'workspaces/%' OR (refs.name LIKE 'sessions/%' AND instr(substr(refs.name, 10), '/') = 0)",
+      )
+      .all();
+
+    for (const row of refs) {
+      const name = parseText(row.name);
+      const body = parseText(row.body);
+
+      if (name === null || body === null || !name.startsWith("workspaces/")) continue;
+      const workspace = decodeWorkspaceRecord(decodeObject(body));
+
+      if (workspace !== null)
+        workspaces.set(
+          workspace.id,
+          workspace.target.kind === "local" && "path" in workspace.target
+            ? parseText(workspace.target.path)
+            : null,
+        );
+    }
+
+    for (const row of refs) {
+      const name = parseText(row.name);
+      const body = parseText(row.body);
+
+      if (name === null || body === null || name.split("/").length !== 2) continue;
+      const id = parseSessionRef(name);
+
+      if (id === null) continue;
+      const session = decodeSessionRecord(decodeObject(body));
+
+      if (session === null) throw new Error(`Cannot read session ${id}.`);
+      sessions.set(id, {
+        workspacePath: workspaces.get(session.workspace) ?? null,
+        name: session.name ?? undefined,
+        lastActivityAt: session.lastActivityAt,
+        records: [],
+      });
+    }
+
+    const models = new Map<SessionId, Map<string | null, ModelRef>>();
+
+    for (const row of database.prepare(USAGE_EVENTS).iterate()) {
+      const session = parseSessionRef(`sessions/${parseText(row.session) ?? ""}`);
+
+      if (session === null) throw new Error("Cannot read usage session.");
+      const event = decodeEvent(
+        parseNumber(row.seq),
+        parseNumber(row.at),
+        parseText(row.event) ?? "",
+      );
+      let heads = models.get(session);
+
+      if (heads === undefined) {
+        heads = new Map();
+        models.set(session, heads);
+      }
+
+      if (event.kind === "run" && event.change === "started")
+        heads.set(event.head, event.view.configuration.model);
+
+      if (event.kind !== "request") continue;
+      const model = heads.get(event.head);
+
+      const subject: UsageSubject =
+        event.step === "compaction" || event.step === "summary"
+          ? { kind: "compaction" }
+          : event.step === "plugin"
+            ? { kind: "tool" }
+            : {
+                kind: "model",
+                provider: model?.provider ?? "unknown",
+                model: model?.id ?? "unknown",
+              };
+
+      let info = sessions.get(session);
+
+      if (info === undefined) {
+        info = { workspacePath: null, name: undefined, lastActivityAt: undefined, records: [] };
+        sessions.set(session, info);
+      }
+
+      info.records.push({ at: event.at, subject, usage: event.usage });
+    }
+
+    database.exec("COMMIT");
+    const stores = new Map<string | null, SessionUsage[]>();
+
+    for (const [sessionId, info] of sessions) {
+      const group = stores.get(info.workspacePath) ?? [];
+      group.push({
+        sessionId,
+        name: info.name,
+        records: info.records,
+        lastActivityAt: info.lastActivityAt,
+      });
+      stores.set(info.workspacePath, group);
+    }
+
+    return projectUsageReport(
+      [...stores].map(([workspacePath, sessions]) => ({ workspacePath, sessions, failure: null })),
+      window,
+      readAt,
+    );
+  } catch (cause) {
+    return projectUsageReport(
+      [
+        {
+          workspacePath: null,
+          sessions: [],
+          failure: { message: cause instanceof Error ? cause.message : String(cause) },
+        },
+      ],
+      window,
+      readAt,
+    );
+  } finally {
+    database?.close();
+  }
+}

package/src/usage-scan.ts

@@ -0,0 +1,81 @@
+import { Worker } from "node:worker_threads";
+import type { UsageScan, UsageScanReader, UsageScanRequest } from "./usage-service.ts";
+
+export interface UsageWorkerRequest extends UsageScanRequest {
+  readonly id: number;
+  readonly home: string;
+}
+
+export type UsageWorkerReply =
+  | { readonly id: number; readonly scan: UsageScan }
+  | { readonly id: number; readonly error: string };
+
+export class UsageScanWorker implements UsageScanReader {
+  private readonly home: string;
+  private readonly entry: string | URL;
+  private worker: Worker | undefined;
+  private nextId = 1;
+  private readonly pending = new Map<
+    number,
+    { resolve: (scan: UsageScan) => void; reject: (cause: unknown) => void }
+  >();
+
+  constructor(home: string, entry: string | URL) {
+    this.home = home;
+    this.entry = entry;
+  }
+
+  async scan(request: UsageScanRequest): Promise<UsageScan> {
+    const worker = this.spawn();
+    const id = this.nextId++;
+
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+
+      try {
+        worker.postMessage({ id, home: this.home, ...request } satisfies UsageWorkerRequest);
+      } catch (cause) {
+        this.pending.delete(id);
+        reject(cause);
+      }
+    });
+  }
+
+  async close(): Promise<void> {
+    const worker = this.worker;
+
+    if (worker === undefined) return;
+
+    this.fail(worker, new Error("Usage worker closed."));
+    await worker.terminate();
+  }
+
+  private spawn(): Worker {
+    if (this.worker !== undefined) return this.worker;
+    const worker = new Worker(this.entry);
+    worker.unref();
+    worker.on("message", (reply: UsageWorkerReply) => {
+      const request = this.pending.get(reply.id);
+      this.pending.delete(reply.id);
+
+      if ("scan" in reply) request?.resolve(reply.scan);
+      else request?.reject(new Error(reply.error));
+    });
+
+    worker.on("error", (cause) => this.fail(worker, cause));
+    worker.on("exit", (code) => {
+      this.fail(worker, new Error(`Usage worker exited with code ${String(code)}.`));
+    });
+    this.worker = worker;
+
+    return worker;
+  }
+
+  private fail(worker: Worker, cause: unknown): void {
+    if (this.worker !== worker) return;
+    this.worker = undefined;
+
+    for (const request of this.pending.values()) request.reject(cause);
+    this.pending.clear();
+  }
+}

package/src/usage-service.ts

@@ -0,0 +1,73 @@
+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 { createUsageScanCaches, readLocalUsage } 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 caches = createUsageScanCaches();
+  private readonly models: ReturnType<typeof createModels>;
+  private readonly scans = serial();
+
+  constructor(home: string) {
+    this.home = home;
+    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 local = await readLocalUsage({ models, caches: this.caches });
+      const report = readNyteUsage(this.home, request.window);
+
+      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;
+}