@adecore/agents 0.41.0 → 0.42.0

package/dist/providers/grok-models.json

@@ -1,5 +1,5 @@
 {
-  "updatedAt": "2026-10-27T12:00:00Z",
+  "updatedAt": "2026-10-27T14:38:15.597Z",
   "defaultModel": "default",
   "profiles": {
     "agent": { "options": [], "contextWindowTokens": {} },
@@ -9,7 +9,7 @@
     { "slug": "default", "name": "Default", "profile": "agent" },
     { "slug": "grok-4.7", "name": "Grok 4.7", "profile": "agent" },
     { "slug": "grok-4.7-build-fast", "name": "Grok 4.7 Build Fast", "profile": "agent" },
-    { "slug": "grok-4.6", "name": "Grok 4.6", "profile": "agent-256k" },
-    { "slug": "grok-4.5", "name": "Grok 4.5", "profile": "agent-256k" }
+    { "slug": "grok-4.6", "name": "Grok 4.6", "profile": "agent-256k", "legacy": true },
+    { "slug": "grok-4.5", "name": "Grok 4.5", "profile": "agent-256k", "legacy": true }
   ]
 }

package/dist/usage/history-file.d.ts

@@ -0,0 +1,25 @@
+import { type UsageProvider } from '@adecore/agent-contracts';
+import { type UsageRecord } from './record.ts';
+export interface FileUsage {
+    provider: UsageProvider;
+    records: UsageRecord[];
+    tail: UsageRecord[];
+}
+export interface HistoryEntry {
+    path: string;
+    op: 'set' | 'add';
+    usage: FileUsage;
+}
+export interface HistoryHeader {
+    gen: string;
+    base: number;
+}
+export declare function encodeHeader(header: HistoryHeader): string;
+export declare function encodeEntry(entry: HistoryEntry): string;
+export declare function applyEntry(usage: Map<string, FileUsage>, entry: HistoryEntry): void;
+export interface DecodedHistory {
+    header: HistoryHeader | null;
+    usage: Map<string, FileUsage>;
+    complete: number;
+}
+export declare function decodeHistory(bytes: Uint8Array): DecodedHistory;

package/dist/usage/history-file.js

@@ -0,0 +1,72 @@
+import { UsageProviderSchema } from '@adecore/agent-contracts';
+import { foldByKey } from './record.js';
+import { CURRENT_ROW, decodeRows, RowWriter } from './rows.js';
+const HISTORY_VERSION = 1;
+const NEWLINE = 0x0a;
+export function encodeHeader(header) {
+    return `${JSON.stringify({ v: HISTORY_VERSION, gen: header.gen, base: header.base })}\n`;
+}
+export function encodeEntry(entry) {
+    const writer = new RowWriter();
+    const rows = entry.usage.records.map((record) => writer.row(record));
+    const tail = entry.usage.tail.map((record) => writer.row(record));
+    const { models, sessions, folders, accounts } = writer.tables;
+    const line = { p: entry.path, k: entry.usage.provider, op: entry.op, m: models, s: sessions, f: folders, a: accounts, r: rows, t: tail };
+    return `${JSON.stringify(line)}\n`;
+}
+function parseLine(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function decodeHeader(text) {
+    const header = parseLine(text);
+    if (header?.v !== HISTORY_VERSION || typeof header.gen !== 'string' || typeof header.base !== 'number') {
+        return null;
+    }
+    return { gen: header.gen, base: header.base };
+}
+function decodeEntry(text) {
+    const line = parseLine(text);
+    if (typeof line?.p !== 'string' || (line.op !== 'set' && line.op !== 'add') || !UsageProviderSchema.safeParse(line.k).success) {
+        return null;
+    }
+    const provider = line.k;
+    const tables = { models: line.m, sessions: line.s, folders: line.f, accounts: line.a };
+    const records = decodeRows(line.r, tables, provider, CURRENT_ROW);
+    const tail = decodeRows(line.t, tables, provider, CURRENT_ROW);
+    if (records === null || tail === null) {
+        return null;
+    }
+    return { path: line.p, op: line.op, usage: { provider, records, tail } };
+}
+/* Folds one line into what every path counted. */
+export function applyEntry(usage, entry) {
+    const known = usage.get(entry.path);
+    if (entry.op === 'set' || known === undefined || known.provider !== entry.usage.provider) {
+        usage.set(entry.path, entry.usage);
+        return;
+    }
+    usage.set(entry.path, { provider: known.provider, records: foldByKey([...known.records, ...entry.usage.records]), tail: entry.usage.tail });
+}
+/*
+ * Every line stands alone, so a line that does not read back costs only that line. Only the end can
+ * be half-written, since lines are only ever appended.
+ */
+export function decodeHistory(bytes) {
+    const buffer = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const complete = buffer.lastIndexOf(NEWLINE) + 1;
+    const lines = buffer.toString('utf8', 0, complete).split('\n');
+    const usage = new Map();
+    const header = complete === 0 ? null : decodeHeader(lines[0]);
+    for (let i = header === null ? 0 : 1; i < lines.length; i++) {
+        const entry = lines[i] === '' ? null : decodeEntry(lines[i]);
+        if (entry !== null) {
+            applyEntry(usage, entry);
+        }
+    }
+    return { header, usage, complete };
+}

package/dist/usage/index-file.d.ts

@@ -15,4 +15,4 @@ export interface IndexedFile {
 }
 export type UsageIndex = Map<string, IndexedFile>;
 export declare function encodeIndex(index: UsageIndex): string;
-export declare function decodeIndex(text: string): UsageIndex;
+export declare function decodeIndex(text: string): UsageIndex | null;

package/dist/usage/index-file.js

@@ -1,52 +1,15 @@
 import { UsageProviderSchema } from '@adecore/agent-contracts';
-/* Old records survive deleted transcripts; the scanner reparses existing Codex files with its current reader. */
+import { CURRENT_ROW, decodeRows, RowWriter } from './rows.js';
+/*
+ * The single index usage was kept in before history and scan state went apart. The store reads it
+ * once to migrate it; nothing writes it any more but the tests that need one to migrate.
+ */
 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 {
-    values = [];
-    at = new Map();
-    index(value) {
-        const seen = this.at.get(value);
-        if (seen !== undefined) {
-            return seen;
-        }
-        const next = this.values.length;
-        this.values.push(value);
-        this.at.set(value, next);
-        return next;
-    }
-}
 export function encodeIndex(index) {
-    const models = new Interner();
-    const sessions = new Interner();
-    const folders = new Interner();
-    const accounts = new Interner();
+    const writer = new RowWriter();
     const files = {};
-    const row = (record) => {
-        const counted = [
-            record.timestampMs,
-            models.index(record.model),
-            sessions.index(record.sessionId),
-            folders.index(record.cwd),
-            record.totals.calls,
-            record.totals.input,
-            record.totals.cacheRead,
-            record.totals.cacheWrite,
-            record.totals.cacheWrite1h,
-            record.totals.output,
-            record.totals.reasoning,
-            record.dedupeKey ?? 0,
-            record.account === undefined ? 0 : accounts.index(record.account) + 1
-        ];
-        if (record.costUsd !== undefined || record.serviceTier !== undefined) {
-            counted[13] = record.costUsd;
-        }
-        if (record.serviceTier !== undefined) {
-            counted[14] = record.serviceTier;
-        }
-        return counted;
-    };
     for (const [path, file] of index) {
         files[path] = {
             p: file.provider,
@@ -54,107 +17,63 @@ export function encodeIndex(index) {
             m: file.mtimeMs,
             o: file.offset,
             c: file.codex,
-            r: file.records.map(row),
-            t: file.tail.map(row),
+            r: file.records.map((record) => writer.row(record)),
+            t: file.tail.map((record) => writer.row(record)),
             ...(file.head === null ? {} : { h: file.head }),
             ...(file.parserVersion === undefined ? {} : { v: file.parserVersion }),
             ...(file.compressed === undefined ? {} : { z: file.compressed })
         };
     }
-    const document = {
-        version: INDEX_VERSION,
-        models: models.values,
-        sessions: sessions.values,
-        folders: folders.values,
-        accounts: accounts.values,
-        files
-    };
+    const document = { version: INDEX_VERSION, ...writer.tables, files };
     return JSON.stringify(document);
 }
-function isRow(row, version) {
-    return (Array.isArray(row) &&
-        (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 || 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,
- * so anything unexpected drops that file's entry rather than being repaired.
+ * Null for text that is no index of a version this reads. A file whose rows do not read back is left
+ * out, so only that file's usage is missing from what migrates, never a wrong total.
  */
 export function decodeIndex(text) {
-    const index = new Map();
     let document;
     try {
         document = JSON.parse(text);
     }
     catch {
-        return index;
+        return null;
     }
     const version = document?.version;
     if ((version !== INDEX_VERSION && version !== 2 && version !== ACCOUNTLESS_VERSION) ||
         !Array.isArray(document.models) ||
         !Array.isArray(document.sessions) ||
         !Array.isArray(document.folders)) {
-        return index;
+        return null;
     }
-    const accounts = Array.isArray(document.accounts) ? document.accounts : [];
-    const name = (table, at) => (typeof table[at] === 'string' ? table[at] : null);
+    const index = new Map();
+    const tables = { ...document, accounts: Array.isArray(document.accounts) ? document.accounts : [] };
+    const shape = { accountless: version === ACCOUNTLESS_VERSION, maxLength: version === INDEX_VERSION ? CURRENT_ROW.maxLength : 14 };
     for (const [path, file] of Object.entries(document.files ?? {})) {
         // Every provider the schema knows, so a new one is never dropped from the index it was saved in.
         if (!UsageProviderSchema.safeParse(file.p).success) {
             continue;
         }
-        if (typeof file.s !== 'number' || typeof file.m !== 'number' || typeof file.o !== 'number' || file.o < 0 || !Array.isArray(file.r)) {
+        if (typeof file.s !== 'number' || typeof file.m !== 'number' || typeof file.o !== 'number' || file.o < 0) {
             continue;
         }
-        let broken = false;
-        const decode = (rows) => {
-            const records = [];
-            for (const row of rows) {
-                const valid = isRow(row, version);
-                const model = valid ? name(document.models, row[1]) : null;
-                const sessionId = valid ? name(document.sessions, row[2]) : null;
-                const cwd = valid ? name(document.folders, row[3]) : null;
-                const accountAt = valid ? (row[12] ?? 0) : 0;
-                const account = accountAt === 0 ? undefined : name(accounts, accountAt - 1);
-                if (!valid || model === null || sessionId === null || cwd === null || account === null) {
-                    broken = true;
-                    return records;
-                }
-                records.push({
-                    provider: file.p,
-                    timestampMs: row[0],
-                    model,
-                    sessionId,
-                    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] },
-                    ...(typeof row[13] === 'number' ? { costUsd: row[13] } : {}),
-                    ...(typeof row[14] === 'string' ? { serviceTier: row[14] } : {}),
-                    dedupeKey: row[11] === 0 ? null : row[11]
-                });
-            }
-            return records;
-        };
-        const records = decode(file.r);
-        const tail = decode(Array.isArray(file.t) ? file.t : []);
-        if (!broken) {
-            index.set(path, {
-                provider: file.p,
-                size: file.s,
-                mtimeMs: file.m,
-                offset: file.o,
-                records,
-                tail,
-                codex: file.c ?? null,
-                head: typeof file.h === 'string' ? file.h : null,
-                ...(typeof file.v === 'number' ? { parserVersion: file.v } : {}),
-                ...(typeof file.z === 'boolean' ? { compressed: file.z } : {})
-            });
+        const records = decodeRows(file.r, tables, file.p, shape);
+        const tail = decodeRows(Array.isArray(file.t) ? file.t : [], tables, file.p, shape);
+        if (records === null || tail === null) {
+            continue;
         }
+        index.set(path, {
+            provider: file.p,
+            size: file.s,
+            mtimeMs: file.m,
+            offset: file.o,
+            records,
+            tail,
+            codex: file.c ?? null,
+            head: typeof file.h === 'string' ? file.h : null,
+            ...(typeof file.v === 'number' ? { parserVersion: file.v } : {}),
+            ...(typeof file.z === 'boolean' ? { compressed: file.z } : {})
+        });
     }
     return index;
 }

package/dist/usage/rows.d.ts

@@ -0,0 +1,23 @@
+import type { UsageProvider } from '@adecore/agent-contracts';
+import type { UsageRecord } from './record.ts';
+export type RecordRow = [number, number, number, number, number, number, number, number, number, number, number, string | 0, number?, number?, string?];
+export interface RowTables {
+    models: string[];
+    sessions: string[];
+    folders: string[];
+    accounts: string[];
+}
+export declare class RowWriter {
+    private readonly models;
+    private readonly sessions;
+    private readonly folders;
+    private readonly accounts;
+    get tables(): RowTables;
+    row(record: UsageRecord): RecordRow;
+}
+export interface RowShape {
+    accountless: boolean;
+    maxLength: number;
+}
+export declare const CURRENT_ROW: RowShape;
+export declare function decodeRows(rows: unknown, tables: Partial<Record<keyof RowTables, unknown>>, provider: UsageProvider, shape: RowShape): UsageRecord[] | null;

package/dist/usage/rows.js

@@ -0,0 +1,94 @@
+class Interner {
+    values = [];
+    at = new Map();
+    index(value) {
+        const seen = this.at.get(value);
+        if (seen !== undefined) {
+            return seen;
+        }
+        const next = this.values.length;
+        this.values.push(value);
+        this.at.set(value, next);
+        return next;
+    }
+}
+/* Turns records into rows, collecting the names they share into one set of tables. */
+export class RowWriter {
+    models = new Interner();
+    sessions = new Interner();
+    folders = new Interner();
+    accounts = new Interner();
+    get tables() {
+        return { models: this.models.values, sessions: this.sessions.values, folders: this.folders.values, accounts: this.accounts.values };
+    }
+    row(record) {
+        const counted = [
+            record.timestampMs,
+            this.models.index(record.model),
+            this.sessions.index(record.sessionId),
+            this.folders.index(record.cwd),
+            record.totals.calls,
+            record.totals.input,
+            record.totals.cacheRead,
+            record.totals.cacheWrite,
+            record.totals.cacheWrite1h,
+            record.totals.output,
+            record.totals.reasoning,
+            record.dedupeKey ?? 0,
+            record.account === undefined ? 0 : this.accounts.index(record.account) + 1
+        ];
+        if (record.costUsd !== undefined || record.serviceTier !== undefined) {
+            counted[13] = record.costUsd;
+        }
+        if (record.serviceTier !== undefined) {
+            counted[14] = record.serviceTier;
+        }
+        return counted;
+    }
+}
+export const CURRENT_ROW = { accountless: false, maxLength: 15 };
+function isRow(row, shape) {
+    return (Array.isArray(row) &&
+        (shape.accountless ? row.length === 12 : row.length >= 13 && row.length <= shape.maxLength) &&
+        row.slice(0, 11).every((value) => typeof value === 'number') &&
+        (typeof row[11] === 'string' || row[11] === 0) &&
+        (shape.accountless || typeof row[12] === 'number') &&
+        (row.length < 14 || row[13] === null || row[13] === undefined || typeof row[13] === 'number') &&
+        (row.length < 15 || typeof row[14] === 'string'));
+}
+function nameAt(table, at) {
+    return Array.isArray(table) && typeof table[at] === 'string' ? table[at] : null;
+}
+/* The records of `rows`, or null when any row does not read back against its tables. */
+export function decodeRows(rows, tables, provider, shape) {
+    if (!Array.isArray(rows)) {
+        return null;
+    }
+    const records = [];
+    for (const row of rows) {
+        if (!isRow(row, shape)) {
+            return null;
+        }
+        const model = nameAt(tables.models, row[1]);
+        const sessionId = nameAt(tables.sessions, row[2]);
+        const cwd = nameAt(tables.folders, row[3]);
+        const accountAt = row[12] ?? 0;
+        const account = accountAt === 0 ? undefined : nameAt(tables.accounts, accountAt - 1);
+        if (model === null || sessionId === null || cwd === null || account === null) {
+            return null;
+        }
+        records.push({
+            provider,
+            timestampMs: row[0],
+            model,
+            sessionId,
+            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] },
+            ...(typeof row[13] === 'number' ? { costUsd: row[13] } : {}),
+            ...(typeof row[14] === 'string' ? { serviceTier: row[14] } : {}),
+            dedupeKey: row[11] === 0 ? null : row[11]
+        });
+    }
+    return records;
+}

package/dist/usage/scan-state.d.ts

@@ -0,0 +1,21 @@
+import { type UsageProvider } from '@adecore/agent-contracts';
+import type { CodexParserState } from './readers/codex.ts';
+export interface ScanState {
+    provider: UsageProvider;
+    size: number;
+    mtimeMs: number;
+    offset: number;
+    codex: CodexParserState | null;
+    head: string | null;
+    parserVersion?: number;
+    compressed?: boolean;
+}
+export interface HistoryMark {
+    gen: string;
+    bytes: number;
+}
+export declare function encodeState(state: ReadonlyMap<string, ScanState>, history: HistoryMark): string;
+export declare function decodeState(text: string): {
+    history: HistoryMark;
+    files: Map<string, ScanState>;
+} | null;

package/dist/usage/scan-state.js

@@ -0,0 +1,53 @@
+import { UsageProviderSchema } from '@adecore/agent-contracts';
+const STATE_VERSION = 1;
+export function encodeState(state, history) {
+    const files = {};
+    for (const [path, file] of state) {
+        files[path] = {
+            p: file.provider,
+            s: file.size,
+            m: file.mtimeMs,
+            o: file.offset,
+            c: file.codex,
+            ...(file.head === null ? {} : { h: file.head }),
+            ...(file.parserVersion === undefined ? {} : { v: file.parserVersion }),
+            ...(file.compressed === undefined ? {} : { z: file.compressed })
+        };
+    }
+    const document = { version: STATE_VERSION, history, files };
+    return JSON.stringify(document);
+}
+/* Null for text that is no state of this version; an entry that does not read only costs a read of its transcript. */
+export function decodeState(text) {
+    let document;
+    try {
+        document = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    const history = document?.history;
+    if (document?.version !== STATE_VERSION || typeof history?.gen !== 'string' || typeof history.bytes !== 'number') {
+        return null;
+    }
+    const files = new Map();
+    for (const [path, file] of Object.entries(document.files ?? {})) {
+        if (!UsageProviderSchema.safeParse(file.p).success) {
+            continue;
+        }
+        if (typeof file.s !== 'number' || typeof file.m !== 'number' || typeof file.o !== 'number' || file.o < 0) {
+            continue;
+        }
+        files.set(path, {
+            provider: file.p,
+            size: file.s,
+            mtimeMs: file.m,
+            offset: file.o,
+            codex: file.c ?? null,
+            head: typeof file.h === 'string' ? file.h : null,
+            ...(typeof file.v === 'number' ? { parserVersion: file.v } : {}),
+            ...(typeof file.z === 'boolean' ? { compressed: file.z } : {})
+        });
+    }
+    return { history: { gen: history.gen, bytes: history.bytes }, files };
+}

package/dist/usage/scanner.d.ts

@@ -20,14 +20,11 @@ export interface UsageScannerOptions {
 type AccountOf = (record: UsageRecord) => string | undefined;
 export declare function accountResolver(root: UsageRootPath, sessionAccounts: () => ReadonlyMap<string, string>): AccountOf;
 export declare class UsageScanner {
-    private readonly home;
     private readonly roots;
     private readonly sessionAccounts;
-    private index;
+    private readonly store;
     private loaded;
-    private dirty;
     constructor(home: string, roots?: UsageRootPath[] | (() => UsageRootPath[]), options?: UsageScannerOptions);
-    private get file();
     load(): Promise<void>;
     scan(): Promise<ScanReport>;
     records(): UsageRecord[];