@adecore/agents 0.31.5 → 0.31.7

package/src/testing/fake-acp-capture.ts

@@ -0,0 +1,70 @@
+/*
+ * An ACP agent that answers with the frames a real one sent, recorded in a capture: its `initialize`, its
+ * `session/new`, and every update of one prompt before the response. Every prompt gets the same turn, except
+ * that a `session_info_update` carries the prompt's own text as its title, as Copilot CLI names a session.
+ */
+import type { FakeCli } from './fake-cli.ts';
+
+type Frame = Record<string, unknown>;
+
+export interface AcpCapture {
+    sessionId: string;
+    initialize: unknown;
+    sessionNew: unknown;
+    // The `available_commands_update` the agent sends before it answers `session/new`.
+    commands: unknown[];
+    setConfigOption: unknown;
+    promptUpdates: unknown[];
+    promptResponse: unknown;
+}
+
+export function fakeAcpCapture(capture: AcpCapture): FakeCli {
+    return (io) => {
+        const send = (frame: Frame): void => {
+            io.out({ jsonrpc: '2.0', ...frame });
+        };
+        const update = (fields: unknown): void => {
+            send({ method: 'session/update', params: { sessionId: capture.sessionId, update: fields } });
+        };
+        return {
+            onLine: (line) => {
+                const frame = JSON.parse(line) as Frame;
+                const id = frame.id;
+                switch (frame.method) {
+                    case undefined:
+                        return;
+                    case 'initialize':
+                        send({ id, result: capture.initialize });
+                        return;
+                    case 'session/new':
+                        update({ sessionUpdate: 'available_commands_update', availableCommands: capture.commands });
+                        send({ id, result: capture.sessionNew });
+                        return;
+                    case 'session/set_config_option':
+                        send({ id, result: capture.setConfigOption });
+                        return;
+                    case 'session/set_mode':
+                    case 'session/close':
+                        send({ id, result: {} });
+                        return;
+                    case 'session/prompt': {
+                        const blocks = Array.isArray((frame.params as Frame | undefined)?.prompt) ? ((frame.params as Frame).prompt as Frame[]) : [];
+                        const text = blocks.find((block) => block.type === 'text')?.text;
+                        for (const fields of capture.promptUpdates) {
+                            const named = (fields as Frame).sessionUpdate === 'session_info_update';
+                            update(named ? { ...(fields as Frame), title: text } : fields);
+                        }
+                        send({ id, result: capture.promptResponse });
+                        return;
+                    }
+                    case 'session/cancel':
+                        return;
+                    default:
+                        if (id !== undefined) {
+                            send({ id, error: { code: -32601, message: `Method not found: ${String(frame.method)}` } });
+                        }
+                }
+            }
+        };
+    };
+}

package/src/usage/aggregate.ts

@@ -186,7 +186,7 @@ export async function aggregate(
         if (day < payload.from || day > payload.to) {
             continue;
         }
-        const lookup = prices.look(record.model);
+        const lookup = prices.look(record.model, record.serviceTier, record.timestampMs);
         const cost = record.costUsd ?? (lookup.price === null ? 0 : costOf(record.totals, lookup.price));
         foldBucket(buckets, slot, record, account, lookup.price, cost);
         foldModel(models, record, account, lookup, cost);

package/src/usage/index-file.ts

@@ -2,8 +2,8 @@ import { UsageProviderSchema, type UsageProvider } from '@adecore/agent-contract
 import type { UsageRecord } from './record.ts';
 import type { CodexParserState } from './readers/codex.ts';
 
-/* Another version is thrown away rather than migrated, since rebuilding costs one cold scan; version 1 is read as it is. */
-const INDEX_VERSION = 2;
+/* Old records survive deleted transcripts; the scanner reparses existing Codex files with its current reader. */
+const INDEX_VERSION = 3;
 /* Before accounts: every record was the default account's, so it reads as that without a scan. */
 const ACCOUNTLESS_VERSION = 1;
 
@@ -21,18 +21,14 @@ export interface IndexedFile {
     codex: CodexParserState | null;
     /* A versioned hash of all bytes before the offset; absent in indexes that cannot verify an append. */
     head: string | null;
+    parserVersion?: number;
+    compressed?: boolean;
 }
 
 export type UsageIndex = Map<string, IndexedFile>;
 
-/*
- * The index is a few hundred thousand records of seven numbers each, and the same model, session,
- * directory and account strings over and over. Interning those and writing a record as a tuple is
- * what keeps the file at a few megabytes instead of tens of them. The account is one past its place
- * in its table, and 0 for the default account, which is also what a version 1 row without it means.
- * A cost the CLI reported itself rides last, only on a row that has one, so every other row keeps its length.
- */
-type RecordRow = [number, number, number, number, number, number, number, number, number, number, number, string | 0, number?, number?];
+/* Interned names keep the index compact; optional cost and tier fields preserve per-call pricing. */
+type RecordRow = [number, number, number, number, number, number, number, number, number, number, number, string | 0, number?, number?, string?];
 
 interface FileRow {
     p: UsageProvider;
@@ -43,6 +39,8 @@ interface FileRow {
     t: RecordRow[];
     c: CodexParserState | null;
     h?: string;
+    v?: number;
+    z?: boolean;
 }
 
 interface IndexFile {
@@ -92,8 +90,11 @@ export function encodeIndex(index: UsageIndex): string {
             record.dedupeKey ?? 0,
             record.account === undefined ? 0 : accounts.index(record.account) + 1
         ];
-        if (record.costUsd !== undefined) {
-            counted.push(record.costUsd);
+        if (record.costUsd !== undefined || record.serviceTier !== undefined) {
+            counted[13] = record.costUsd;
+        }
+        if (record.serviceTier !== undefined) {
+            counted[14] = record.serviceTier;
         }
         return counted;
     };
@@ -106,7 +107,9 @@ export function encodeIndex(index: UsageIndex): string {
             c: file.codex,
             r: file.records.map(row),
             t: file.tail.map(row),
-            ...(file.head === null ? {} : { h: file.head })
+            ...(file.head === null ? {} : { h: file.head }),
+            ...(file.parserVersion === undefined ? {} : { v: file.parserVersion }),
+            ...(file.compressed === undefined ? {} : { z: file.compressed })
         };
     }
     const document: IndexFile = {
@@ -123,11 +126,12 @@ export function encodeIndex(index: UsageIndex): string {
 function isRow(row: unknown, version: number): row is RecordRow {
     return (
         Array.isArray(row) &&
-        (version === ACCOUNTLESS_VERSION ? row.length === 12 : row.length === 13 || row.length === 14) &&
+        (version === ACCOUNTLESS_VERSION ? row.length === 12 : row.length >= 13 && row.length <= (version === INDEX_VERSION ? 15 : 14)) &&
         row.slice(0, 11).every((value) => typeof value === 'number') &&
         (typeof row[11] === 'string' || row[11] === 0) &&
         (version === ACCOUNTLESS_VERSION || typeof row[12] === 'number') &&
-        (row.length < 14 || typeof row[13] === 'number')
+        (row.length < 14 || row[13] === null || row[13] === undefined || typeof row[13] === 'number') &&
+        (row.length < 15 || typeof row[14] === 'string')
     );
 }
 
@@ -145,7 +149,7 @@ export function decodeIndex(text: string): UsageIndex {
     }
     const version = document?.version;
     if (
-        (version !== INDEX_VERSION && version !== ACCOUNTLESS_VERSION) ||
+        (version !== INDEX_VERSION && version !== 2 && version !== ACCOUNTLESS_VERSION) ||
         !Array.isArray(document.models) ||
         !Array.isArray(document.sessions) ||
         !Array.isArray(document.folders)
@@ -184,7 +188,8 @@ export function decodeIndex(text: string): UsageIndex {
                     cwd,
                     ...(account === undefined ? {} : { account }),
                     totals: { calls: row[4], input: row[5], cacheRead: row[6], cacheWrite: row[7], cacheWrite1h: row[8], output: row[9], reasoning: row[10] },
-                    ...(row[13] === undefined ? {} : { costUsd: row[13] }),
+                    ...(typeof row[13] === 'number' ? { costUsd: row[13] } : {}),
+                    ...(typeof row[14] === 'string' ? { serviceTier: row[14] } : {}),
                     dedupeKey: row[11] === 0 ? null : row[11]
                 });
             }
@@ -201,7 +206,9 @@ export function decodeIndex(text: string): UsageIndex {
                 records,
                 tail,
                 codex: file.c ?? null,
-                head: typeof file.h === 'string' ? file.h : null
+                head: typeof file.h === 'string' ? file.h : null,
+                ...(typeof file.v === 'number' ? { parserVersion: file.v } : {}),
+                ...(typeof file.z === 'boolean' ? { compressed: file.z } : {})
             });
         }
     }

package/src/usage/pricing.ts

@@ -22,6 +22,7 @@ export interface ModelPrice {
     cacheRead: number;
     cacheWrite: number;
     cacheWrite1h: number;
+    tiers?: Partial<Record<string, ModelPrice>>;
 }
 
 export type PriceTable = Map<string, ModelPrice>;
@@ -40,6 +41,7 @@ const PROVIDERS = new Set(['anthropic', 'openai']);
 const MODES = new Set(['chat', 'responses']);
 
 interface LiteLlmEntry {
+    [key: string]: unknown;
     input_cost_per_token?: unknown;
     output_cost_per_token?: unknown;
     cache_read_input_token_cost?: unknown;
@@ -84,6 +86,23 @@ export function parsePriceTable(document: unknown): PriceTable {
             cacheWrite: rate(value.cache_creation_input_token_cost) ?? input * CACHE_WRITE_SHARE,
             cacheWrite1h: input * CACHE_WRITE_1H_SHARE
         };
+        const tiers: Partial<Record<string, ModelPrice>> = {};
+        for (const [tier, multiplier] of [
+            ['priority', 2],
+            ['flex', 0.5],
+            ['ultrafast', 6]
+        ] as const) {
+            tiers[tier] = {
+                input: rate(value[`input_cost_per_token_${tier}`]) ?? input * multiplier,
+                output: rate(value[`output_cost_per_token_${tier}`]) ?? output * multiplier,
+                cacheRead: rate(value[`cache_read_input_token_cost_${tier}`]) ?? price.cacheRead * multiplier,
+                cacheWrite: rate(value[`cache_creation_input_token_cost_${tier}`]) ?? price.cacheWrite * multiplier,
+                cacheWrite1h: price.cacheWrite1h * multiplier
+            };
+        }
+        if (value.litellm_provider === 'openai') {
+            price.tiers = tiers;
+        }
         const key = name.trim().toLowerCase();
         table.set(key, price);
         const bare = key.slice(key.lastIndexOf('/') + 1);
@@ -100,12 +119,25 @@ function withoutDate(key: string): string | null {
     return match === null ? null : match[1]!;
 }
 
-/*
- * Exact first, then the same name without its date, then the longest family the table knows. A name
- * nobody prices is left unpriced rather than guessed at: `$0.00` for a model that costs money is a
- * worse answer than a question mark.
- */
-export function lookupPrice(table: PriceTable, model: string): PriceLookup {
+// The internal review alias has no published price; expose ccusage's dated estimate as a family match.
+// https://github.com/ccusage/ccusage/blob/main/rust/adapters/codex/src/codex-auto-review-fallbacks.json
+const REVIEW_MODELS = [
+    ['2026-07-30', 'gpt-5.6-luna'],
+    ['2026-03-05', 'gpt-5.4'],
+    ['2026-02-05', 'gpt-5.3-codex'],
+    ['2025-12-11', 'gpt-5.2-codex'],
+    ['2025-11-13', 'gpt-5.1-codex'],
+    ['2025-09-15', 'gpt-5-codex'],
+    ['2025-08-07', 'gpt-5']
+] as const;
+
+export function lookupPrice(table: PriceTable, model: string, serviceTier?: string, timestampMs?: number): PriceLookup {
+    const found = lookupBasePrice(table, model, timestampMs);
+    const tier = serviceTier === 'fast' ? 'priority' : serviceTier;
+    return { ...found, price: (tier === undefined ? undefined : found.price?.tiers?.[tier]) ?? found.price };
+}
+
+function lookupBasePrice(table: PriceTable, model: string, timestampMs?: number): PriceLookup {
     const key = model.trim().toLowerCase().split('[')[0]!;
     const bare = key.slice(key.lastIndexOf('/') + 1);
     if (bare === '' || AMBIGUOUS.has(bare)) {
@@ -115,6 +147,12 @@ export function lookupPrice(table: PriceTable, model: string): PriceLookup {
     if (exact !== undefined) {
         return { price: exact, basis: 'exact', pricedAs: null };
     }
+    if (bare === 'codex-auto-review' && timestampMs !== undefined && Number.isFinite(timestampMs)) {
+        const date = new Date(timestampMs).toISOString().slice(0, 10);
+        const fallback = REVIEW_MODELS.find(([released]) => date >= released)?.[1] ?? 'gpt-5';
+        const found = lookupBasePrice(table, fallback);
+        return { price: found.price, basis: found.price === null ? 'unknown' : 'family', pricedAs: found.price === null ? null : fallback };
+    }
     const dated = withoutDate(bare);
     const undated = dated === null ? undefined : table.get(dated);
     if (undated !== undefined && dated !== null) {
@@ -177,8 +215,8 @@ export class PriceBook {
         return { source: this.table.size === 0 ? 'none' : this.source, fetchedAt: this.fetchedAt, models: this.table.size };
     }
 
-    look(model: string): PriceLookup {
-        return lookupPrice(this.table, model);
+    look(model: string, serviceTier?: string, timestampMs?: number): PriceLookup {
+        return lookupPrice(this.table, model, serviceTier, timestampMs);
     }
 
     /* Reads the table an earlier run stored, once; asking LiteLLM is left to `ensure`. */

package/src/usage/readers/codex.ts

@@ -1,8 +1,7 @@
 import { asObject, asString, int, type UsageRecord } from '../record.ts';
 
-/* A `token_count` line carries the counts; the other two carry the model and the directory they belong to. */
 export function codexMightCarryUsage(line: string): boolean {
-    return line.includes('token_count') || line.includes('turn_context') || line.includes('session_meta');
+    return ['token_count', 'turn_context', 'session_meta', 'thread_settings_applied', 'token_usage_record', 'compacted'].some((type) => line.includes(type));
 }
 
 /* A fork replays its ancestors' events into the new file the moment it is created, so anything this
@@ -34,6 +33,11 @@ export interface CodexParserState {
     anchorMs: number;
     /* The last counts as they were written, so a line repeated verbatim is not counted twice. */
     lastSignature: string | null;
+    serviceTier: string | null;
+    pendingCompactions: Record<string, { record: UsageRecord; counts: CodexCounts; threadTotal: CodexCounts | null }>;
+    compacted: string[];
+    handledResponses: string[];
+    latestResponse: string | null;
 }
 
 export function createCodexState(): CodexParserState {
@@ -45,12 +49,17 @@ export function createCodexState(): CodexParserState {
         sawSessionMeta: false,
         suppressing: false,
         anchorMs: 0,
-        lastSignature: null
+        lastSignature: null,
+        serviceTier: null,
+        pendingCompactions: {},
+        compacted: [],
+        handledResponses: [],
+        latestResponse: null
     };
 }
 
 export function cloneCodexState(state: CodexParserState): CodexParserState {
-    return { ...state, total: state.total === null ? null : { ...state.total } };
+    return structuredClone(state);
 }
 
 function countsOf(usage: Record<string, unknown>): CodexCounts {
@@ -87,13 +96,8 @@ export function isForkOrSubagent(payload: Record<string, unknown>): boolean {
     return typeof asObject(spawn)?.parent_thread_id === 'string';
 }
 
-/*
- * One line of `~/.codex/sessions/**\/*.jsonl`, against the state of the file it came from. Codex
- * reports a cumulative total per turn, so the call is the difference with the line before it; when
- * that difference falls the run started over and `last_token_usage` is the turn on its own. Codex
- * counts cache reads and writes inside `input_tokens`, unlike Anthropic, so what is left after
- * taking both out is the input that was actually paid for at the full rate.
- */
+/* Codex includes cache reads and writes in input_tokens. Compaction can appear separately from
+   cumulative token_count events, so response identities prevent charging the same request twice. */
 export function parseCodexLine(line: string, state: CodexParserState): UsageRecord | null {
     let parsed: unknown;
     try {
@@ -134,6 +138,18 @@ export function parseCodexLine(line: string, state: CodexParserState): UsageReco
         return null;
     }
 
+    if (payload.type === 'thread_settings_applied') {
+        const settings = asObject(payload.thread_settings);
+        if (settings !== null && typeof settings.service_tier === 'string') {
+            state.serviceTier = settings.service_tier;
+        }
+        return null;
+    }
+
+    if (record.type === 'token_usage_record' || record.type === 'compacted') {
+        return parseCompaction(record, payload, state);
+    }
+
     if (payload.type !== 'token_count') {
         return null;
     }
@@ -170,6 +186,62 @@ export function parseCodexLine(line: string, state: CodexParserState): UsageReco
         state.suppressing = false;
     }
 
+    let dedupeKey: string | null = null;
+    const pending = state.latestResponse === null ? undefined : state.pendingCompactions[state.latestResponse];
+    if (pending !== undefined && (sameCounts(pending.counts, counts) || sameCounts(pending.threadTotal, cumulative))) {
+        dedupeKey = `codex:response:${state.latestResponse}`;
+        delete state.pendingCompactions[state.latestResponse!];
+        state.handledResponses.push(state.latestResponse!);
+    }
+    return usageRecord(counts, timestampMs, state.model, state, dedupeKey);
+}
+
+function sameCounts(first: CodexCounts | null, second: CodexCounts): boolean {
+    return (
+        first !== null &&
+        first.input === second.input &&
+        first.cached === second.cached &&
+        first.cacheWrite === second.cacheWrite &&
+        first.output === second.output &&
+        first.reasoning === second.reasoning
+    );
+}
+
+function parseCompaction(record: Record<string, unknown>, payload: Record<string, unknown>, state: CodexParserState): UsageRecord | null {
+    const id = asString(record.type === 'compacted' ? payload.compaction_response_id : payload.response_id);
+    if (id === '' || state.handledResponses.includes(id)) {
+        return null;
+    }
+    if (record.type === 'compacted') {
+        if (!state.compacted.includes(id)) {
+            state.compacted.push(id);
+        }
+    } else {
+        const usage = asObject(payload.usage);
+        const model = asString(payload.model) || state.model;
+        const timestampMs = Date.parse(asString(record.timestamp));
+        if (usage === null || model === null || !Number.isFinite(timestampMs)) {
+            return null;
+        }
+        const counts = countsOf(usage);
+        const parsed = usageRecord(counts, timestampMs, model, state, `codex:response:${id}`);
+        if (parsed === null) {
+            return null;
+        }
+        state.latestResponse = id;
+        const threadTotal = asObject(payload.thread_token_usage);
+        state.pendingCompactions[id] ??= { record: parsed, counts, threadTotal: threadTotal === null ? null : countsOf(threadTotal) };
+    }
+    const pending = state.pendingCompactions[id];
+    if (!state.compacted.includes(id) || pending === undefined) {
+        return null;
+    }
+    state.handledResponses.push(id);
+    delete state.pendingCompactions[id];
+    return pending.record;
+}
+
+function usageRecord(counts: CodexCounts, timestampMs: number, model: string, state: CodexParserState, dedupeKey: string | null): UsageRecord | null {
     const uncached = Math.max(0, counts.input - counts.cached - counts.cacheWrite);
     const totals = {
         calls: 1,
@@ -186,11 +258,11 @@ export function parseCodexLine(line: string, state: CodexParserState): UsageReco
     return {
         provider: 'codex',
         timestampMs,
-        model: state.model,
+        model,
         sessionId: state.sessionId,
         cwd: state.cwd,
         totals,
-        // Fork copies are gone by here, so every event that is left is a call of its own.
-        dedupeKey: null
+        ...(state.serviceTier === null ? {} : { serviceTier: state.serviceTier }),
+        dedupeKey
     };
 }

package/src/usage/record.ts

@@ -13,6 +13,7 @@ export interface UsageRecord {
     totals: UsageTotals;
     /* What the CLI itself says the call cost, which wins over a price from the table; absent where it says nothing. */
     costUsd?: number;
+    serviceTier?: string;
     /* What identifies the message this line reports on, or null when nothing does. */
     dedupeKey: string | null;
 }

package/src/usage/scanner.ts

@@ -1,6 +1,7 @@
 import { createHash, type Hash } from 'node:crypto';
 import { mkdir, open, readFile, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
+import { zstdDecompressSync } from 'node:zlib';
 import type { UsageProvider, UsageRoot } from '@adecore/agent-contracts';
 import { errorText } from '../error-text.ts';
 import { isNotFound, writeAtomic } from '../fs.ts';
@@ -13,6 +14,7 @@ import { cloneCodexState, codexMightCarryUsage, createCodexState, parseCodexLine
 import { usageRoots, type UsageRootPath } from './roots.ts';
 
 const HASH_CHUNK_BYTES = 65536;
+const CODEX_PARSER_VERSION = 2;
 
 interface HashedRead {
     /* Everything from `from` to the end of the file, as it is at the read. */
@@ -82,7 +84,7 @@ function readsWhole(provider: UsageProvider): boolean {
 }
 
 function isUsageFile(provider: UsageProvider, name: string): boolean {
-    return readsWhole(provider) ? name === GROK_USAGE_FILE : name.endsWith('.jsonl');
+    return readsWhole(provider) ? name === GROK_USAGE_FILE : name.endsWith('.jsonl') || (provider === 'codex' && name.endsWith('.jsonl.zst'));
 }
 
 async function listUsageFiles(dir: string, provider: UsageProvider, out: string[] = []): Promise<string[]> {
@@ -255,7 +257,12 @@ export class UsageScanner {
             }
             let failure: string | null = null;
             const accountOf = accountResolver(root, sessionAccounts);
-            for (const path of await listUsageFiles(root.path, root.provider)) {
+            const paths = await listUsageFiles(root.path, root.provider);
+            const plain = new Set(paths);
+            for (const path of paths) {
+                if (root.provider === 'codex' && path.endsWith('.jsonl.zst') && plain.has(path.slice(0, -4))) {
+                    continue;
+                }
                 files += 1;
                 try {
                     if (await this.readFileInto(path, root.provider, accountOf)) {
@@ -288,15 +295,34 @@ export class UsageScanner {
 
     private async readFileInto(path: string, provider: UsageProvider, accountOf: AccountOf): Promise<boolean> {
         const info = await stat(path);
-        const known = this.index.get(path);
-        if (known !== undefined && known.provider === provider && known.size === info.size && known.mtimeMs === info.mtimeMs) {
+        const compressed = provider === 'codex' && path.endsWith('.jsonl.zst');
+        const key = compressed ? path.slice(0, -4) : path;
+        const known = this.index.get(key);
+        const currentParser = provider !== 'codex' || known?.parserVersion === CODEX_PARSER_VERSION;
+        if (
+            currentParser &&
+            known !== undefined &&
+            known.provider === provider &&
+            (known.compressed ?? false) === compressed &&
+            known.size === info.size &&
+            known.mtimeMs === info.mtimeMs
+        ) {
             return false;
         }
         if (readsWhole(provider)) {
             return this.readWholeInto(path, provider, accountOf, info);
         }
-        const appended = known !== undefined && known.provider === provider && info.size > known.size && known.head?.startsWith('sha256:') === true;
-        let read = await readHashed(path, appended ? known.offset : 0);
+        const appended =
+            !compressed &&
+            currentParser &&
+            known?.compressed !== true &&
+            known !== undefined &&
+            known.provider === provider &&
+            info.size > known.size &&
+            known.head?.startsWith('sha256:') === true;
+        let read = compressed
+            ? { bytes: zstdDecompressSync(await readFile(path)), hash: createHash('sha256') }
+            : await readHashed(path, appended ? known.offset : 0);
         // A file only counts as grown while it starts the way it did; one rewritten larger is read again from the start.
         const grown = appended && headOf(read.hash) === known.head;
         if (appended && !grown) {
@@ -315,9 +341,10 @@ export class UsageScanner {
             records: foldByKey([...before, ...withAccount(parsed.records, accountOf)]),
             tail: withAccount(parsed.tail, accountOf),
             codex: parsed.codex,
-            head: headOf(read.hash)
+            head: headOf(read.hash),
+            ...(provider === 'codex' ? { parserVersion: CODEX_PARSER_VERSION, compressed } : {})
         };
-        this.index.set(path, entry);
+        this.index.set(key, entry);
         this.dirty = true;
         return true;
     }