@adecore/agents 0.31.4 → 0.31.6

package/dist/providers/acp-provider.js

@@ -1,10 +1,11 @@
 import { createAcpBackend } from '../chat/acp-backend.js';
 import { askAcpAccount } from './accounts/acp-account.js';
+import { AcpAgentState } from './acp-agent-state.js';
 import { writeAcpUsage } from './acp-usage-log.js';
 import { detectCli } from './detect.js';
 /*
- * What every ACP agent can do through this backend. A file change comes as the text before and after;
- * a message names its mentions and attachments by path, as text the agent opens with its own tools.
+ * What every ACP agent can do through this backend, before what it shows of itself. A file change comes as the text
+ * before and after; a message names its mentions and attachments by path, and carries the files themselves where the agent takes them.
  */
 export const ACP_CAPABILITIES = {
     chat: true,
@@ -25,38 +26,22 @@ export const ACP_CAPABILITIES = {
 };
 /* Agents whose own usage files the scanner reads; a log of their turns would count every one twice. */
 const OWN_USAGE_FILES = new Set(['grok']);
-/* An agent's model id may reach a command line, so one that reads as a flag is left out. */
-function adoptableModels(info) {
-    return (info.models?.models ?? []).filter((model) => model.id !== '' && !model.id.startsWith('-')).map((model) => ({ slug: model.id, name: model.name }));
-}
-/* The reasoning effort a session offers, as the `effort` option the composer draws for every provider. */
-function effortOption(info) {
-    const level = info.thoughtLevel;
-    if (level === null || !level.choices.some((choice) => choice.id === level.current)) {
-        return [];
-    }
-    return [
-        {
-            id: 'effort',
-            label: 'Reasoning',
-            type: 'select',
-            defaultChoice: level.current,
-            choices: level.choices.map((choice) => ({
-                id: choice.id,
-                label: choice.name,
-                ...(choice.description === null ? {} : { description: choice.description })
-            }))
-        }
-    ];
-}
 export function createAcpProvider(spec) {
-    const capabilities = { ...ACP_CAPABILITIES, ...spec.capabilities };
+    const state = new AcpAgentState({
+        catalog: spec.catalog,
+        adoptModels: spec.adoptModels !== false,
+        store: spec.catalogStore ?? null,
+        base: ACP_CAPABILITIES,
+        overrides: spec.capabilities ?? {}
+    });
     const onSession = (info) => {
-        if (spec.adoptModels !== false && info.models !== null) {
-            spec.catalog.adopt(adoptableModels(info), info.models.current, effortOption(info));
-        }
+        state.session(info);
         spec.onSession?.(info);
     };
+    const onCommands = (commands) => {
+        state.commandsListed(commands);
+        spec.onCommands?.(commands);
+    };
     const usageLog = spec.usageLog === undefined || OWN_USAGE_FILES.has(spec.kind) ? null : spec.usageLog;
     const onUsage = usageLog === null
         ? spec.onUsage
@@ -68,7 +53,8 @@ export function createAcpProvider(spec) {
         kind: spec.kind,
         name: spec.name,
         catalog: spec.catalog,
-        capabilities,
+        capabilities: state.capabilities,
+        onChange: (listener) => state.onChange(listener),
         command: [spec.command, ...(spec.args ?? [])],
         resumeCommand: spec.resumeCommand ?? '',
         ...(spec.ignoresProjectConfig === undefined ? {} : { ignoresProjectConfig: spec.ignoresProjectConfig }),
@@ -90,9 +76,19 @@ export function createAcpProvider(spec) {
                     command,
                     env: { ...env, ...spec.env },
                     ...(spec.client ? { client: spec.client } : {}),
-                    onSession
+                    onSession,
+                    onCommands
                 })
             }),
-        createBackend: createAcpBackend({ ...spec, onSession, ...(onUsage === undefined ? {} : { onUsage }) })
+        createBackend: createAcpBackend({
+            ...spec,
+            onSession,
+            onCommands,
+            onContextReport: () => {
+                state.contextReported();
+                spec.onContextReport?.();
+            },
+            ...(onUsage === undefined ? {} : { onUsage })
+        })
     };
 }

package/dist/providers/catalog.d.ts

@@ -5,12 +5,14 @@ export type ModelCatalogInput = Omit<ModelCatalogData, 'updatedAt'> & {
 export declare class ModelCatalog {
     private readonly shippedAt;
     private data;
+    private hostWindows;
     constructor(data?: ModelCatalogInput);
     get defaultModel(): string;
     replace(data: ModelCatalogData): boolean;
     adopt(models: ReadonlyArray<{
         slug: string;
         name: string;
+        contextWindow?: number;
     }>, defaultModel: string, options?: readonly ModelOptionDescriptor[]): boolean;
     list(): ModelInfo[];
     nameOf(slug: string): string;

package/dist/providers/catalog.js

@@ -11,6 +11,8 @@ function timeOf(data) {
 export class ModelCatalog {
     shippedAt;
     data;
+    // The sizes the host's own default had before an agent's models replaced it, for an adopted model that names none.
+    hostWindows;
     constructor(data = manifest) {
         this.shippedAt = timeOf(data);
         this.data = data;
@@ -25,13 +27,14 @@ export class ModelCatalog {
         }
         const changed = JSON.stringify(data) !== JSON.stringify(this.data);
         this.data = data;
+        this.hostWindows = undefined;
         return changed;
     }
     /*
      * Takes the models an agent reported for itself in place of the list, the agent's current model as the
      * default and its order kept; answers whether the models changed. Every model gets the profile the
      * default has now, as an agent names its models but not what each can be asked for, with `options`
-     * in place of the profile's options of the same id.
+     * in place of the profile's options of the same id, and the context window in tokens a model names as its only size.
      */
     adopt(models, defaultModel, options = []) {
         if (models.length === 0 || !models.some((model) => model.slug === defaultModel)) {
@@ -39,12 +42,19 @@ export class ModelCatalog {
         }
         const base = this.profileOf(this.data.defaultModel) ?? { options: [], contextWindowTokens: {} };
         const replaced = new Set(options.map((option) => option.id));
-        const profile = { ...base, options: [...base.options.filter((option) => !replaced.has(option.id)), ...options] };
+        this.hostWindows ??= base.contextWindowTokens;
+        const profile = { ...base, contextWindowTokens: this.hostWindows, options: [...base.options.filter((option) => !replaced.has(option.id)), ...options] };
+        const profileName = (window) => (window === undefined ? ADOPTED_PROFILE : `${ADOPTED_PROFILE}-${window}`);
+        const profiles = {};
+        for (const model of models) {
+            profiles[profileName(model.contextWindow)] =
+                model.contextWindow === undefined ? profile : { ...profile, contextWindowTokens: { '*': model.contextWindow } };
+        }
         const data = {
             ...(this.data.updatedAt === undefined ? {} : { updatedAt: this.data.updatedAt }),
             defaultModel,
-            profiles: { [ADOPTED_PROFILE]: profile },
-            models: models.map((model) => ({ slug: model.slug, name: model.name, profile: ADOPTED_PROFILE }))
+            profiles,
+            models: models.map((model) => ({ slug: model.slug, name: model.name, profile: profileName(model.contextWindow) }))
         };
         const changed = JSON.stringify(data) !== JSON.stringify(this.data);
         this.data = data;

package/dist/providers/index.d.ts

@@ -1,3 +1,4 @@
+export { type AcpCatalogStore } from './acp-agent-state.ts';
 export { ACP_CAPABILITIES, type AcpProviderSpec, createAcpProvider } from './acp-provider.ts';
 export { type AcpAccountProbe, askAcpAccount, type ProbeTimer } from './accounts/acp-account.ts';
 export { AccountError, type AccountLaunches, storedAccount, launchEnv } from './accounts/launch.ts';

package/dist/providers/index.js

@@ -1,4 +1,5 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
+export {} from './acp-agent-state.js';
 export { ACP_CAPABILITIES, createAcpProvider } from './acp-provider.js';
 export { askAcpAccount } from './accounts/acp-account.js';
 export { AccountError, storedAccount, launchEnv } from './accounts/launch.js';

package/dist/providers/provider.d.ts

@@ -25,5 +25,6 @@ export interface ChatProvider {
     detect(command: string, env: Record<string, string | undefined>): Promise<CliDetection>;
     enabled?(): boolean;
     askAccount?(command: readonly string[], env: Record<string, string | undefined>): Promise<AccountReading>;
+    onChange?(listener: () => void): () => void;
     createBackend(launch: BackendLaunch, host: BackendHost): ChatBackend;
 }

package/dist/providers/registry.d.ts

@@ -23,6 +23,7 @@ export declare class ProviderRegistry {
     oneShotProvider(preferred?: AgentKind): Promise<ChatProvider | null>;
     catalogFor(kind: AgentKind): ModelCatalog;
     enabled(kind: AgentKind): boolean;
+    onChange(listener: (kind: AgentKind) => void): () => void;
     invalidate(kind: AgentKind): void;
     protected fallback(kind: AgentKind): ChatProvider;
     private detection;

package/dist/providers/registry.js

@@ -97,6 +97,15 @@ export class ProviderRegistry {
     enabled(kind) {
         return this.get(kind).enabled?.() !== false;
     }
+    /* Calls the listener with the kind of every provider whose models or capabilities changed, so a host can list them again; answers how to stop. */
+    onChange(listener) {
+        const stops = this.providers.flatMap((provider) => (provider.onChange ? [provider.onChange(() => listener(provider.kind))] : []));
+        return () => {
+            for (const stop of stops) {
+                stop();
+            }
+        };
+    }
     invalidate(kind) {
         this.cache.delete(kind);
     }

package/dist/testing/fake-acp.d.ts

@@ -8,6 +8,9 @@ export interface FakeAcpOptions {
     closeSession?: boolean;
     turnUsage?: Record<string, number>;
     reasoningEffort?: 'accept' | 'reject';
+    contextWindows?: boolean;
+    commands?: readonly string[];
+    embeddedContext?: boolean;
 }
 export declare function fakeAcpWith(options: FakeAcpOptions): FakeCli;
 export declare const fakeAcp: FakeCli;

package/dist/testing/fake-acp.js

@@ -38,9 +38,10 @@ export function fakeAcpWith(options) {
             prompt = null;
         };
         const sessionState = () => {
+            const meta = (totalContextTokens) => (options.contextWindows ? { _meta: { totalContextTokens } } : {});
             const modelChoices = [
-                { value: 'fake-small', name: 'Fake small' },
-                { value: 'fake-large', name: 'Fake large' }
+                { value: 'fake-small', name: 'Fake small', ...meta(128000) },
+                { value: 'fake-large', name: 'Fake large', ...meta(1000000) }
             ];
             const effortChoices = [
                 { value: 'low', name: 'Low', description: 'Answers quickly' },
@@ -53,7 +54,7 @@ export function fakeAcpWith(options) {
             return {
                 ...(modes.length === 0 ? {} : { modes: { currentModeId: mode, availableModes: modes.map((id) => ({ id, name: id })) } }),
                 ...(options.legacyModels
-                    ? { models: { currentModelId: model, availableModels: modelChoices.map((choice) => ({ modelId: choice.value, name: choice.name })) } }
+                    ? { models: { currentModelId: model, availableModels: modelChoices.map(({ value, ...choice }) => ({ modelId: value, ...choice })) } }
                     : {
                         configOptions: [
                             { id: 'model', name: 'Model', type: 'select', category: 'model', currentValue: model, options: modelChoices },
@@ -193,7 +194,7 @@ export function fakeAcpWith(options) {
                         protocolVersion: 1,
                         agentCapabilities: {
                             loadSession: options.loadSession ?? true,
-                            promptCapabilities: { image: true, audio: false, embeddedContext: false },
+                            promptCapabilities: { image: true, audio: false, embeddedContext: options.embeddedContext === true },
                             sessionCapabilities: { ...(options.resumeSession ? { resume: {} } : {}), ...(options.closeSession ? { close: {} } : {}) }
                         },
                         authMethods: options.authMethod === undefined ? [] : [{ id: options.authMethod, name: 'Sign in' }],
@@ -211,6 +212,12 @@ export function fakeAcpWith(options) {
                     }
                     sessionId = `fake-session-${Math.random().toString(36).slice(2, 8)}`;
                     sessionHistory.set(sessionId, []);
+                    if (options.commands !== undefined) {
+                        update({
+                            sessionUpdate: 'available_commands_update',
+                            availableCommands: options.commands.map((name) => ({ name, description: name }))
+                        });
+                    }
                     respond(id, { sessionId, ...sessionState() });
                     return;
                 case 'session/load':

package/dist/usage/aggregate.js

@@ -111,7 +111,7 @@ export async function aggregate(records, payload, prices, known) {
         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/dist/usage/index-file.d.ts

@@ -10,6 +10,8 @@ export interface IndexedFile {
     tail: UsageRecord[];
     codex: CodexParserState | null;
     head: string | null;
+    parserVersion?: number;
+    compressed?: boolean;
 }
 export type UsageIndex = Map<string, IndexedFile>;
 export declare function encodeIndex(index: UsageIndex): string;

package/dist/usage/index-file.js

@@ -1,6 +1,6 @@
 import { UsageProviderSchema } from '@adecore/agent-contracts';
-/* 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;
 class Interner {
@@ -39,8 +39,11 @@ export function encodeIndex(index) {
             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;
     };
@@ -53,7 +56,9 @@ export function encodeIndex(index) {
             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 = {
@@ -68,11 +73,12 @@ export function encodeIndex(index) {
 }
 function isRow(row, version) {
     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'));
 }
 /*
  * A row that does not read back costs a cold parse of the file it belonged to, never a wrong total,
@@ -88,7 +94,7 @@ export function decodeIndex(text) {
         return index;
     }
     const version = document?.version;
-    if ((version !== INDEX_VERSION && version !== ACCOUNTLESS_VERSION) ||
+    if ((version !== INDEX_VERSION && version !== 2 && version !== ACCOUNTLESS_VERSION) ||
         !Array.isArray(document.models) ||
         !Array.isArray(document.sessions) ||
         !Array.isArray(document.folders)) {
@@ -126,7 +132,8 @@ export function decodeIndex(text) {
                     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]
                 });
             }
@@ -143,7 +150,9 @@ export function decodeIndex(text) {
                 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/dist/usage/pricing.d.ts

@@ -6,6 +6,7 @@ export interface ModelPrice {
     cacheRead: number;
     cacheWrite: number;
     cacheWrite1h: number;
+    tiers?: Partial<Record<string, ModelPrice>>;
 }
 export type PriceTable = Map<string, ModelPrice>;
 export interface PriceLookup {
@@ -14,7 +15,7 @@ export interface PriceLookup {
     pricedAs: string | null;
 }
 export declare function parsePriceTable(document: unknown): PriceTable;
-export declare function lookupPrice(table: PriceTable, model: string): PriceLookup;
+export declare function lookupPrice(table: PriceTable, model: string, serviceTier?: string, timestampMs?: number): PriceLookup;
 export declare function costOf(totals: UsageTotals, price: ModelPrice): number;
 export declare function cacheSavingsOf(totals: UsageTotals, price: ModelPrice): number;
 export declare class PriceBook {
@@ -27,7 +28,7 @@ export declare class PriceBook {
     private inFlight;
     constructor(home: string, allowFetch?: boolean);
     get pricing(): UsagePricing;
-    look(model: string): PriceLookup;
+    look(model: string, serviceTier?: string, timestampMs?: number): PriceLookup;
     load(): Promise<void>;
     ensure(): Promise<boolean>;
     private get file();

package/dist/usage/pricing.js

@@ -50,6 +50,23 @@ export function parsePriceTable(document) {
             cacheWrite: rate(value.cache_creation_input_token_cost) ?? input * CACHE_WRITE_SHARE,
             cacheWrite1h: input * CACHE_WRITE_1H_SHARE
         };
+        const tiers = {};
+        for (const [tier, multiplier] of [
+            ['priority', 2],
+            ['flex', 0.5],
+            ['ultrafast', 6]
+        ]) {
+            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);
@@ -64,12 +81,23 @@ function withoutDate(key) {
     const match = /^(.*)-\d{6,8}$/.exec(key);
     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, model) {
+// 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']
+];
+export function lookupPrice(table, model, serviceTier, timestampMs) {
+    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, model, timestampMs) {
     const key = model.trim().toLowerCase().split('[')[0];
     const bare = key.slice(key.lastIndexOf('/') + 1);
     if (bare === '' || AMBIGUOUS.has(bare)) {
@@ -79,6 +107,12 @@ export function lookupPrice(table, model) {
     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) {
@@ -128,8 +162,8 @@ export class PriceBook {
     get pricing() {
         return { source: this.table.size === 0 ? 'none' : this.source, fetchedAt: this.fetchedAt, models: this.table.size };
     }
-    look(model) {
-        return lookupPrice(this.table, model);
+    look(model, serviceTier, timestampMs) {
+        return lookupPrice(this.table, model, serviceTier, timestampMs);
     }
     /* Reads the table an earlier run stored, once; asking LiteLLM is left to `ensure`. */
     load() {

package/dist/usage/readers/codex.d.ts

@@ -16,6 +16,15 @@ export interface CodexParserState {
     suppressing: boolean;
     anchorMs: number;
     lastSignature: string | null;
+    serviceTier: string | null;
+    pendingCompactions: Record<string, {
+        record: UsageRecord;
+        counts: CodexCounts;
+        threadTotal: CodexCounts | null;
+    }>;
+    compacted: string[];
+    handledResponses: string[];
+    latestResponse: string | null;
 }
 export declare function createCodexState(): CodexParserState;
 export declare function cloneCodexState(state: CodexParserState): CodexParserState;

package/dist/usage/readers/codex.js

@@ -1,7 +1,6 @@
 import { asObject, asString, int } from '../record.js';
-/* A `token_count` line carries the counts; the other two carry the model and the directory they belong to. */
 export function codexMightCarryUsage(line) {
-    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
    close to the file's own start is a copy of work that was already counted somewhere else. */
@@ -15,11 +14,16 @@ export function createCodexState() {
         sawSessionMeta: false,
         suppressing: false,
         anchorMs: 0,
-        lastSignature: null
+        lastSignature: null,
+        serviceTier: null,
+        pendingCompactions: {},
+        compacted: [],
+        handledResponses: [],
+        latestResponse: null
     };
 }
 export function cloneCodexState(state) {
-    return { ...state, total: state.total === null ? null : { ...state.total } };
+    return structuredClone(state);
 }
 function countsOf(usage) {
     return {
@@ -52,13 +56,8 @@ export function isForkOrSubagent(payload) {
     const spawn = asObject(asObject(payload.source)?.subagent)?.thread_spawn;
     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, state) {
     let parsed;
     try {
@@ -97,6 +96,16 @@ export function parseCodexLine(line, state) {
         }
         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;
     }
@@ -129,6 +138,58 @@ export function parseCodexLine(line, state) {
         // The first event that is not part of the replayed burst is this thread's own work.
         state.suppressing = false;
     }
+    let dedupeKey = 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, second) {
+    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, payload, state) {
+    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, timestampMs, model, state, dedupeKey) {
     const uncached = Math.max(0, counts.input - counts.cached - counts.cacheWrite);
     const totals = {
         calls: 1,
@@ -145,11 +206,11 @@ export function parseCodexLine(line, state) {
     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/dist/usage/record.d.ts

@@ -8,6 +8,7 @@ export interface UsageRecord {
     account?: string;
     totals: UsageTotals;
     costUsd?: number;
+    serviceTier?: string;
     dedupeKey: string | null;
 }
 export declare function int(value: unknown): number;