@neuralmindlabs/tokn 0.1.0

package/packages/tokn/src/types.ts

@@ -0,0 +1,51 @@
+export type Tool = 'claude' | 'codex' | 'cursor';
+
+export interface UsageEvent {
+  tool: Tool;
+  /** ISO timestamp of the API call */
+  timestamp: string;
+  model: string;
+  /** Absolute path of the project the session ran in, if known */
+  project?: string;
+  inputTokens: number;
+  outputTokens: number;
+  /** Anthropic cache_creation_input_tokens (5m + 1h combined) */
+  cacheWriteTokens: number;
+  /** Subset of cacheWriteTokens written with 1h TTL — billed at 2x input rate instead of 1.25x */
+  cacheWrite1hTokens?: number;
+  /** Anthropic cache_read_input_tokens / OpenAI cached_input_tokens */
+  cacheReadTokens: number;
+}
+
+export interface CostedEvent extends UsageEvent {
+  /** undefined when the model has no pricing entry */
+  costUSD?: number;
+}
+
+export interface ToolDayTotals {
+  inputTokens: number;
+  outputTokens: number;
+  cacheWriteTokens: number;
+  cacheReadTokens: number;
+  costUSD: number;
+  /** events whose model had no pricing entry (tokens counted, cost not) */
+  unpricedEvents: number;
+}
+
+export interface DayRollup {
+  /** local date YYYY-MM-DD */
+  date: string;
+  byTool: Partial<Record<Tool, ToolDayTotals>>;
+  byModel: Record<string, ToolDayTotals>;
+  byProject: Record<string, ToolDayTotals>;
+  totalCostUSD: number;
+  totalTokens: number;
+}
+
+export interface FileScanState {
+  size: number;
+  mtimeMs: number;
+  project?: string;
+  /** parsed contribution of this file (date -> model -> totals), so unchanged files are never re-read */
+  days: Record<string, Record<string, ToolDayTotals>>;
+}

package/packages/tokn/tests/__snapshots__/eval.test.ts.snap

@@ -0,0 +1,12 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`eval: fixtures → rollups > produces a stable per-day rollup (golden cost snapshot) 1`] = `
+{
+  "claudeCost": 0.0576,
+  "claudeTokens": 27000,
+  "codexCost": 0.02905,
+  "codexTokens": 46200,
+  "date": "2026-07-05",
+  "totalCost": 0.08665,
+}
+`;

package/packages/tokn/tests/aggregate.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest';
+import { buildRollups, eventsToDays, localDate, totalTokens } from '../src/aggregate.ts';
+import type { UsageEvent } from '../src/types.ts';
+
+const ev = (over: Partial<UsageEvent>): UsageEvent => ({
+  tool: 'claude',
+  timestamp: '2026-07-05T10:00:00.000Z',
+  model: 'claude-sonnet-5',
+  inputTokens: 100,
+  outputTokens: 50,
+  cacheWriteTokens: 0,
+  cacheReadTokens: 0,
+  ...over,
+});
+
+describe('aggregate', () => {
+  it('groups events into local dates and counts unpriced models separately', () => {
+    const days = eventsToDays([ev({}), ev({ model: 'mystery-model' })]);
+    const day = days['2026-07-05'];
+    expect(day['claude-sonnet-5'].costUSD).toBeGreaterThan(0);
+    expect(day['mystery-model'].costUSD).toBe(0);
+    expect(day['mystery-model'].unpricedEvents).toBe(1);
+  });
+
+  it('merges multiple sources into per-day tool/model/project rollups', () => {
+    const claudeDays = eventsToDays([ev({ inputTokens: 1_000_000 })]);
+    const codexDays = eventsToDays([ev({ tool: 'codex', model: 'gpt-5.2-codex', inputTokens: 500_000 })]);
+    const rollups = buildRollups([
+      { tool: 'claude', project: '/p/a', days: claudeDays },
+      { tool: 'codex', project: '/p/b', days: codexDays },
+    ]);
+    expect(rollups).toHaveLength(1);
+    const day = rollups[0];
+    expect(day.date).toBe('2026-07-05');
+    expect(day.byTool.claude!.inputTokens).toBe(1_000_000);
+    expect(day.byTool.codex!.inputTokens).toBe(500_000);
+    expect(Object.keys(day.byProject).sort()).toEqual(['/p/a', '/p/b']);
+    expect(day.totalCostUSD).toBeCloseTo(day.byTool.claude!.costUSD + day.byTool.codex!.costUSD, 10);
+    expect(day.totalTokens).toBe(totalTokens(day.byTool.claude!) + totalTokens(day.byTool.codex!));
+  });
+
+  it('maps ISO timestamps to local calendar dates', () => {
+    expect(localDate('2026-07-05T12:00:00.000Z')).toBe('2026-07-05');
+    expect(localDate('2026-07-06T23:59:59.000Z')).toBe('2026-07-06');
+  });
+
+  it('sorts rollups by date ascending across multiple days', () => {
+    const later = eventsToDays([ev({ timestamp: '2026-07-06T10:00:00.000Z' })]);
+    const earlier = eventsToDays([ev({ timestamp: '2026-07-05T10:00:00.000Z' })]);
+    const rollups = buildRollups([
+      { tool: 'claude', days: later },
+      { tool: 'codex', days: earlier },
+    ]);
+    expect(rollups.map((r) => r.date)).toEqual(['2026-07-05', '2026-07-06']);
+  });
+
+  it('groups sources without a project under (unknown)', () => {
+    const days = eventsToDays([ev({ inputTokens: 100 })]);
+    const rollups = buildRollups([{ tool: 'claude', days }]);
+    expect(rollups[0].byProject['(unknown)']!.inputTokens).toBe(100);
+  });
+
+  it('accumulates multiple models on the same day into byModel totals', () => {
+    const days = eventsToDays([
+      ev({ model: 'claude-sonnet-5', inputTokens: 100 }),
+      ev({ model: 'claude-haiku-4-5-20251001', inputTokens: 200 }),
+    ]);
+    const rollups = buildRollups([{ tool: 'claude', project: '/p/a', days }]);
+    expect(Object.keys(rollups[0].byModel)).toHaveLength(2);
+    expect(rollups[0].byModel['claude-sonnet-5'].inputTokens).toBe(100);
+    expect(rollups[0].byModel['claude-haiku-4-5-20251001'].inputTokens).toBe(200);
+  });
+});

package/packages/tokn/tests/claude.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest';
+import { parseClaudeSession } from '../src/parsers/claude.ts';
+
+const assistantLine = (over: Record<string, unknown> = {}, usage: Record<string, number> = {}) =>
+  JSON.stringify({
+    type: 'assistant',
+    timestamp: '2026-07-05T10:00:00.000Z',
+    requestId: 'req_1',
+    cwd: '/Users/surya/proj/a',
+    message: {
+      id: 'msg_1',
+      model: 'claude-sonnet-5',
+      usage: {
+        input_tokens: 10,
+        output_tokens: 100,
+        cache_creation_input_tokens: 500,
+        cache_read_input_tokens: 2000,
+        ...usage,
+      },
+    },
+    ...over,
+  });
+
+describe('parseClaudeSession', () => {
+  it('extracts usage events with project from cwd', () => {
+    const { events, project } = parseClaudeSession(
+      [JSON.stringify({ type: 'user', cwd: '/Users/surya/proj/a' }), assistantLine()].join('\n'),
+      new Set(),
+    );
+    expect(project).toBe('/Users/surya/proj/a');
+    expect(events).toHaveLength(1);
+    expect(events[0]).toMatchObject({
+      tool: 'claude',
+      model: 'claude-sonnet-5',
+      inputTokens: 10,
+      outputTokens: 100,
+      cacheWriteTokens: 500,
+      cacheReadTokens: 2000,
+    });
+  });
+
+  it('dedupes identical message.id + requestId across files', () => {
+    const dedupe = new Set<string>();
+    const a = parseClaudeSession(assistantLine(), dedupe);
+    const b = parseClaudeSession(assistantLine(), dedupe);
+    expect(a.events).toHaveLength(1);
+    expect(b.events).toHaveLength(0);
+  });
+
+  it('keeps events that lack ids instead of deduping them', () => {
+    const line = assistantLine({ requestId: undefined });
+    const dedupe = new Set<string>();
+    expect(parseClaudeSession(`${line}\n${line}`, dedupe).events).toHaveLength(2);
+  });
+
+  it('extracts ephemeral 1h cache-write tokens from usage.cache_creation', () => {
+    const line = assistantLine(
+      {},
+      {
+        cache_creation_input_tokens: 1000,
+        cache_creation: { ephemeral_1h_input_tokens: 800 },
+      },
+    );
+    const { events } = parseClaudeSession(line, new Set());
+    expect(events[0].cacheWriteTokens).toBe(1000);
+    expect(events[0].cacheWrite1hTokens).toBe(800);
+  });
+
+  it('skips assistant lines missing timestamp, usage, or model', () => {
+    const noTs = JSON.stringify({
+      type: 'assistant',
+      message: { id: 'm', model: 'claude-sonnet-5', usage: { input_tokens: 1, output_tokens: 1 } },
+    });
+    const noUsage = assistantLine({ timestamp: '2026-07-05T10:00:00.000Z', message: { id: 'm', model: 'claude-sonnet-5' } });
+    const noModel = assistantLine({ message: { id: 'm', usage: { input_tokens: 1, output_tokens: 1 } } });
+    expect(parseClaudeSession([noTs, noUsage, noModel].join('\n'), new Set()).events).toHaveLength(0);
+  });
+
+  it('skips synthetic models, malformed lines, and non-assistant entries', () => {
+    const content = [
+      'not json{{{',
+      JSON.stringify({ type: 'user', message: { role: 'user' } }),
+      assistantLine({ message: { id: 'm2', model: '<synthetic>', usage: { input_tokens: 5 } } }),
+    ].join('\n');
+    expect(parseClaudeSession(content, new Set()).events).toHaveLength(0);
+  });
+});

package/packages/tokn/tests/codex.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import { parseCodexSession } from '../src/parsers/codex.ts';
+
+const meta = JSON.stringify({
+  timestamp: '2026-07-05T09:00:00.000Z',
+  type: 'session_meta',
+  payload: { id: 's1', cwd: '/Users/surya/proj/b', model_provider: 'openai' },
+});
+const turn = JSON.stringify({
+  timestamp: '2026-07-05T09:00:01.000Z',
+  type: 'turn_context',
+  payload: { model: 'gpt-5.2-codex', cwd: '/Users/surya/proj/b', effort: 'medium' },
+});
+const count = (input: number, cached: number, output: number, ts = '2026-07-05T09:01:00.000Z') =>
+  JSON.stringify({
+    timestamp: ts,
+    type: 'event_msg',
+    payload: {
+      type: 'token_count',
+      info: {
+        total_token_usage: { input_tokens: input, cached_input_tokens: cached, output_tokens: output, total_tokens: input + output },
+        last_token_usage: { input_tokens: 0, cached_input_tokens: 0, output_tokens: 0, total_tokens: 0 },
+      },
+    },
+  });
+
+describe('parseCodexSession', () => {
+  it('takes deltas of the cumulative counter and tracks model/project', () => {
+    const { events, project } = parseCodexSession([meta, turn, count(1000, 800, 50), count(2500, 2000, 120)].join('\n'));
+    expect(project).toBe('/Users/surya/proj/b');
+    expect(events).toHaveLength(2);
+    expect(events[0]).toMatchObject({ tool: 'codex', model: 'gpt-5.2-codex', inputTokens: 1000, cacheReadTokens: 800, outputTokens: 50 });
+    expect(events[1]).toMatchObject({ inputTokens: 1500, cacheReadTokens: 1200, outputTokens: 70 });
+  });
+
+  it('treats a shrinking counter as a reset, not a negative delta', () => {
+    const { events } = parseCodexSession([turn, count(1000, 800, 50), count(300, 0, 10)].join('\n'));
+    expect(events).toHaveLength(2);
+    expect(events[1]).toMatchObject({ inputTokens: 300, cacheReadTokens: 0, outputTokens: 10 });
+  });
+
+  it('skips malformed JSON lines and entries without payload', () => {
+    const noPayload = JSON.stringify({ timestamp: '2026-07-05T09:00:00.000Z', type: 'event_msg' });
+    const { events } = parseCodexSession(['not json{{{', noPayload, turn, count(100, 0, 10)].join('\n'));
+    expect(events).toHaveLength(1);
+    expect(events[0].inputTokens).toBe(100);
+  });
+
+  it('skips zero-delta events and token_count without info', () => {
+    const empty = JSON.stringify({ timestamp: '2026-07-05T09:02:00.000Z', type: 'event_msg', payload: { type: 'token_count', info: null } });
+    const { events } = parseCodexSession([turn, count(1000, 0, 50), count(1000, 0, 50), empty].join('\n'));
+    expect(events).toHaveLength(1);
+  });
+});

package/packages/tokn/tests/cursor.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it } from 'vitest';
+import { fetchCursorUsage } from '../src/cursor.ts';
+
+const ts = new Date('2026-07-05T12:00:00.000Z').getTime();
+
+function mockResponse(body: unknown, status = 200): Response {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    json: async () => body,
+  } as Response;
+}
+
+describe('fetchCursorUsage', () => {
+  it('aggregates token usage and billed cost from usageEventsDisplay', async () => {
+    const result = await fetchCursorUsage('  my-cookie  ', {
+      fetchImpl: async () =>
+        mockResponse({
+          usageEventsDisplay: [
+            {
+              timestamp: ts,
+              model: 'claude-sonnet-5',
+              tokenUsage: { inputTokens: 1000, outputTokens: 500, cacheReadTokens: 200, totalCents: 42 },
+            },
+          ],
+          totalUsageEventsCount: 1,
+        }),
+    });
+    expect(result.status).toBe('ok');
+    const day = result.days['2026-07-05']['claude-sonnet-5'];
+    expect(day.inputTokens).toBe(1000);
+    expect(day.outputTokens).toBe(500);
+    expect(day.cacheReadTokens).toBe(200);
+    expect(day.costUSD).toBeCloseTo(0.42, 6);
+  });
+
+  it('falls back to usageEvents and defaults the model name to cursor', async () => {
+    const result = await fetchCursorUsage('cookie', {
+      fetchImpl: async () =>
+        mockResponse({
+          usageEvents: [{ timestamp: String(ts), tokenUsage: { totalCents: 10 } }],
+          totalUsageEventsCount: 1,
+        }),
+    });
+    expect(result.status).toBe('ok');
+    expect(result.days['2026-07-05'].cursor.costUSD).toBeCloseTo(0.1, 6);
+  });
+
+  it('paginates until all events are fetched', async () => {
+    let calls = 0;
+    const result = await fetchCursorUsage('cookie', {
+      fetchImpl: async () => {
+        calls++;
+        if (calls === 1) {
+          return mockResponse({
+            usageEventsDisplay: Array.from({ length: 300 }, () => ({
+              timestamp: ts,
+              model: 'cursor',
+              tokenUsage: { totalCents: 1 },
+            })),
+            totalUsageEventsCount: 301,
+          });
+        }
+        return mockResponse({
+          usageEventsDisplay: [{ timestamp: ts, model: 'cursor', tokenUsage: { totalCents: 1 } }],
+          totalUsageEventsCount: 301,
+        });
+      },
+    });
+    expect(result.status).toBe('ok');
+    expect(calls).toBe(2);
+    expect(result.days['2026-07-05'].cursor.costUSD).toBeCloseTo(3.01, 6);
+  });
+
+  it('returns unauthorized on 401/403 and when the body is not JSON', async () => {
+    expect((await fetchCursorUsage('bad', { fetchImpl: async () => mockResponse({}, 401) })).status).toBe('unauthorized');
+    expect((await fetchCursorUsage('bad', { fetchImpl: async () => mockResponse({}, 403) })).status).toBe('unauthorized');
+    expect(
+      (
+        await fetchCursorUsage('bad', {
+          fetchImpl: async () =>
+            ({
+              ok: true,
+              status: 200,
+              json: async () => {
+                throw new Error('not json');
+              },
+            }) as Response,
+        })
+      ).status,
+    ).toBe('unauthorized');
+  });
+
+  it('returns error on network failure and non-ok HTTP', async () => {
+    const net = await fetchCursorUsage('cookie', {
+      fetchImpl: async () => {
+        throw new Error('offline');
+      },
+    });
+    expect(net.status).toBe('error');
+    expect(net.detail).toContain('offline');
+
+    const http = await fetchCursorUsage('cookie', {
+      fetchImpl: async () => mockResponse({}, 500),
+    });
+    expect(http.status).toBe('error');
+    expect(http.detail).toBe('HTTP 500');
+  });
+
+  it('skips events with missing or invalid timestamps', async () => {
+    const result = await fetchCursorUsage('cookie', {
+      fetchImpl: async () =>
+        mockResponse({
+          usageEventsDisplay: [
+            { timestamp: undefined, tokenUsage: { totalCents: 99 } },
+            { timestamp: 'not-a-number', tokenUsage: { totalCents: 99 } },
+            { timestamp: ts, tokenUsage: { totalCents: 5 } },
+          ],
+          totalUsageEventsCount: 3,
+        }),
+    });
+    expect(result.status).toBe('ok');
+    expect(Object.keys(result.days)).toEqual(['2026-07-05']);
+    expect(result.days['2026-07-05'].cursor.costUSD).toBeCloseTo(0.05, 6);
+  });
+});

package/packages/tokn/tests/eval.test.ts

@@ -0,0 +1,69 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { parseClaudeSession } from '../src/parsers/claude.ts';
+import { parseCodexSession } from '../src/parsers/codex.ts';
+import { buildRollups, eventsToDays, totalTokens } from '../src/aggregate.ts';
+
+const fixtures = join(dirname(fileURLToPath(import.meta.url)), 'fixtures');
+const read = (name: string) => readFileSync(join(fixtures, name), 'utf8');
+
+/**
+ * Golden end-to-end eval: parse committed fixture logs → aggregate → assert
+ * exact token totals and a snapshotted cost. Fully offline and deterministic
+ * (pricing is vendored), so it runs as a CI gate. This is the CI-safe stand-in
+ * for `npm run validate`, which needs the user's real ~/.claude logs + network.
+ */
+describe('eval: fixtures → rollups', () => {
+  const claude = parseClaudeSession(read('claude-session.jsonl'), new Set());
+  const codex = parseCodexSession(read('codex-session.jsonl'));
+
+  it('parses Claude usage including the 1h cache-write bucket', () => {
+    expect(claude.project).toBe('/Users/dev/proj/alpha');
+    expect(claude.events).toHaveLength(2);
+    const sum = claude.events.reduce(
+      (a, e) => ({
+        input: a.input + e.inputTokens,
+        output: a.output + e.outputTokens,
+        cacheWrite: a.cacheWrite + e.cacheWriteTokens,
+        cacheWrite1h: a.cacheWrite1h + (e.cacheWrite1hTokens ?? 0),
+        cacheRead: a.cacheRead + e.cacheReadTokens,
+      }),
+      { input: 0, output: 0, cacheWrite: 0, cacheWrite1h: 0, cacheRead: 0 },
+    );
+    expect(sum).toEqual({ input: 1500, output: 3500, cacheWrite: 4000, cacheWrite1h: 4000, cacheRead: 18000 });
+  });
+
+  it('takes Codex deltas and ignores the duplicated token_count event', () => {
+    // The fixture emits the first token_count twice; the dup is a zero delta.
+    expect(codex.events).toHaveLength(2);
+    const t = codex.events.reduce(
+      (a, e) => ({
+        input: a.input + e.inputTokens,
+        cacheRead: a.cacheRead + e.cacheReadTokens,
+        output: a.output + e.outputTokens,
+      }),
+      { input: 0, cacheRead: 0, output: 0 },
+    );
+    expect(t).toEqual({ input: 25000, cacheRead: 20000, output: 1200 });
+  });
+
+  it('produces a stable per-day rollup (golden cost snapshot)', () => {
+    const rollups = buildRollups([
+      { tool: 'claude', project: claude.project, days: eventsToDays(claude.events) },
+      { tool: 'codex', project: codex.project, days: eventsToDays(codex.events) },
+    ]);
+    const day = rollups.find((r) => r.date === '2026-07-05');
+    expect(day).toBeDefined();
+    const summary = {
+      date: day!.date,
+      claudeTokens: totalTokens(day!.byTool.claude),
+      codexTokens: totalTokens(day!.byTool.codex),
+      claudeCost: +day!.byTool.claude.costUSD.toFixed(6),
+      codexCost: +day!.byTool.codex.costUSD.toFixed(6),
+      totalCost: +day!.totalCostUSD.toFixed(6),
+    };
+    expect(summary).toMatchSnapshot();
+  });
+});

package/packages/tokn/tests/fixtures/claude-session.jsonl

@@ -0,0 +1,3 @@
+{"type":"user","cwd":"/Users/dev/proj/alpha","timestamp":"2026-07-05T09:59:00.000Z"}
+{"type":"assistant","timestamp":"2026-07-05T10:00:00.000Z","requestId":"req_a1","cwd":"/Users/dev/proj/alpha","message":{"id":"msg_a1","model":"claude-sonnet-5","usage":{"input_tokens":1000,"output_tokens":2000,"cache_creation_input_tokens":4000,"cache_creation":{"ephemeral_1h_input_tokens":4000},"cache_read_input_tokens":8000}}}
+{"type":"assistant","timestamp":"2026-07-05T10:05:00.000Z","requestId":"req_a2","cwd":"/Users/dev/proj/alpha","message":{"id":"msg_a2","model":"claude-sonnet-5","usage":{"input_tokens":500,"output_tokens":1500,"cache_creation_input_tokens":0,"cache_read_input_tokens":10000}}}

package/packages/tokn/tests/fixtures/codex-session.jsonl

@@ -0,0 +1,5 @@
+{"timestamp":"2026-07-05T09:00:00.000Z","type":"session_meta","payload":{"id":"s1","cwd":"/Users/dev/proj/beta","model_provider":"openai"}}
+{"timestamp":"2026-07-05T09:00:01.000Z","type":"turn_context","payload":{"model":"gpt-5.2-codex","cwd":"/Users/dev/proj/beta","effort":"medium"}}
+{"timestamp":"2026-07-05T09:01:00.000Z","type":"event_msg","payload":{"type":"token_count","info":{"total_token_usage":{"input_tokens":10000,"cached_input_tokens":8000,"output_tokens":500,"total_tokens":10500}}}}
+{"timestamp":"2026-07-05T09:01:00.000Z","type":"event_msg","payload":{"type":"token_count","info":{"total_token_usage":{"input_tokens":10000,"cached_input_tokens":8000,"output_tokens":500,"total_tokens":10500}}}}
+{"timestamp":"2026-07-05T09:02:00.000Z","type":"event_msg","payload":{"type":"token_count","info":{"total_token_usage":{"input_tokens":25000,"cached_input_tokens":20000,"output_tokens":1200,"total_tokens":26200}}}}

package/packages/tokn/tests/pricing.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it } from 'vitest';
+import { eventCostUSD, findPrice, fetchPrices, setPriceTable } from '../src/pricing/index.ts';
+import type { UsageEvent } from '../src/types.ts';
+
+const ev = (over: Partial<UsageEvent>): UsageEvent => ({
+  tool: 'claude',
+  timestamp: '2026-07-05T10:00:00.000Z',
+  model: 'claude-sonnet-5',
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheWriteTokens: 0,
+  cacheReadTokens: 0,
+  ...over,
+});
+
+describe('pricing', () => {
+  it('prices anthropic events with disjoint cache buckets', () => {
+    const cost = eventCostUSD(
+      ev({ inputTokens: 1000, outputTokens: 1000, cacheWriteTokens: 1000, cacheReadTokens: 1000 }),
+    );
+    expect(cost).toBeCloseTo(0.0147, 6);
+  });
+
+  it('prices openai events where input includes cached tokens', () => {
+    const cost = eventCostUSD(
+      ev({ tool: 'codex', model: 'gpt-5.2-codex', inputTokens: 2000, cacheReadTokens: 1000, outputTokens: 100 }),
+    );
+    expect(cost).toBeCloseTo(0.003325, 7);
+  });
+
+  it('resolves dated model ids and -latest suffixes', () => {
+    expect(findPrice('claude-haiku-4-5-20251001')).toBeDefined();
+    setPriceTable({
+      'gpt-4o': { provider: 'openai', input_cost_per_token: 1, output_cost_per_token: 1 },
+    });
+    expect(findPrice('gpt-4o-latest')).toBeDefined();
+    expect(eventCostUSD(ev({ model: 'some-future-model' }))).toBeUndefined();
+  });
+
+  it('prices 1h cache writes at 2x input rate separately from 5m writes', () => {
+    setPriceTable({
+      'test-anthropic': {
+        provider: 'anthropic',
+        input_cost_per_token: 0.001,
+        output_cost_per_token: 0,
+        cache_creation_input_token_cost: 0.00125,
+        cache_read_input_token_cost: 0.0001,
+      },
+    });
+    const cost = eventCostUSD(
+      ev({ model: 'test-anthropic', cacheWriteTokens: 1000, cacheWrite1hTokens: 600 }),
+    );
+    expect(cost).toBeCloseTo(400 * 0.00125 + 600 * 0.002, 6);
+  });
+
+  it('fetches model pricing and updates the pricing table with throttling', async () => {
+    let fetchCount = 0;
+    const mockFetch = async () => {
+      fetchCount++;
+      return {
+        ok: true,
+        json: async () => ({
+          data: [
+            {
+              id: 'custom-provider/custom-test-model',
+              provider: 'custom-provider',
+              inputPricePer1M: 10,
+              outputPricePer1M: 20,
+            },
+            {
+              id: 'anthropic/claude-test',
+              provider: 'Anthropic',
+              inputPricePer1M: 3,
+              outputPricePer1M: 15,
+            },
+            {
+              id: 'openai/gpt-test',
+              provider: 'OpenAI',
+              inputPricePer1M: 2,
+              outputPricePer1M: 8,
+            },
+          ],
+        }),
+      } as any;
+    };
+
+    // Force fetch should invoke mockFetch
+    const ok = await fetchPrices({ fetchImpl: mockFetch, force: true });
+    expect(ok).toBe(true);
+    expect(fetchCount).toBe(1);
+
+    // Verify model was added with full ID and bare ID
+    const priceFull = findPrice('custom-provider/custom-test-model');
+    expect(priceFull).toBeDefined();
+    expect(priceFull?.input_cost_per_token).toBe(10 / 1000000);
+    expect(priceFull?.output_cost_per_token).toBe(20 / 1000000);
+
+    const priceBare = findPrice('custom-test-model');
+    expect(priceBare).toBeDefined();
+    expect(priceBare?.input_cost_per_token).toBe(10 / 1000000);
+
+    const anthropic = findPrice('claude-test');
+    expect(anthropic?.cache_creation_input_token_cost).toBeCloseTo((3 / 1_000_000) * 1.25, 12);
+    expect(anthropic?.cache_read_input_token_cost).toBeCloseTo((3 / 1_000_000) * 0.1, 12);
+
+    const openai = findPrice('gpt-test');
+    expect(openai?.cache_read_input_token_cost).toBeCloseTo((2 / 1_000_000) * 0.5, 12);
+
+    // Throttling: consecutive call without 'force' should not invoke mockFetch
+    const ok2 = await fetchPrices({ fetchImpl: mockFetch, force: false });
+    expect(ok2).toBe(true);
+    expect(fetchCount).toBe(1);
+
+    // Failure cases should preserve the existing table and return false
+    const badFetch = async () => {
+      throw new Error('network down');
+    };
+    const ok3 = await fetchPrices({ fetchImpl: badFetch, force: true });
+    expect(ok3).toBe(false);
+    expect(findPrice('custom-test-model')).toBeDefined();
+  });
+
+  it('returns false when the API responds with an error or invalid body', async () => {
+    expect(
+      await fetchPrices({
+        fetchImpl: async () => ({ ok: false }) as Response,
+        force: true,
+      }),
+    ).toBe(false);
+    expect(
+      await fetchPrices({
+        fetchImpl: async () => ({ ok: true, json: async () => ({}) }) as Response,
+        force: true,
+      }),
+    ).toBe(false);
+  });
+});

package/packages/tokn/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "rewriteRelativeImportExtensions": true,
+    "resolveJsonModule": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": [
+      "node"
+    ]
+  },
+  "include": [
+    "src"
+  ]
+}