@linkshell/wire 0.2.29 → 0.2.31

package/src/lsa.ts

@@ -0,0 +1,159 @@
+import { z } from "zod";
+
+/**
+ * LinkShell Agent (LSA) Phase 1 RPC contracts: deterministic task ledger,
+ * automated post-turn acceptance verification, memories, and due followups.
+ */
+
+export const lsaTaskStatusSchema = z.enum([
+  "queued",
+  "running",
+  "verifying",
+  "waiting_decision",
+  "completed",
+  "failed",
+  "cancelled",
+]);
+export type LsaTaskStatus = z.infer<typeof lsaTaskStatusSchema>;
+
+export const lsaDecisionSchema = z.enum(["accept", "retry", "cancel"]);
+export type LsaDecision = z.infer<typeof lsaDecisionSchema>;
+
+export const lsaTaskSchema = z.object({
+  id: z.string().min(1),
+  title: z.string().optional(),
+  goal: z.string().min(1),
+  status: lsaTaskStatusSchema,
+  cwd: z.string(),
+  worktree: z.boolean().optional(),
+  agent: z.string().optional(),
+  sessionId: z.string().optional(),
+  controllerEpoch: z.number().int().nonnegative().optional(),
+  acceptanceChecks: z.array(z.string()),
+  summary: z.string().optional(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+export type LsaTask = z.infer<typeof lsaTaskSchema>;
+
+export const lsaMemorySchema = z.object({
+  id: z.string().optional(),
+  scope: z.string().optional(),
+  key: z.string().min(1),
+  content: z.string(),
+  tags: z.array(z.string()),
+  updatedAt: z.number(),
+});
+export type LsaMemory = z.infer<typeof lsaMemorySchema>;
+
+export const lsaFollowupSchema = z.object({
+  id: z.string().min(1),
+  taskId: z.string().optional(),
+  dueAt: z.number(),
+  note: z.string(),
+  done: z.boolean(),
+  triggeredAt: z.number().optional(),
+});
+export type LsaFollowup = z.infer<typeof lsaFollowupSchema>;
+
+export const lsaCandidateProjectSchema = z.object({
+  cwd: z.string(),
+  name: z.string(),
+  score: z.number(),
+  remote: z.string().optional(),
+  reason: z.string().optional(),
+});
+export type LsaCandidateProject = z.infer<typeof lsaCandidateProjectSchema>;
+
+export const lsaStatusSchema = z.object({
+  enabled: z.boolean(),
+  controllerEpoch: z.number().int().nonnegative(),
+  generation: z.number().int().positive(),
+  activeTasks: z.number().int().nonnegative(),
+  waitingDecisionTasks: z.number().int().nonnegative(),
+  dueFollowups: z.number().int().nonnegative(),
+  requiresYearlyTier: z.boolean(),
+  handoffSummary: z.string().optional(),
+  candidates: z.array(lsaCandidateProjectSchema).optional(),
+});
+export type LsaStatus = z.infer<typeof lsaStatusSchema>;
+
+export const lsaMethods = {
+  "lsa.status": {
+    params: z.object({
+      query: z.string().max(200).optional(),
+    }),
+    result: lsaStatusSchema,
+  },
+  "lsa.tasks": {
+    params: z.object({
+      taskId: z.string().optional(),
+      status: lsaTaskStatusSchema.optional(),
+      limit: z.number().int().positive().max(200).optional(),
+    }),
+    result: z.object({
+      tasks: z.array(lsaTaskSchema),
+    }),
+  },
+  "lsa.dispatch": {
+    params: z.object({
+      goal: z.string().min(1).max(20_000),
+      title: z.string().max(200).optional(),
+      cwd: z.string().optional(),
+      agent: z.string().optional(),
+      worktree: z.boolean().optional(),
+      acceptanceChecks: z.array(z.string().max(2000)).max(50).optional(),
+    }),
+    result: z.object({
+      task: lsaTaskSchema,
+    }),
+  },
+  "lsa.steer": {
+    params: z.object({
+      taskId: z.string().min(1),
+      instruction: z.string().min(1).max(20_000),
+      controllerEpoch: z.number().int().nonnegative().optional(),
+    }),
+    result: z.object({
+      task: lsaTaskSchema,
+    }),
+  },
+  "lsa.decide": {
+    params: z.object({
+      taskId: z.string().min(1),
+      decision: lsaDecisionSchema,
+      feedback: z.string().max(20_000).optional(),
+      controllerEpoch: z.number().int().nonnegative().optional(),
+    }),
+    result: z.object({
+      task: lsaTaskSchema,
+    }),
+  },
+  "lsa.memories": {
+    params: z.object({
+      op: z.enum(["list", "search", "save", "delete"]).optional(),
+      query: z.string().max(500).optional(),
+      scope: z.string().max(120).optional(),
+      key: z.string().max(200).optional(),
+      content: z.string().max(20_000).optional(),
+      tags: z.array(z.string().max(80)).max(32).optional(),
+      limit: z.number().int().positive().max(200).optional(),
+    }),
+    result: z.object({
+      memories: z.array(lsaMemorySchema),
+    }),
+  },
+  "lsa.followups": {
+    params: z.object({
+      op: z.enum(["list", "schedule", "complete", "delete"]).optional(),
+      id: z.string().optional(),
+      taskId: z.string().optional(),
+      dueAt: z.number().optional(),
+      note: z.string().max(2000).optional(),
+      includeDone: z.boolean().optional(),
+    }),
+    result: z.object({
+      followups: z.array(lsaFollowupSchema),
+    }),
+  },
+} as const;

package/src/model.ts

@@ -302,6 +302,10 @@ export const gitInfoSchema = z.object({
   head: z.string().optional(),
   /** Uncommitted changes in the working directory (a new worktree starts from the last commit, without them). */
   dirty: z.boolean(),
+  /** Normalized git origin remote (`host/owner/repo`), when configured. */
+  remote: z.string().optional(),
+  /** First commit hash of the repository, for cross-machine repo identity. */
+  rootCommit: z.string().optional(),
 });
 export type GitInfo = z.infer<typeof gitInfoSchema>;
 
@@ -356,6 +360,23 @@ export const machineInfoSchema = z.object({
 });
 export type MachineInfo = z.infer<typeof machineInfoSchema>;
 
+export const keepAwakeModeSchema = z.enum(["smart", "always", "off"]);
+export type KeepAwakeMode = z.infer<typeof keepAwakeModeSchema>;
+
+export const machinePowerSchema = z.object({
+  onBattery: z.boolean(),
+  percent: z.number().min(0).max(100).nullable(),
+  charging: z.boolean().optional(),
+});
+export type MachinePower = z.infer<typeof machinePowerSchema>;
+
+export const machineKeepAwakeSchema = z.object({
+  mode: keepAwakeModeSchema,
+  active: z.boolean(),
+  reason: z.string().optional(),
+});
+export type MachineKeepAwake = z.infer<typeof machineKeepAwakeSchema>;
+
 /** Whole-computer resource use; CPU is a delta across all logical cores, not load average. */
 export const machineMetricsSchema = z.object({
   sampledAt: z.number().nonnegative(),
@@ -382,6 +403,10 @@ export const machineMetricsSchema = z.object({
     /** Space available to this user; excludes filesystem reservations. */
     availableBytes: z.number().nonnegative(),
   }).optional(),
+  /** Battery and AC power state on laptops; absent on desktops or older hosts. */
+  power: machinePowerSchema.optional(),
+  /** Host idle-sleep assertion state; absent on older hosts. */
+  keepAwake: machineKeepAwakeSchema.optional(),
 });
 export type MachineMetrics = z.infer<typeof machineMetricsSchema>;
 

package/src/relay.ts

@@ -123,7 +123,7 @@ export interface RelayMethods {
   "machines.forget": { params: { machineId: string }; result: Record<string, never> };
   "devices.list": { params: Record<string, never>; result: { devices: DeviceEntry[] } };
   "devices.revoke": { params: { deviceId: string }; result: Record<string, never> };
-  /** Device: take this device off its account (signing out); paired computers stay. */
+  /** Take this peer off its account (signing out); explicit pairings stay. */
   "account.leave": { params: Record<string, never>; result: Record<string, never> };
 }
 export type RelayMethod = keyof RelayMethods;

package/src/rpc.ts

@@ -3,12 +3,14 @@ import { usageQuerySchema, usageReportSchema } from "./usage.js";
 import { goalChangeSchema, sessionGoalSchema } from "./goal.js";
 import { acpAgentSettingsSchema, acpFeaturesSchema, acpRemoteAgentSchema, acpProviderSchema } from "./acp.js";
 import { editorRequestSchema, editorResultSchema } from "./editor.js";
-import { liveActivityIdSchema, liveActivitySubscriptionSchema } from "./live-activity.js";
+import { liveActivityIdSchema, liveActivityPushToStartSchema, liveActivitySubscriptionSchema, wakeupNoticeSchema } from "./live-activity.js";
 import {
   backgroundTaskSchema,
   agentInfoSchema,
   gatewayStatusSchema,
+  keepAwakeModeSchema,
   machineInfoSchema,
+  machineKeepAwakeSchema,
   machineMetricsSnapshotSchema,
   portInfoSchema,
   projectSummarySchema,
@@ -24,6 +26,7 @@ import {
 import { contentBlockSchema, sessionConfigOptionSchema, sessionEventSchema, sessionNoticeSchema } from "./updates.js";
 import { sideChatSchema } from "./side.js";
 import { mcpMethods } from "./rpc-mcp.js";
+import { lsaMethods } from "./lsa.js";
 
 // ── JSON-RPC 2.0 framing ─────────────────────────────────────────────
 
@@ -77,11 +80,51 @@ export const RPC_APP_ERROR = -32000;
  * 1: side conversations (`sessions.side`), `machine.info.protocol` itself.
  * 2: session terminals (`terminals.create` `sessionId`, `TerminalInfo.sessionId`).
  * 3: whole-computer CPU and physical memory sampling (`machine.metrics`).
+ * 4: smart keep-awake & battery telemetry (`machine.keepAwake`), real git working-tree
+ *    diff/revert (`git.diff`, `git.revertFile`), fast `@file` search (`fs.projectFiles`),
+ *    clipboard & screen privacy (`clipboard.*`, `screen.privacy`), push-to-start wakeup
+ *    (`liveActivities.registerPushToStart`), and LSA Phase 1 steward RPCs (`lsa.*`).
  */
-export const HOST_PROTOCOL = 3;
+export const HOST_PROTOCOL = 4;
 
 const empty = z.looseObject({});
 
+export const gitDiffFileStatusSchema = z.enum(["modified", "added", "deleted", "renamed", "untracked"]);
+export type GitDiffFileStatus = z.infer<typeof gitDiffFileStatusSchema>;
+
+export const gitDiffFileSchema = z.object({
+  path: z.string(),
+  oldPath: z.string().optional(),
+  status: gitDiffFileStatusSchema,
+  oldText: z.string(),
+  newText: z.string(),
+  additions: z.number().int().nonnegative(),
+  deletions: z.number().int().nonnegative(),
+  binary: z.boolean().optional(),
+});
+export type GitDiffFile = z.infer<typeof gitDiffFileSchema>;
+
+export const gitDiffResultSchema = z.object({
+  files: z.array(gitDiffFileSchema),
+  truncated: z.boolean(),
+  branch: z.string().optional(),
+});
+export type GitDiffResult = z.infer<typeof gitDiffResultSchema>;
+
+export const projectFileEntrySchema = z.object({
+  path: z.string(),
+  relativePath: z.string(),
+  isDir: z.boolean().optional(),
+});
+export type ProjectFileEntry = z.infer<typeof projectFileEntrySchema>;
+
+export const screenPrivacyStateSchema = z.object({
+  curtain: z.boolean(),
+  lockOnDisconnect: z.boolean(),
+  supported: z.boolean(),
+});
+export type ScreenPrivacyState = z.infer<typeof screenPrivacyStateSchema>;
+
 export const directoryEntrySchema = z.object({
   name: z.string(),
   path: z.string(),
@@ -133,11 +176,19 @@ const coreMethods = {
     params: z.object({ activityId: liveActivityIdSchema }),
     result: z.object({}),
   },
+  "liveActivities.registerPushToStart": {
+    params: liveActivityPushToStartSchema,
+    result: z.looseObject({ ok: z.boolean().optional() }),
+  },
   "machine.info": {
     params: empty,
     result: machineInfoSchema,
   },
   "machine.metrics": { params: empty, result: machineMetricsSnapshotSchema },
+  "machine.keepAwake": {
+    params: z.object({ mode: keepAwakeModeSchema.optional() }),
+    result: machineKeepAwakeSchema,
+  },
   "machine.rename": {
     /** Empty restores the configured default; names never change peer identities. */
     params: z.object({ name: z.string().trim().max(40) }),
@@ -480,6 +531,8 @@ const coreMethods = {
    * host connects, moves or disconnects without a restart.
    */
   "gateway.refresh": { params: empty, result: gatewayStatusSchema },
+  /** Explicitly end this computer's gateway account binding (local only). */
+  "gateway.account.leave": { params: empty, result: empty },
   /**
    * Opens a pairing window (local only). `link` is what the QR encodes; the
    * code can be typed instead. `pairing.done` follows when a device pairs.
@@ -506,9 +559,24 @@ const coreMethods = {
     params: z.object({ password: z.string().min(4).max(128).optional() }),
     result: z.object({ password: z.boolean() }),
   },
-  // ── Git: sessions in worktrees ──
+  // ── Git: sessions in worktrees & working-tree diffs ──
   /** What git says about `path`; no `git` when it isn't in a repository. */
   "git.info": { params: z.object({ path: z.string().min(1) }), result: z.object({ git: gitInfoSchema.optional() }) },
+  /** Real git working-tree diff (or against `base`), bounded by `maxBytes` and including untracked text files by default. */
+  "git.diff": {
+    params: z.object({
+      cwd: z.string().min(1),
+      base: z.string().optional(),
+      includeUntracked: z.boolean().optional(),
+      maxBytes: z.number().int().positive().max(10_000_000).optional(),
+    }),
+    result: gitDiffResultSchema,
+  },
+  /** Restores a tracked file or removes an untracked file strictly inside the repository root. */
+  "git.revertFile": {
+    params: z.object({ cwd: z.string().min(1), path: z.string().min(1) }),
+    result: z.object({ ok: z.boolean() }),
+  },
   /** The worktrees LinkShell made, newest first. */
   "worktrees.list": { params: empty, result: z.object({ worktrees: z.array(worktreeEntrySchema) }) },
   /** Removes a worktree and its branch. Refused (`busy`) while a session uses it, or (`dirty`) when work in it would be lost, unless `force`. */
@@ -598,6 +666,27 @@ const coreMethods = {
     params: z.object({ query: z.string().min(1).max(200), limit: z.number().int().min(1).max(200).default(60) }),
     result: z.object({ entries: z.array(directoryEntrySchema), truncated: z.boolean() }),
   },
+  /** Fast project file listing under `cwd` (`git ls-files` with directory walk fallback) for `@file` autocomplete. */
+  "fs.projectFiles": {
+    params: z.object({
+      cwd: z.string().min(1),
+      query: z.string().max(200).optional(),
+      limit: z.number().int().min(1).max(2000).optional(),
+    }),
+    result: z.object({
+      files: z.array(projectFileEntrySchema),
+      truncated: z.boolean(),
+    }),
+  },
+  // ── Clipboard: encrypted host clipboard access ──
+  "clipboard.read": {
+    params: empty,
+    result: z.object({ text: z.string() }),
+  },
+  "clipboard.write": {
+    params: z.object({ text: z.string().max(2_000_000) }),
+    result: z.object({ ok: z.boolean() }),
+  },
   // ── Terminals: plain shells on the host, any command, like SSH ──
   "terminals.list": {
     params: empty,
@@ -731,6 +820,14 @@ const coreMethods = {
       problem: z.string().optional(),
     }),
   },
+  /** Privacy curtain (dim/blank physical screen while viewing remotely) and auto-lock on disconnect. */
+  "screen.privacy": {
+    params: z.object({
+      curtain: z.boolean().optional(),
+      lockOnDisconnect: z.boolean().optional(),
+    }),
+    result: screenPrivacyStateSchema,
+  },
   /** Bytes to the host's end of a stream (base64). */
   "proxy.write": {
     params: z.object({ streamId: z.string().min(1), data: z.string().max(2_000_000) }),
@@ -742,7 +839,12 @@ const coreMethods = {
   },
 } as const;
 
-export const methods: typeof coreMethods & typeof acpMethods & typeof mcpMethods = { ...coreMethods, ...acpMethods, ...mcpMethods };
+export const methods: typeof coreMethods & typeof acpMethods & typeof mcpMethods & typeof lsaMethods = {
+  ...coreMethods,
+  ...acpMethods,
+  ...mcpMethods,
+  ...lsaMethods,
+};
 
 export type MethodName = keyof typeof methods;
 export type MethodParams<M extends MethodName> = z.input<(typeof methods)[M]["params"]>;
@@ -787,6 +889,8 @@ export const notifications = {
   "proxy.data": z.object({ streamId: z.string(), data: z.string() }),
   /** The host's end of a stream closed (the server hung up, or refused). */
   "proxy.closed": z.object({ streamId: z.string(), error: z.string().optional() }),
+  /** Zero-plaintext transition wakeup metadata. */
+  "liveActivities.wakeup": wakeupNoticeSchema,
 } as const;
 
 export type NotificationName = keyof typeof notifications;

package/src/usage.ts

@@ -4,21 +4,133 @@ export const usageQuerySchema = z.object({
   days: z.union([z.literal(1), z.literal(7), z.literal(30)]).default(7),
   agent: z.string().min(1).max(128).default("all"),
 });
+
 export const usageTotalsSchema = z.object({
-  records: z.number(), sessions: z.number(), inputTokens: z.number(), outputTokens: z.number(),
-  cacheReadTokens: z.number(), cacheWriteTokens: z.number(), totalTokens: z.number(),
+  records: z.number(),
+  sessions: z.number(),
+  inputTokens: z.number(),
+  outputTokens: z.number(),
+  cacheReadTokens: z.number(),
+  cacheWriteTokens: z.number(),
+  totalTokens: z.number(),
+  estimatedCostUsd: z.number().nonnegative().optional(),
+});
+
+export const usageRemoteStatsSchema = z.object({
+  remoteTurns: z.number().int().nonnegative(),
+  remoteApprovals: z.number().int().nonnegative(),
 });
+
 export const usageReportSchema = z.object({
-  generatedAt: z.number(), days: z.number(), agent: z.string(), timezone: z.string(),
+  generatedAt: z.number(),
+  days: z.number(),
+  agent: z.string(),
+  timezone: z.string(),
   totals: usageTotalsSchema,
   daily: z.array(usageTotalsSchema.extend({ date: z.string() })),
   models: z.array(usageTotalsSchema.extend({ agent: z.string(), model: z.string() })),
   agents: z.array(z.object({
-    id: z.string(), label: z.string(), source: z.enum(["native", "acp"]),
-    status: z.enum(["available", "no_data"]), records: z.number(), totalTokens: z.number(), note: z.string(),
+    id: z.string(),
+    label: z.string(),
+    source: z.enum(["native", "acp"]),
+    status: z.enum(["available", "no_data"]),
+    records: z.number(),
+    totalTokens: z.number(),
+    note: z.string(),
+    estimatedCostUsd: z.number().nonnegative().optional(),
   })).optional(),
+  estimatedCostUsd: z.number().nonnegative().optional(),
+  remoteStats: usageRemoteStatsSchema.optional(),
   warnings: z.array(z.string()),
 });
+
 export type UsageQuery = z.infer<typeof usageQuerySchema>;
 export type UsageTotals = z.infer<typeof usageTotalsSchema>;
+export type UsageRemoteStats = z.infer<typeof usageRemoteStatsSchema>;
 export type UsageReport = z.infer<typeof usageReportSchema>;
+
+export interface ModelPricingPerMillion {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+}
+
+export interface TokenCostInput {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens?: number;
+  cacheWriteTokens?: number;
+}
+
+/**
+ * Reference public API pricing (USD per 1M tokens), ordered most-specific first.
+ * Subscription users (ChatGPT Plus/Pro, Claude Pro/Max) pay flat fees; this
+ * estimates the equivalent API value of work orchestrated through LinkShell.
+ */
+const MODEL_PRICING_RULES: ReadonlyArray<{ match: RegExp; pricing: ModelPricingPerMillion }> = [
+  // Anthropic Claude
+  { match: /claude[-_.]?opus[-_.]?(?:4[._][56]|5)/i, pricing: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 } },
+  { match: /opus/i, pricing: { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 } },
+  { match: /sonnet/i, pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 } },
+  { match: /claude[-_.]?haiku[-_.]?4[._]5/i, pricing: { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 } },
+  { match: /haiku/i, pricing: { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 } },
+  // OpenAI / Codex
+  { match: /(?:gpt-5|o1|o3)[-_]pro/i, pricing: { input: 15, output: 60, cacheRead: 3.75, cacheWrite: 15 } },
+  { match: /gpt-5[-_.]?mini/i, pricing: { input: 0.25, output: 2, cacheRead: 0.025, cacheWrite: 0.25 } },
+  { match: /gpt-5[-_.]?nano/i, pricing: { input: 0.05, output: 0.4, cacheRead: 0.005, cacheWrite: 0.05 } },
+  { match: /codex[-_.]?mini/i, pricing: { input: 1.5, output: 6, cacheRead: 0.375, cacheWrite: 1.5 } },
+  { match: /gpt-5|codex/i, pricing: { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 1.25 } },
+  { match: /gpt-4\.1[-_.]?mini/i, pricing: { input: 0.4, output: 1.6, cacheRead: 0.1, cacheWrite: 0.4 } },
+  { match: /gpt-4\.1[-_.]?nano/i, pricing: { input: 0.1, output: 0.4, cacheRead: 0.025, cacheWrite: 0.1 } },
+  { match: /gpt-4\.1/i, pricing: { input: 2, output: 8, cacheRead: 0.5, cacheWrite: 2 } },
+  { match: /gpt-4o[-_.]?mini/i, pricing: { input: 0.15, output: 0.6, cacheRead: 0.075, cacheWrite: 0.15 } },
+  { match: /gpt-4o/i, pricing: { input: 2.5, output: 10, cacheRead: 1.25, cacheWrite: 2.5 } },
+  { match: /o[34][-_.]?mini/i, pricing: { input: 1.1, output: 4.4, cacheRead: 0.275, cacheWrite: 1.1 } },
+  { match: /\bo3\b|\bo1\b/i, pricing: { input: 2, output: 8, cacheRead: 0.5, cacheWrite: 2 } },
+  // Google Gemini
+  { match: /gemini.*flash/i, pricing: { input: 0.3, output: 2.5, cacheRead: 0.075, cacheWrite: 0.3 } },
+  { match: /gemini/i, pricing: { input: 1.25, output: 10, cacheRead: 0.3125, cacheWrite: 1.25 } },
+  // xAI Grok & DeepSeek
+  { match: /grok/i, pricing: { input: 3, output: 15, cacheRead: 0.75, cacheWrite: 3 } },
+  { match: /deepseek/i, pricing: { input: 0.27, output: 1.1, cacheRead: 0.07, cacheWrite: 0.27 } },
+];
+
+const DEFAULT_PRICING_PER_MILLION: ModelPricingPerMillion = {
+  input: 2,
+  output: 8,
+  cacheRead: 0.2,
+  cacheWrite: 2,
+};
+
+export function modelPricingPerMillionUsd(model: string): ModelPricingPerMillion {
+  const normalized = model.trim();
+  for (const rule of MODEL_PRICING_RULES) {
+    if (rule.match.test(normalized)) return rule.pricing;
+  }
+  return DEFAULT_PRICING_PER_MILLION;
+}
+
+function safeTokenCount(value: number | undefined): number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+
+/**
+ * Pure reference cost estimator (in USD) for a model and non-overlapping token bucket totals.
+ */
+export function estimateModelCostUsd(model: string, totals: TokenCostInput): number {
+  const input = safeTokenCount(totals.inputTokens);
+  const output = safeTokenCount(totals.outputTokens);
+  const cacheRead = safeTokenCount(totals.cacheReadTokens);
+  const cacheWrite = safeTokenCount(totals.cacheWriteTokens);
+  if (input === 0 && output === 0 && cacheRead === 0 && cacheWrite === 0) return 0;
+
+  const rate = modelPricingPerMillionUsd(model);
+  const rawUsd =
+    (input * rate.input +
+      output * rate.output +
+      cacheRead * rate.cacheRead +
+      cacheWrite * rate.cacheWrite) /
+    1_000_000;
+  return Math.round(rawUsd * 1_000_000) / 1_000_000;
+}