pennyrouter 0.3.43 → 0.3.45

package/standalone/web-demo/claude-meter.mjs

@@ -1,22 +1,38 @@
 import { readFileSync } from 'node:fs';
 import { mkdir, open, readdir, stat, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { basename, join } from 'node:path';
 
-// Standard per-token rates from ../rates.json (scripts/generate_compare_rates.py), the same
-// file pricing.py reads. Each rate list is [input, cache read, cache write 5m, cache write 1h,
-// output]; a model may carry an `above` list that applies once one request's input context
-// exceeds its threshold.
-const { models } = JSON.parse(readFileSync(new URL('../rates.json', import.meta.url), 'utf8'));
+// Per-token rates from ../rates.json (scripts/generate_compare_rates.py) and the hand-maintained
+// ../govcloud-rates.json, the same files pricing.py reads. Each rate list is [input, cache read,
+// cache write 5m, cache write 1h, output]; a model may carry an `above` list that applies once
+// one request's input context exceeds its threshold.
+const schedule = (file) => JSON.parse(readFileSync(new URL(file, import.meta.url), 'utf8')).models;
+const schedules = { standard: schedule('../rates.json'), govcloud: schedule('../govcloud-rates.json') };
+export const pricingProfiles = Object.keys(schedules);
 
 function longestPrefix(name, table) {
+  if (table[name]) return name;
   const keys = Object.keys(table).filter((key) => name.startsWith(key));
   return keys.sort((a, b) => b.length - a.length)[0];
 }
 
-function rateFor(model, contextTokens = 0) {
-  const normalized = String(model || '').replace(/^.*\//, '').replace('[1m]', '').trim();
-  const entry = models[longestPrefix(normalized, models)] || models['claude-sonnet-5'];
+// Mirrors pricing._normalize: vendor prefixes (including Bedrock's `anthropic.`), the
+// long-context suffix, and the dotted Anthropic ids some routes record.
+function normalize(model) {
+  let name = String(model || '').replace(/^.*\//, '').trim();
+  if (name.startsWith('anthropic.')) name = name.slice('anthropic.'.length);
+  name = name.replace('[1m]', '').trim();
+  return { 'claude-opus-4.8': 'claude-opus-4-8', 'claude-haiku-4.5': 'claude-haiku-4-5' }[name] || name;
+}
+
+// A GovCloud schedule overrides only the models it lists; others keep their standard rate.
+export function rateFor(model, contextTokens = 0, profile = 'standard') {
+  const name = normalize(model);
+  const table = schedules[profile] || schedules.standard;
+  const key = longestPrefix(name, table);
+  if (!key && table !== schedules.standard) return rateFor(model, contextTokens, 'standard');
+  const entry = table[key] || schedules.standard['claude-sonnet-5'];
   return entry.above && contextTokens > entry.above.threshold ? entry.above.rates : entry.rates;
 }
 
@@ -41,19 +57,43 @@ async function readFirstLine(path, limit = 1024 * 1024) {
   } finally { await handle.close(); }
 }
 
+// Telemetry usually arrives before the transcript line for the same request; an event counts
+// as a background call only once its request id has stayed out of the transcript this long.
+const sideCallGraceMs = 5000;
+
+// A reply the gateway answered itself, with no model call, reports an estimate of the whole
+// context as fresh input so Claude Code's context gauge stays honest. Nothing was billed for
+// it. The gateway marks these replies with a `penny_local_` request id (which Claude Code keeps
+// in its transcript and telemetry) and a `msg_swallow_` message id.
+const isLocalReply = (requestId, messageId) =>
+  String(requestId || '').startsWith('penny_local_') || String(messageId || '').startsWith('msg_swallow_');
+
+// Without a request id (a gateway may not relay Anthropic's), a telemetry event and its
+// transcript line still carry the same usage, so that usage identifies the call.
+const usagePrint = (model, input, read, write, output) =>
+  [String(model || '').split('/').pop().replace('[1m]', ''), input, read, write, output].join(':');
+const addPrint = (prints, print) => prints.set(print, (prints.get(print) || 0) + 1);
+const takePrint = (prints, print) => {
+  const count = prints.get(print) || 0;
+  if (count) prints.set(print, count - 1);
+  return count > 0;
+};
+
 function emptyTotals() {
   return { cache_read: 0, cache_write: 0, write_5m: 0, write_1h: 0,
     fresh_input: 0, output: 0, reasoning_output: 0, total: 0, cost: 0 };
 }
 
 export class ClaudeMeter {
-  constructor({ sessionId, cwd, side, role, label, variant }) {
+  constructor({ sessionId, cwd, side, role, label, variant, pricingProfile = 'standard', options = {} }) {
     this.sessionId = sessionId;
     this.cwd = cwd;
     this.side = side;
     this.role = role;
     this.label = label || role;
     this.variant = variant;
+    this.options = options;
+    this.pricingProfile = pricingProfiles.includes(pricingProfile) ? pricingProfile : 'standard';
     this.root = join(homedir(), '.claude', 'projects');
     this.files = new Map();
     this.ids = new Set();
@@ -62,6 +102,67 @@ export class ClaudeMeter {
     this.model = '';
     this.transcriptPath = null;
     this.started = Date.now() / 1000;
+    this.requestIds = new Set();
+    this.transcriptPrints = new Map();
+    this.chargedPrints = new Map();
+    this.telemetry = new Map();
+    this.sideCalls = { count: 0, cost: 0, models: {} };
+    this.localReplyIds = new Set();
+  }
+
+  // api_request events from this pane's telemetry (see telemetry.mjs).
+  ingestTelemetry(requests) {
+    for (const request of requests) {
+      if (!this.telemetry.has(request.key)) {
+        this.telemetry.set(request.key, { ...request, receivedAt: Date.now(), resolved: false, charged: false });
+      }
+    }
+  }
+
+  // Charges requests Claude Code made outside the transcript (the auto-mode reviewer, titles,
+  // and similar background calls). Pass final once the session has ended to skip the grace.
+  chargeSideCalls({ final = false } = {}) {
+    const now = Date.now();
+    for (const request of this.telemetry.values()) {
+      if (request.resolved) continue;
+      if (isLocalReply(request.requestId)) {
+        request.resolved = true;
+        this.localReplyIds.add(request.requestId);
+        continue;
+      }
+      const { model, cache_read: read, cache_write: write, fresh_input: input, output } = request;
+      const print = usagePrint(model, input, read, write, output);
+      if (request.requestId ? this.requestIds.has(request.requestId) : takePrint(this.transcriptPrints, print)) {
+        request.resolved = true;
+        continue;
+      }
+      if (!final && now - request.receivedAt < sideCallGraceMs) continue;
+      request.resolved = true;
+      request.charged = true;
+      if (!request.requestId) addPrint(this.chargedPrints, print);
+      const prices = rateFor(model, read + write + input, this.pricingProfile);
+      // Telemetry does not split cache writes by TTL; they are priced at the 5-minute rate.
+      const cost = input * prices[0] + read * prices[1] + write * prices[2] + output * prices[4];
+      const total = read + write + input + output;
+      this.calls.push({ timestamp: request.timestamp, recorded_at: now / 1000, model,
+        cache_read: read, cache_write: write, write_5m: write, write_1h: 0, fresh_input: input, output,
+        reasoning_output: 0, total, cost, context_tokens: read + write + input,
+        pricing_profile: this.pricingProfile, side_call: true, query_source: request.querySource,
+        rates_per_million: Object.fromEntries(
+          ['input', 'cache_read', 'cache_write_5m', 'cache_write_1h', 'output']
+            .map((name, index) => [name, prices[index] * 1_000_000])) });
+      this.totals.cache_read += read;
+      this.totals.cache_write += write;
+      this.totals.write_5m += write;
+      this.totals.fresh_input += input;
+      this.totals.output += output;
+      this.totals.total += total;
+      this.totals.cost += cost;
+      const byModel = this.sideCalls.models[model] ||= { calls: 0, tokens: 0, cost: 0 };
+      byModel.calls += 1; byModel.tokens += total; byModel.cost += cost;
+      this.sideCalls.count += 1;
+      this.sideCalls.cost += cost;
+    }
   }
 
   async findTranscript() {
@@ -93,7 +194,7 @@ export class ClaudeMeter {
     return null;
   }
 
-  async poll() {
+  async poll({ final = false } = {}) {
     const transcript = await this.findTranscript();
     if (!transcript) return this.snapshot();
     const paths = [transcript];
@@ -108,6 +209,7 @@ export class ClaudeMeter {
     };
     await collect(join(transcript.slice(0, -6), 'subagents'));
     for (const path of paths) await this.readAppended(path);
+    this.chargeSideCalls({ final });
     return this.snapshot();
   }
 
@@ -131,6 +233,11 @@ export class ClaudeMeter {
         const message = obj.message;
         const usage = message?.usage;
         if (!usage || typeof usage !== 'object') continue;
+        if (obj.requestId) {
+          this.requestIds.add(obj.requestId);
+          // Already charged from telemetry when its transcript line arrived late.
+          if (this.telemetry.get(obj.requestId)?.charged) continue;
+        }
         if (message.id && this.ids.has(message.id)) continue;
         if (message.id) this.ids.add(message.id);
         const read = Number(usage.cache_read_input_tokens) || 0;
@@ -141,7 +248,19 @@ export class ClaudeMeter {
         const input = Number(usage.input_tokens) || 0;
         const output = Number(usage.output_tokens) || 0;
         const model = message.model || this.model;
-        const prices = rateFor(model, read + write + input);
+        if (isLocalReply(obj.requestId, message.id)) {
+          this.localReplyIds.add(obj.requestId || message.id);
+          // Without a request id the matching telemetry event is recognized by its usage.
+          if (!obj.requestId) addPrint(this.transcriptPrints, usagePrint(model, input, read, write, output));
+          continue;
+        }
+        if (!obj.requestId) {
+          const print = usagePrint(model, input, read, write, output);
+          // Already charged from telemetry when its transcript line arrived late.
+          if (takePrint(this.chargedPrints, print)) continue;
+          addPrint(this.transcriptPrints, print);
+        }
+        const prices = rateFor(model, read + write + input, this.pricingProfile);
         const cost = input * prices[0] + read * prices[1] + write5 * prices[2] +
           write1 * prices[3] + output * prices[4];
         const call = { timestamp: obj.timestamp || null, recorded_at: Date.now() / 1000,
@@ -149,7 +268,7 @@ export class ClaudeMeter {
           fresh_input: input, output, reasoning_output: 0,
           total: read + write + input + output, cost,
           context_tokens: read + write + input,
-          pricing_profile: 'standard',
+          pricing_profile: this.pricingProfile,
           rates_per_million: Object.fromEntries(
             ['input', 'cache_read', 'cache_write_5m', 'cache_write_1h', 'output']
               .map((name, index) => [name, prices[index] * 1_000_000])),
@@ -169,89 +288,121 @@ export class ClaudeMeter {
   }
 
   snapshot() {
-    return { side: this.side, role: this.role, label: this.label, variant: this.variant,
-      harness: 'claude-code', cwd: this.cwd, pricing_profile: 'standard', session_id: this.sessionId,
+    return { side: this.side, role: this.role, label: this.label, variant: this.variant, options: this.options,
+      harness: 'claude-code', cwd: this.cwd, pricing_profile: this.pricingProfile, session_id: this.sessionId,
       transcript_path: this.transcriptPath, model: this.model, call_count: this.calls.length,
-      totals: { ...this.totals } };
+      totals: { ...this.totals }, local_replies: this.localReplyIds.size,
+      side_calls: { ...this.sideCalls, models: structuredClone(this.sideCalls.models) } };
   }
 }
 
-// Codex writes cumulative token_count snapshots to dated rollout JSONL files.
-// Keep a cursor per transcript and charge each snapshot's delta once.
+// Codex writes cumulative token_count snapshots to dated rollout JSONL files, one per thread.
+// Subagent threads sit beside the root and name their parent in session_meta, so the meter
+// follows that lineage (as usage.related_transcripts does) and charges each thread's deltas once.
 export class CodexMeter extends ClaudeMeter {
   constructor(options) {
     super(options);
     this.root = join(homedir(), '.codex', 'sessions');
     this.transcriptPath = null;
-    this.previous = null;
+    this.threads = new Map();
+    this.metas = new Map();
     this.started = Date.now() / 1000;
   }
 
-  async findTranscript() {
-    if (this.transcriptPath) return this.transcriptPath;
+  // Rollouts touched since this comparison started, with their session_meta payloads.
+  async recentRollouts() {
+    const found = [];
     const visit = async (directory) => {
       let entries;
-      try { entries = await readdir(directory, { withFileTypes: true }); } catch { return []; }
-      const found = [];
+      try { entries = await readdir(directory, { withFileTypes: true }); } catch { return; }
       for (const entry of entries) {
         const path = join(directory, entry.name);
-        if (entry.isDirectory()) found.push(...await visit(path));
-        else if (entry.name.endsWith('.jsonl')) {
-          try {
-            const meta = JSON.parse(await readFirstLine(path)).payload;
-            const info = await stat(path);
-            const expectedProvider = this.role === 'NATIVE' ? 'openai' : 'pennyrouter';
-            if (meta?.cwd && meta.cwd.toLowerCase() === this.cwd.toLowerCase() &&
-                meta.model_provider === expectedProvider &&
-                info.mtimeMs / 1000 >= this.started - 3) found.push([path, info.mtimeMs]);
-          } catch { /* incomplete or unrelated rollout */ }
-        }
+        if (entry.isDirectory()) { await visit(path); continue; }
+        if (!entry.name.endsWith('.jsonl')) continue;
+        try {
+          const info = await stat(path);
+          if (info.mtimeMs / 1000 < this.started - 3) continue;
+          if (!this.metas.has(path)) this.metas.set(path, JSON.parse(await readFirstLine(path)).payload || {});
+          found.push({ path, meta: this.metas.get(path), mtimeMs: info.mtimeMs });
+        } catch { /* incomplete or unrelated rollout */ }
       }
-      return found;
     };
-    const candidates = await visit(this.root);
-    candidates.sort((a, b) => b[1] - a[1]);
-    this.transcriptPath = candidates[0]?.[0] || null;
+    await visit(this.root);
+    return found;
+  }
+
+  // Each pane has its own folder, so the folder and start time identify its session. The
+  // provider cannot: subscription-backed Penny sessions record model_provider = openai.
+  async findTranscript(rollouts) {
+    if (this.transcriptPath) return this.transcriptPath;
+    const roots = (rollouts || await this.recentRollouts()).filter(({ meta }) =>
+      meta?.cwd && meta.cwd.toLowerCase() === this.cwd.toLowerCase() && !parentOf(meta));
+    roots.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    this.transcriptPath = roots[0]?.path || null;
     return this.transcriptPath;
   }
 
   async poll() {
-    const path = await this.findTranscript();
-    if (!path) return this.snapshot();
+    const rollouts = await this.recentRollouts();
+    const root = await this.findTranscript(rollouts);
+    if (!root) return this.snapshot();
+    const lineage = new Set([threadId(this.metas.get(root))].filter(Boolean));
+    const paths = [root];
+    for (let added = true; added;) {
+      added = false;
+      for (const { path, meta } of rollouts) {
+        if (paths.includes(path) || !lineage.has(parentOf(meta))) continue;
+        paths.push(path);
+        if (threadId(meta)) lineage.add(threadId(meta));
+        added = true;
+      }
+    }
+    for (const path of paths) await this.readRollout(path, path === root);
+    return this.snapshot();
+  }
+
+  async readRollout(path, isRoot) {
+    const thread = this.threads.get(path) || { previous: null, model: '' };
+    this.threads.set(path, thread);
     let size;
-    try { ({ size } = await stat(path)); } catch { return this.snapshot(); }
+    try { ({ size } = await stat(path)); } catch { return; }
     let offset = this.files.get(path) || 0;
-    if (size < offset) { offset = 0; this.previous = null; }
-    if (size === offset) return this.snapshot();
+    if (size < offset) { offset = 0; thread.previous = null; }
+    if (size === offset) return;
     const handle = await open(path, 'r');
     try {
       const buffer = Buffer.alloc(size - offset);
       const { bytesRead } = await handle.read(buffer, 0, buffer.length, offset);
       const text = buffer.subarray(0, bytesRead).toString('utf8');
       const end = text.lastIndexOf('\n');
-      if (end < 0) return this.snapshot();
+      if (end < 0) return;
       this.files.set(path, offset + Buffer.byteLength(text.slice(0, end + 1)));
       for (const line of text.slice(0, end).split('\n')) {
         let obj;
         try { obj = JSON.parse(line); } catch { continue; }
         const payload = obj.payload;
-        if (obj.type === 'turn_context' && payload?.model) this.model = payload.model;
+        if (obj.type === 'turn_context' && payload?.model) {
+          thread.model = payload.model;
+          if (isRoot) this.model = payload.model;
+        }
         if (payload?.type !== 'token_count' || !payload.info?.total_token_usage) continue;
         const total = payload.info.total_token_usage;
         const fingerprint = ['input_tokens', 'cached_input_tokens', 'cache_write_input_tokens',
           'output_tokens', 'reasoning_output_tokens'].map((key) => Number(total[key]) || 0);
-        if (this.previous && fingerprint.every((value, index) => value === this.previous[index])) continue;
-        const delta = fingerprint.map((value, index) => Math.max(0, value - (this.previous?.[index] || 0)));
-        this.previous = fingerprint;
+        if (thread.previous && fingerprint.every((value, index) => value === thread.previous[index])) continue;
+        const delta = fingerprint.map((value, index) => Math.max(0, value - (thread.previous?.[index] || 0)));
+        thread.previous = fingerprint;
         const [input, cached, write, output, reasoning] = delta;
         const fresh = Math.max(0, input - cached - write);
         const context = Number(payload.info.last_token_usage?.input_tokens) || input;
-        const prices = rateFor(this.model, context);
+        const model = thread.model || this.model;
+        const prices = rateFor(model, context, this.pricingProfile);
         const cost = fresh * prices[0] + cached * prices[1] + write * prices[2] + output * prices[4];
         const call = { timestamp: obj.timestamp || null, recorded_at: Date.now() / 1000,
-          model: this.model, cache_read: cached, cache_write: write, write_5m: write,
+          model, cache_read: cached, cache_write: write, write_5m: write,
           write_1h: 0, fresh_input: fresh, output, reasoning_output: reasoning,
-          total: input + output, cost, context_tokens: context, pricing_profile: 'standard',
+          total: input + output, cost, context_tokens: context, pricing_profile: this.pricingProfile,
+          ...(isRoot ? {} : { thread: basename(path) }),
           rates_per_million: Object.fromEntries(
             ['input', 'cache_read', 'cache_write_5m', 'cache_write_1h', 'output']
               .map((name, index) => [name, prices[index] * 1_000_000])) };
@@ -262,7 +413,6 @@ export class CodexMeter extends ClaudeMeter {
         this.totals.total += call.total; this.totals.cost += cost;
       }
     } finally { await handle.close(); }
-    return this.snapshot();
   }
 
   snapshot() {
@@ -271,7 +421,10 @@ export class CodexMeter extends ClaudeMeter {
   }
 }
 
-export async function saveReport(left, right, reportsDir) {
+const threadId = (meta) => String(meta?.id || meta?.session_id || '');
+const parentOf = (meta) => String(meta?.parent_thread_id || meta?.forked_from_id || '');
+
+export async function saveReport(left, right, reportsDir, environment) {
   const sides = [left.snapshot(), right.snapshot()];
   const native = sides.find((side) => side.role === 'NATIVE') || sides[0];
   const penny = sides.find((side) => side.role === 'PENNY') || sides[1];
@@ -282,7 +435,8 @@ export async function saveReport(left, right, reportsDir) {
     token_percent: native.totals.total ? (native.totals.total - penny.totals.total) / native.totals.total * 100 : 0,
   };
   const report = { created_at: new Date().toISOString(),
-    measured_from_epoch: Math.min(left.started, right.started), pricing_profile: 'standard',
+    measured_from_epoch: Math.min(left.started, right.started), pricing_profile: left.pricingProfile,
+    ...(environment ? { environment } : {}),
     left: { ...native, calls: left.calls }, right: { ...penny, calls: right.calls },
     savings_native_minus_penny: savings };
   await mkdir(reportsDir, { recursive: true });
@@ -291,3 +445,17 @@ export async function saveReport(left, right, reportsDir) {
   return { path, savings, native: { calls: native.call_count, totals: native.totals },
     penny: { calls: penny.call_count, totals: penny.totals } };
 }
+
+// The report a gallery submission carries (apps/web/lib/gallery.ts validates it and recomputes
+// the savings). Only a native pane and a Penny pane on the same harness can be published.
+export function galleryReport(left, right, { environment, harnessVersions }) {
+  const sides = [left.snapshot(), right.snapshot()];
+  const native = sides.find((side) => side.role === 'NATIVE');
+  const penny = sides.find((side) => side.role === 'PENNY');
+  if (!native || !penny || native.harness !== penny.harness) return null;
+  const side = (snapshot) => ({ model: snapshot.model, call_count: snapshot.call_count, totals: snapshot.totals,
+    side_calls: snapshot.side_calls || { count: 0, cost: 0, models: {} } });
+  return JSON.stringify({ version: 1, harness: native.harness,
+    harness_version: harnessVersions?.[native.harness === 'codex' ? 'codex' : 'claude'] || '',
+    environment, native: side(native), penny: side(penny), finished_at: new Date().toISOString() });
+}