@saadnvd1/agent-os 0.3.471 → 0.3.472

package/lib/usage/cost.ts

@@ -0,0 +1,71 @@
+/**
+ * What a turn would cost at a provider's list prices (the price table in
+ * Settings > Models). For Anthropic that's the API's price, not what the
+ * plan charges: the plan's own measure is its share of the 5-hour window.
+ */
+
+import { ANTHROPIC_ALIASES, type ModelPrice } from "../models/providers";
+import { ANTHROPIC } from "../models/roles";
+
+export interface PricedRow {
+  provider: string | null;
+  model: string | null;
+  cost_usd: number;
+  input_tokens: number;
+  output_tokens: number;
+  cache_read_tokens: number;
+  cache_write_tokens: number;
+}
+
+export const UNRECORDED = "unrecorded";
+
+// The row's provider and model as the table names them: turns from before
+// routing have neither, and ran on Anthropic.
+export function rowModel(r: Pick<PricedRow, "provider" | "model">): {
+  provider: string;
+  model: string;
+} {
+  const provider = r.provider ?? ANTHROPIC;
+  const raw = r.model ?? UNRECORDED;
+  const model = provider === ANTHROPIC ? (ANTHROPIC_ALIASES[raw] ?? raw) : raw;
+  return { provider, model };
+}
+
+// Dollars, and whether it came from the table (false: the agent's own
+// figure, for a model the table doesn't price).
+export function estimateCost(
+  r: PricedRow,
+  prices: Record<string, ModelPrice>
+): { usd: number; priced: boolean } {
+  const { provider, model } = rowModel(r);
+  const p = prices[`${provider}/${model}`];
+  if (!p) return { usd: r.cost_usd, priced: false };
+  const usd =
+    (r.input_tokens * p.input +
+      r.cache_write_tokens * p.cacheWrite +
+      r.cache_read_tokens * p.cacheRead +
+      r.output_tokens * p.output) /
+    1_000_000;
+  return { usd, priced: true };
+}
+
+// Each Anthropic turn's share of the plan's 5-hour window, in points: how
+// far the window moved since the turn before it (any session's) ended.
+// Turns overlap, so one turn's share is rough; summed over many it isn't.
+// A drop means the window reset, and all of the new reading is this turn's;
+// the first reading has nothing to measure from.
+export function planShares(
+  rows: { at: number; provider: string | null; window_pct: number | null }[]
+): number[] {
+  const order = rows.map((r, i) => ({ r, i })).sort((a, b) => a.r.at - b.r.at);
+  const out = new Array<number>(rows.length).fill(0);
+  let prev: number | null = null;
+  for (const { r, i } of order) {
+    if ((r.provider ?? ANTHROPIC) !== ANTHROPIC || r.window_pct == null)
+      continue;
+    const pct = r.window_pct;
+    out[i] = prev === null ? 0 : pct < prev ? pct : pct - prev;
+    prev = pct;
+  }
+  return out;
+}

package/lib/usage/report.ts

@@ -1,4 +1,7 @@
 import { db } from "../db";
+import { effectiveModels } from "../models/config";
+import { LEDGER_SQL } from "./compare";
+import { spendByModel, type ModelTurnRow, type SpendByModel } from "./by-model";
 import { listWorkspaces } from "../workspaces";
 import {
   aggregateUsage,
@@ -43,3 +46,26 @@ export function checkRunReport(range: UsageRange, now = Date.now()) {
   const names = Object.fromEntries(listWorkspaces().map((w) => [w.id, w.name]));
   return aggregateUsage(named, range, names, now);
 }
+
+const HOUR = 3600 * 1000;
+
+// Spend by model and role in the plan's current 5-hour window (its start
+// from when it resets, or the last five hours) and the last 24 hours.
+export function modelUsage(
+  fiveHourResetsIn: number | null | undefined,
+  now = Date.now()
+): { fiveHour: SpendByModel; day: SpendByModel } {
+  const day = now - 24 * HOUR;
+  const fiveHour =
+    fiveHourResetsIn != null
+      ? now + fiveHourResetsIn * 1000 - 5 * HOUR
+      : now - 5 * HOUR;
+  const rows = db
+    .prepare(LEDGER_SQL)
+    .all({ from: Math.min(day, fiveHour), to: now }) as ModelTurnRow[];
+  const { prices } = effectiveModels();
+  return {
+    fiveHour: spendByModel(rows, fiveHour, prices),
+    day: spendByModel(rows, day, prices),
+  };
+}

package/lib/usage/turns.ts

@@ -7,6 +7,8 @@
 import { db, type Session } from "../db";
 import type { UsageTotals } from "../chat/events";
 import { totalTokens, turnDelta } from "../chat/context";
+import { readUsage } from "../orchestrator/usage";
+import { ANTHROPIC, sessionRole } from "../models/roles";
 
 // Where a worker's totals start: a resumed conversation continues from the
 // totals its transcript saved, which the last worker stored; a new one
@@ -30,12 +32,22 @@ function savedTotals(sessionId: string): UsageTotals | null {
   }
 }
 
-// Records the turn and returns the totals to measure the next one from.
+// The plan's 5-hour window when a turn on it ended, for its share of the
+// plan (lib/usage/compare): unknown when the statusline isn't sampling.
+export function planWindowPct(): number | null {
+  const u = readUsage();
+  return "window" in u && u.window ? u.window.pct : null;
+}
+
+// Records the turn, with the model, provider and role it ran as, and
+// returns the totals to measure the next one from.
 export function recordTurn(
   session: Pick<Session, "id" | "name" | "workspace_id">,
   prev: UsageTotals | null,
   totals: UsageTotals,
-  at = Date.now()
+  at = Date.now(),
+  durationMs: number | null = null,
+  windowPct: () => number | null = planWindowPct
 ): UsageTotals {
   const turn = turnDelta(prev, totals);
   db.transaction(() => {
@@ -46,25 +58,35 @@ export function recordTurn(
     // A local command (/context, /mcp) spends nothing.
     if (turn.costUsd <= 0 && totalTokens(turn) <= 0) return;
     const current = db
-      .prepare(`SELECT name, workspace_id FROM sessions WHERE id = ?`)
+      .prepare(
+        `SELECT name, workspace_id, model, model_provider, role, task_status,
+           plan_phase FROM sessions WHERE id = ?`
+      )
       .get(session.id) as
-      | { name: string; workspace_id: string | null }
+      | Pick<
+          Session,
+          | "name"
+          | "workspace_id"
+          | "model"
+          | "model_provider"
+          | "role"
+          | "task_status"
+          | "plan_phase"
+        >
       | undefined;
-    db.prepare(
-      `INSERT INTO chat_turns (session_id, session_name, workspace_id, at, cost_usd,
-         input_tokens, output_tokens, cache_read_tokens, cache_write_tokens)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      session.id,
-      current?.name ?? session.name,
-      current?.workspace_id ?? session.workspace_id,
+    const provider = current?.model_provider ?? ANTHROPIC;
+    insertTurn({
+      sessionId: session.id,
+      sessionName: current?.name ?? session.name,
+      workspaceId: current?.workspace_id ?? session.workspace_id,
       at,
-      turn.costUsd,
-      turn.inputTokens,
-      turn.outputTokens,
-      turn.cacheReadTokens,
-      turn.cacheWriteTokens
-    );
+      turn,
+      model: current?.model ?? null,
+      provider,
+      role: current ? sessionRole(current) : null,
+      durationMs,
+      windowPct: provider === ANTHROPIC ? windowPct() : null,
+    });
   })();
   return totals;
 }
@@ -96,3 +118,42 @@ export function recordCompaction(
     c.after ?? null
   );
 }
+
+export interface TurnRecord {
+  sessionId: string;
+  sessionName: string;
+  workspaceId: string | null;
+  at: number;
+  turn: UsageTotals;
+  model: string | null;
+  provider: string;
+  role: string | null;
+  durationMs: number | null;
+  windowPct: number | null;
+}
+
+// One row of the usage ledger: a chat turn, or a one-shot check's run.
+export function insertTurn(r: TurnRecord): void {
+  const { turn } = r;
+  db.prepare(
+    `INSERT INTO chat_turns (session_id, session_name, workspace_id, at, cost_usd,
+       input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
+       model, provider, role, duration_ms, window_pct)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    r.sessionId,
+    r.sessionName,
+    r.workspaceId,
+    r.at,
+    turn.costUsd,
+    turn.inputTokens,
+    turn.outputTokens,
+    turn.cacheReadTokens,
+    turn.cacheWriteTokens,
+    r.model,
+    r.provider,
+    r.role,
+    r.durationMs,
+    r.windowPct
+  );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.471",
+  "version": "0.3.472",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/stores/usageUi.ts

@@ -1,12 +1,21 @@
 import { proxy } from "valtio";
 
-export const usageUi = proxy({ open: false });
+export type UsageTab = "spend" | "models" | "compare";
+
+export const usageUi = proxy<{ open: boolean; tab: UsageTab }>({
+  open: false,
+  tab: "spend",
+});
 
 export const usageUiActions = {
-  open: () => {
+  open: (tab: UsageTab = "spend") => {
+    usageUi.tab = tab;
     usageUi.open = true;
   },
   setOpen: (open: boolean) => {
     usageUi.open = open;
   },
+  setTab: (tab: UsageTab) => {
+    usageUi.tab = tab;
+  },
 };