@adecore/agents 0.31.4 → 0.31.6

package/src/providers/acp-provider.ts

@@ -1,15 +1,16 @@
-import type { AgentKind, ModelOptionDescriptor, ProviderCapabilities, ProviderInstall } from '@adecore/agent-contracts';
+import type { AgentKind, ProviderCapabilities, ProviderInstall } from '@adecore/agent-contracts';
 import { createAcpBackend, type AcpAgentSpec, type AcpUsageReport } from '../chat/acp-backend.ts';
 import type { AcpSessionInfo } from '../chat/acp-protocol.ts';
 import { askAcpAccount } from './accounts/acp-account.ts';
+import { AcpAgentState, type AcpCatalogStore } from './acp-agent-state.ts';
 import { writeAcpUsage } from './acp-usage-log.ts';
 import type { ModelCatalog } from './catalog.ts';
 import { detectCli, type CliDetection } from './detect.ts';
 import type { ChatProvider, ProviderHome } from './provider.ts';
 
 /*
- * 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: ProviderCapabilities = {
     chat: true,
@@ -36,7 +37,7 @@ export interface AcpProviderSpec extends AcpAgentSpec {
     command: string;
     args?: readonly string[];
     catalog: ModelCatalog;
-    // Over `ACP_CAPABILITIES`, for an agent that reports its cost or context window, or whose commands fold its context.
+    // Over `ACP_CAPABILITIES` and what the agent showed it can do, for what the host knows better.
     capabilities?: Partial<ProviderCapabilities>;
     // What a terminal runs to continue one of its sessions; empty where it has none.
     resumeCommand?: string;
@@ -56,45 +57,29 @@ export interface AcpProviderSpec extends AcpAgentSpec {
     adoptModels?: boolean;
     // The folder the usage of every turn the agent reports is logged to, for a usage root of the agent's kind; absent logs nothing.
     usageLog?: string;
+    // Keeps the models the agent reported across a restart of the host; absent starts from `catalog` every time.
+    catalogStore?: AcpCatalogStore;
 }
 
 /* Agents whose own usage files the scanner reads; a log of their turns would count every one twice. */
 const OWN_USAGE_FILES: ReadonlySet<AgentKind> = 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: AcpSessionInfo): Array<{ slug: string; name: string }> {
-    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: AcpSessionInfo): ModelOptionDescriptor[] {
-    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: AcpProviderSpec): ChatProvider {
-    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: AcpSessionInfo): void => {
-        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: string[]): void => {
+        state.commandsListed(commands);
+        spec.onCommands?.(commands);
+    };
     const usageLog = spec.usageLog === undefined || OWN_USAGE_FILES.has(spec.kind) ? null : spec.usageLog;
     const onUsage =
         usageLog === null
@@ -107,7 +92,8 @@ export function createAcpProvider(spec: AcpProviderSpec): ChatProvider {
         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 }),
@@ -131,9 +117,19 @@ export function createAcpProvider(spec: AcpProviderSpec): ChatProvider {
                           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/src/providers/catalog.ts

@@ -18,6 +18,8 @@ function timeOf(data: ModelCatalogInput): number {
 export class ModelCatalog {
     private readonly shippedAt: number;
     private data: ModelCatalogInput;
+    // The sizes the host's own default had before an agent's models replaced it, for an adopted model that names none.
+    private hostWindows: ModelCatalogProfile['contextWindowTokens'] | undefined;
 
     constructor(data: ModelCatalogInput = manifest as never) {
         this.shippedAt = timeOf(data);
@@ -35,6 +37,7 @@ export class ModelCatalog {
         }
         const changed = JSON.stringify(data) !== JSON.stringify(this.data);
         this.data = data;
+        this.hostWindows = undefined;
         return changed;
     }
 
@@ -42,20 +45,31 @@ export class ModelCatalog {
      * 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: ReadonlyArray<{ slug: string; name: string }>, defaultModel: string, options: readonly ModelOptionDescriptor[] = []): boolean {
+    adopt(
+        models: ReadonlyArray<{ slug: string; name: string; contextWindow?: number }>,
+        defaultModel: string,
+        options: readonly ModelOptionDescriptor[] = []
+    ): boolean {
         if (models.length === 0 || !models.some((model) => model.slug === defaultModel)) {
             return false;
         }
         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: number | undefined): string => (window === undefined ? ADOPTED_PROFILE : `${ADOPTED_PROFILE}-${window}`);
+        const profiles: Record<string, ModelCatalogProfile> = {};
+        for (const model of models) {
+            profiles[profileName(model.contextWindow)] =
+                model.contextWindow === undefined ? profile : { ...profile, contextWindowTokens: { '*': model.contextWindow } };
+        }
         const data: ModelCatalogInput = {
             ...(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/src/providers/index.ts

@@ -1,4 +1,5 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
+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/src/providers/provider.ts

@@ -50,5 +50,7 @@ export interface ChatProvider {
     enabled?(): boolean;
     /* Asks the CLI, started in an account's environment, who is signed in there. Absent leaves the host's own reader. */
     askAccount?(command: readonly string[], env: Record<string, string | undefined>): Promise<AccountReading>;
+    /* Calls the listener whenever the models or the capabilities changed, for a provider that learns them from its CLI; answers how to stop. */
+    onChange?(listener: () => void): () => void;
     createBackend(launch: BackendLaunch, host: BackendHost): ChatBackend;
 }

package/src/providers/registry.ts

@@ -128,6 +128,16 @@ export class ProviderRegistry {
         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: (kind: AgentKind) => void): () => void {
+        const stops = this.providers.flatMap((provider) => (provider.onChange ? [provider.onChange(() => listener(provider.kind))] : []));
+        return () => {
+            for (const stop of stops) {
+                stop();
+            }
+        };
+    }
+
     invalidate(kind: AgentKind): void {
         this.cache.delete(kind);
     }

package/src/testing/fake-acp.ts

@@ -27,6 +27,12 @@ export interface FakeAcpOptions {
     // Offers a reasoning effort as the config option `reasoning_effort`, without a category: Low and High, and
     // Extra high on `fake-large`. `reject` refuses every change to it.
     reasoningEffort?: 'accept' | 'reject';
+    // Names each model's context window in its `_meta` (`totalContextTokens`): 128000 for `fake-small`, 1000000 for `fake-large`.
+    contextWindows?: boolean;
+    // The slash commands a new session lists, sent before the answer that names the session.
+    commands?: readonly string[];
+    // Advertises `promptCapabilities.embeddedContext`, so a prompt may carry files as `resource` blocks.
+    embeddedContext?: boolean;
 }
 
 export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
@@ -74,9 +80,10 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
         };
 
         const sessionState = (): Frame => {
+            const meta = (totalContextTokens: number): Frame => (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' },
@@ -90,7 +97,7 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
             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 },
@@ -233,7 +240,7 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
                         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' }],
@@ -251,6 +258,12 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
                     }
                     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/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;
 }