@adecore/agents 0.31.2 → 0.31.3

package/dist/usage/record.js

@@ -33,7 +33,11 @@ export function foldByKey(records) {
             folded.push({ ...record, totals: { ...record.totals } });
             continue;
         }
-        maxTotals(folded[seen].totals, record.totals);
+        const into = folded[seen];
+        maxTotals(into.totals, record.totals);
+        if (record.costUsd !== undefined) {
+            into.costUsd = Math.max(into.costUsd ?? 0, record.costUsd);
+        }
     }
     return folded;
 }

package/dist/usage/roots.js

@@ -1,13 +1,18 @@
 import { join } from 'node:path';
 import { homeFolder } from '../home-folder.js';
 /* Where in its config folder each CLI leaves its transcripts. A provider with no CLI has a log its host passes as a root of its own. */
-const TRANSCRIPTS = { claude: 'projects', codex: 'sessions' };
+const TRANSCRIPTS = {
+    claude: 'projects',
+    codex: 'sessions',
+    grok: 'sessions'
+};
 /* The transcripts of the default accounts, found through the variables the CLIs themselves read. */
 export function usageRoots(env = process.env) {
     const home = homeFolder(env);
     return [
         { provider: 'claude', path: join(env.CLAUDE_CONFIG_DIR ?? join(home, '.claude'), TRANSCRIPTS.claude) },
-        { provider: 'codex', path: join(env.CODEX_HOME ?? join(home, '.codex'), TRANSCRIPTS.codex) }
+        { provider: 'codex', path: join(env.CODEX_HOME ?? join(home, '.codex'), TRANSCRIPTS.codex) },
+        { provider: 'grok', path: join(env.GROK_HOME ?? join(home, '.grok'), TRANSCRIPTS.grok) }
     ];
 }
 /* The transcripts of every account, once per folder: Codex accounts over one home share its sessions. */

package/dist/usage/scanner.d.ts

@@ -26,5 +26,6 @@ export declare class UsageScanner {
     scan(): Promise<ScanReport>;
     records(): UsageRecord[];
     private readFileInto;
+    private readWholeInto;
 }
 export {};

package/dist/usage/scanner.js

@@ -6,6 +6,7 @@ import { isNotFound, writeAtomic } from '../fs.js';
 import { decodeIndex, encodeIndex } from './index-file.js';
 import { foldByKey } from './record.js';
 import { claudeMightCarryUsage, parseClaudeLine } from './readers/claude.js';
+import { GROK_USAGE_FILE, parseGrokUsage } from './readers/grok.js';
 import { hostLogMightCarryUsage, parseHostUsageLine } from './readers/host-log.js';
 import { cloneCodexState, codexMightCarryUsage, createCodexState, parseCodexLine } from './readers/codex.js';
 import { usageRoots } from './roots.js';
@@ -49,7 +50,14 @@ function headOf(hash) {
     // Older indexes hashed only the first 4 KB; they cannot establish that the rest stayed unchanged.
     return `sha256:${hash.copy().digest('base64')}`;
 }
-async function listJsonl(dir, out = []) {
+/* A log of lines for every provider but Grok, which keeps one JSON file per session that it rewrites whole. */
+function readsWhole(provider) {
+    return provider === 'grok';
+}
+function isUsageFile(provider, name) {
+    return readsWhole(provider) ? name === GROK_USAGE_FILE : name.endsWith('.jsonl');
+}
+async function listUsageFiles(dir, provider, out = []) {
     let entries;
     try {
         entries = await readdir(dir, { withFileTypes: true });
@@ -61,9 +69,9 @@ async function listJsonl(dir, out = []) {
     for (const entry of entries) {
         const path = join(dir, entry.name);
         if (entry.isDirectory()) {
-            await listJsonl(path, out);
+            await listUsageFiles(path, provider, out);
         }
-        else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+        else if (entry.isFile() && isUsageFile(provider, entry.name)) {
             out.push(path);
         }
     }
@@ -103,7 +111,7 @@ function parseChunk(text, provider, from, state) {
                 }
                 continue;
             }
-            // Claude Code and Codex write transcripts of their own; every other provider is a log its host keeps.
+            // Claude Code and Codex write transcripts of their own, Grok a file read whole; every other provider is a log its host keeps.
             if (hostLogMightCarryUsage(line)) {
                 const record = parseHostUsageLine(line, provider);
                 if (record !== null) {
@@ -207,7 +215,7 @@ export class UsageScanner {
             }
             let failure = null;
             const accountOf = accountResolver(root, sessionAccounts);
-            for (const path of await listJsonl(root.path)) {
+            for (const path of await listUsageFiles(root.path, root.provider)) {
                 files += 1;
                 try {
                     if (await this.readFileInto(path, root.provider, accountOf)) {
@@ -242,6 +250,9 @@ export class UsageScanner {
         if (known !== undefined && known.provider === provider && 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);
         // A file only counts as grown while it starts the way it did; one rewritten larger is read again from the start.
@@ -268,4 +279,27 @@ export class UsageScanner {
         this.dirty = true;
         return true;
     }
+    /*
+     * A file rewritten as a whole replaces what the index held of it, so a turn it still lists is never
+     * counted twice. One that does not parse, such as one caught halfway through a write, keeps the
+     * records it had and is read again on the next scan.
+     */
+    async readWholeInto(path, provider, accountOf, info) {
+        const records = parseGrokUsage(await readFile(path, 'utf8'), path);
+        if (records === null) {
+            return false;
+        }
+        this.index.set(path, {
+            provider,
+            size: info.size,
+            mtimeMs: info.mtimeMs,
+            offset: info.size,
+            records: foldByKey(withAccount(records, accountOf)),
+            tail: [],
+            codex: null,
+            head: null
+        });
+        this.dirty = true;
+        return true;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.31.2",
+  "version": "0.31.3",
   "description": "Node-compatible agent chat hosts, providers, accounts, usage and durable task coordination.",
   "type": "module",
   "exports": {
@@ -81,8 +81,8 @@
     "test": "bun --conditions=source test"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.31.2",
-    "@adecore/intelligent-ui": "0.31.2",
+    "@adecore/agent-contracts": "0.31.3",
+    "@adecore/intelligent-ui": "0.31.3",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/chat/acp-backend.ts

@@ -10,12 +10,15 @@ import {
     autoAllows,
     parseInitialize,
     parseSessionInfo,
+    promptUsageOf,
     resolveAcpMode,
     runtimeModeOf,
     sessionIdOf,
     type AcpAgentCapabilities,
     type AcpModeMap,
-    type AcpSessionInfo
+    type AcpPermissionRequest,
+    type AcpSessionInfo,
+    type AcpTurnUsage
 } from './acp-protocol.ts';
 import type { ApprovalDecision, BackendEvent, BackendHost, BackendLaunch, ChatBackend, TurnInput } from './backend.ts';
 import { attachmentNote } from './input.ts';
@@ -49,6 +52,18 @@ export interface AcpAgentSpec {
     model?(selection: ModelSelection): string | null;
     // What every new, loaded or resumed session offers, for a host that fills its model catalog from the agent.
     onSession?(info: AcpSessionInfo): void;
+    // The tokens of every turn whose `session/prompt` response reports them, for a host that keeps a usage log.
+    onUsage?(usage: AcpUsageReport): void;
+    // A permission request the host answers itself, in any runtime mode: true allows it once without asking the
+    // person, for a call the host already guards. A throw counts as false.
+    autoAllow?(request: AcpPermissionRequest): boolean;
+}
+
+/* One turn's usage, with the session, folder and model it ran in. */
+export interface AcpUsageReport extends AcpTurnUsage {
+    sessionId: string;
+    cwd: string;
+    model: string;
 }
 
 // What `initialize` and a session request may take; a prompt and a login wait for as long as the agent runs.
@@ -77,6 +92,7 @@ export class AcpBackend implements ChatBackend {
     private replaying = false;
     private contextPending: string | null = null;
     private prompt: { promptId: string | undefined; cancelled: boolean } | null = null;
+    private model: string | null = null;
 
     constructor(launch: BackendLaunch, host: BackendHost, spec: AcpAgentSpec) {
         this.launch = launch;
@@ -139,6 +155,7 @@ export class AcpBackend implements ChatBackend {
         const info = await this.openSession(transport, capabilities);
         const modeId = await this.applyMode(transport, info);
         const model = await this.applyModel(transport, info);
+        this.model = model;
         await this.applyThoughtLevel(transport, info);
         this.spec.onSession?.(info);
         this.emit({
@@ -322,6 +339,7 @@ export class AcpBackend implements ChatBackend {
             .then((result) => {
                 if (this.transport === transport && this.prompt === turn) {
                     this.prompt = null;
+                    this.report(result);
                     this.emitAll(this.protocol.finish(turn.cancelled ? { stopReason: 'cancelled' } : result, turn.promptId));
                 }
             })
@@ -438,7 +456,7 @@ export class AcpBackend implements ChatBackend {
             }
             return;
         }
-        if (autoAllows(this.launch.runtimeMode, permission.kind)) {
+        if (autoAllows(this.launch.runtimeMode, permission.kind) || this.hostAllows(permission.request)) {
             this.emitAll(permission.events.filter((event) => event.type !== 'approval.requested'));
             const answer = this.protocol.answer(permission.requestId, 'allow');
             if (answer) {
@@ -449,6 +467,14 @@ export class AcpBackend implements ChatBackend {
         this.emitAll(permission.events);
     }
 
+    private hostAllows(request: AcpPermissionRequest): boolean {
+        try {
+            return this.spec.autoAllow?.(request) === true;
+        } catch {
+            return false;
+        }
+    }
+
     private handleExit(transport: JsonRpcTransport, exitCode: number | null, stderr: string | null): void {
         if (this.transport !== transport) {
             return;
@@ -459,6 +485,15 @@ export class AcpBackend implements ChatBackend {
         this.emit({ type: 'exit', exitCode, ...(stderr === null ? {} : { stderr }) });
     }
 
+    /* A cancelled turn still spent what it reports. */
+    private report(result: unknown): void {
+        const usage = this.spec.onUsage === undefined ? null : promptUsageOf(result);
+        if (usage === null) {
+            return;
+        }
+        this.spec.onUsage?.({ ...usage, sessionId: this.sessionId, cwd: this.launch.cwd, model: this.model ?? this.launch.selection.model });
+    }
+
     private emitAll(events: BackendEvent[]): void {
         for (const event of events) {
             this.emit(event);
@@ -466,6 +501,9 @@ export class AcpBackend implements ChatBackend {
     }
 
     private emit(event: BackendEvent): void {
+        if (event.type === 'model') {
+            this.model = event.model;
+        }
         this.host.onEvent(event);
     }
 }

package/src/chat/acp-protocol.ts

@@ -58,6 +58,48 @@ const SessionNotificationSchema = z.looseObject({ sessionId: z.string(), update:
 
 const PromptResponseSchema = z.looseObject({ stopReason: z.string() });
 
+const tokenCount = z.number().int().nonnegative();
+
+// Unstable in the protocol (`PromptResponse.usage`); only the three totals are required.
+const PromptUsageSchema = z.looseObject({
+    totalTokens: tokenCount,
+    inputTokens: tokenCount,
+    outputTokens: tokenCount,
+    thoughtTokens: tokenCount.nullish(),
+    cachedReadTokens: tokenCount.nullish(),
+    cachedWriteTokens: tokenCount.nullish()
+});
+
+/* The tokens of one turn with their kinds apart, as a usage record keeps them: `reasoning` is a part of `output`. */
+export interface AcpTurnUsage {
+    input: number;
+    cacheRead: number;
+    cacheWrite: number;
+    output: number;
+    reasoning: number;
+}
+
+/*
+ * The `usage` a `session/prompt` response carries, or null where the agent reports none. The protocol
+ * leaves open whether the input holds the cached part, so the total decides: when the kinds add up
+ * to more than it, the input counted the cache too and loses it here.
+ */
+export function promptUsageOf(result: unknown): AcpTurnUsage | null {
+    const response = z.looseObject({ usage: PromptUsageSchema }).safeParse(result);
+    if (!response.success) {
+        return null;
+    }
+    const usage = response.data.usage;
+    const cacheRead = usage.cachedReadTokens ?? 0;
+    const cacheWrite = usage.cachedWriteTokens ?? 0;
+    const apart = usage.inputTokens + usage.outputTokens + cacheRead + cacheWrite <= usage.totalTokens;
+    const input = apart ? usage.inputTokens : Math.max(0, usage.inputTokens - cacheRead - cacheWrite);
+    if (input + cacheRead + cacheWrite + usage.outputTokens === 0) {
+        return null;
+    }
+    return { input, cacheRead, cacheWrite, output: usage.outputTokens, reasoning: usage.thoughtTokens ?? 0 };
+}
+
 const ModeStateSchema = z.looseObject({
     currentModeId: z.string(),
     availableModes: z.array(z.unknown())
@@ -440,11 +482,22 @@ function toolOutput(tool: ToolState): string | null {
     return null;
 }
 
+/* What an agent asks permission for, in the plain form a host's `autoAllow` judges it by. */
+export interface AcpPermissionRequest {
+    // The ACP tool kind (`execute`, `edit`, `fetch`, ...), or null when the agent names none.
+    kind: string | null;
+    title: string | null;
+    // Every text the call carries that may be what it runs: the command in its raw input and each text in its
+    // content. The agent decides which one it runs, so a host allows the call only when every one passes.
+    commands: string[];
+}
+
 /* A permission request as the backend acts on it: the event it raises, and the tool kind a runtime mode may answer it by. */
 export interface AcpPermission {
     requestId: string;
     rpcId: number | string;
     kind: string | null;
+    request: AcpPermissionRequest;
     events: BackendEvent[];
 }
 
@@ -562,7 +615,9 @@ export class AcpProtocol {
             description: tool.title === '' ? null : tool.title,
             canAllowAlways: options.some((option) => option.kind === 'allow_always')
         });
-        return { requestId, rpcId, kind: tool.kind, events };
+        const command = rawField(tool.rawInput, 'command', 'cmd');
+        const asked = { kind: tool.kind, title: tool.title === '' ? null : tool.title, commands: [...(command === null ? [] : [command]), ...tool.text] };
+        return { requestId, rpcId, kind: tool.kind, request: asked, events };
     }
 
     /*

package/src/chat/index.ts

@@ -1,6 +1,16 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
-export { type AcpAgentSpec, type AcpClientInfo, createAcpBackend } from './acp-backend.ts';
-export type { AcpAgentInfo, AcpModel, AcpModelState, AcpMode, AcpModeState, AcpSessionInfo, AcpModeMap } from './acp-protocol.ts';
+export { type AcpAgentSpec, type AcpClientInfo, type AcpUsageReport, createAcpBackend } from './acp-backend.ts';
+export type {
+    AcpAgentInfo,
+    AcpModel,
+    AcpModelState,
+    AcpMode,
+    AcpModeState,
+    AcpPermissionRequest,
+    AcpSessionInfo,
+    AcpModeMap,
+    AcpTurnUsage
+} from './acp-protocol.ts';
 export { AttachmentStore } from './attachment-store.ts';
 export type { BackendLaunch, TurnInput, ApprovalDecision, BackendEvent, BackendHost, ChatBackend } from './backend.ts';
 export { runningInBackground, type BackgroundWork } from './background-work.ts';

package/src/providers/acp-provider.ts

@@ -1,7 +1,8 @@
 import type { AgentKind, ProviderCapabilities, ProviderInstall } from '@adecore/agent-contracts';
-import { createAcpBackend, type AcpAgentSpec } from '../chat/acp-backend.ts';
+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 { 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';
@@ -53,8 +54,13 @@ export interface AcpProviderSpec extends AcpAgentSpec {
     accountProbe?: boolean;
     // Absent or true lets the models a session reports replace the catalog's; false keeps the catalog as the host built it.
     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;
 }
 
+/* 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 }));
@@ -68,6 +74,14 @@ export function createAcpProvider(spec: AcpProviderSpec): ChatProvider {
         }
         spec.onSession?.(info);
     };
+    const usageLog = spec.usageLog === undefined || OWN_USAGE_FILES.has(spec.kind) ? null : spec.usageLog;
+    const onUsage =
+        usageLog === null
+            ? spec.onUsage
+            : (report: AcpUsageReport): void => {
+                  writeAcpUsage(usageLog, report, Date.now());
+                  spec.onUsage?.(report);
+              };
     return {
         kind: spec.kind,
         name: spec.name,
@@ -99,6 +113,6 @@ export function createAcpProvider(spec: AcpProviderSpec): ChatProvider {
                           onSession
                       })
               }),
-        createBackend: createAcpBackend({ ...spec, onSession })
+        createBackend: createAcpBackend({ ...spec, onSession, ...(onUsage === undefined ? {} : { onUsage }) })
     };
 }

package/src/providers/acp-usage-log.ts

@@ -0,0 +1,26 @@
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import type { AcpUsageReport } from '../chat/acp-backend.ts';
+import { errorText } from '../error-text.ts';
+import { hostUsageLine } from '../usage/readers/host-log.ts';
+
+/*
+ * Appends one turn to the session's own file in the folder, so a scan that hashes what it already read
+ * of a file never rereads the log of every other session. Written at once, since it is one line per turn.
+ */
+export function writeAcpUsage(folder: string, report: AcpUsageReport, at: number): void {
+    const { sessionId, cwd, model, ...tokens } = report;
+    try {
+        mkdirSync(folder, { recursive: true, mode: 0o700 });
+        appendFileSync(
+            join(folder, `${encodeURIComponent(sessionId === '' ? 'session' : sessionId)}.jsonl`),
+            hostUsageLine({ at, model, session: sessionId, cwd, ...tokens }),
+            {
+                mode: 0o600
+            }
+        );
+    } catch (e) {
+        // A turn whose line could not be written is missing from the usage page; the chat itself goes on.
+        console.warn('Could not write the usage of an ACP turn:', errorText(e));
+    }
+}

package/src/providers/index.ts

@@ -13,5 +13,6 @@ export { type CodexRules, codexRulesText, codexRulesPathIn, defaultCodexHome, in
 export { codexThreadOptions, codexServiceTier } from './codex.ts';
 export { type CliDetection, detectCli } from './detect.ts';
 export type { ChatProvider, ProviderHome } from './provider.ts';
+export { isOnlyCommands } from './shell-commands.ts';
 export { ProviderRegistry, type ProviderRegistryOptions } from './registry.ts';
 export { MODE_ORDER, narrowerMode, ceilingForOpening, modeFlag } from '../modes.ts';

package/src/providers/shell-commands.ts

@@ -0,0 +1,122 @@
+// Unquoted, each of these makes the shell do more than run a word list: a pipe, a redirect, an expansion,
+// a subshell or group, a glob, a comment or a history or negation mark.
+const REFUSED = new Set(['|', '>', '<', '$', '`', '(', ')', '{', '}', '*', '?', '[', '~', '#', '!']);
+
+/*
+ * Whether a shell command line is only simple commands, joined by `&&`, `||`, `;` or newlines, each of
+ * which starts with one of `allowed`. Anything the tokenizer cannot prove simple answers false, so a
+ * true is safe to act on without a person: a pipe, a redirect, an expansion, a subshell, a background
+ * `&`, an unquoted glob or an unbalanced quote all refuse the whole line.
+ */
+export function isOnlyCommands(command: string, allowed: readonly string[]): boolean {
+    let word = '';
+    let inWord = false;
+    let words: string[] = [];
+    let commands = 0;
+    // A separator that still needs a command after it; a trailing `;` or newline needs none.
+    let dangling = false;
+
+    const endWord = (): void => {
+        if (inWord) {
+            words.push(word);
+        }
+        word = '';
+        inWord = false;
+    };
+
+    const endCommand = (separator: string): boolean => {
+        endWord();
+        if (words.length === 0) {
+            // Blank lines are fine, and so is a newline after `&&` or `||`; an empty command before any other separator is not.
+            return separator === '\n';
+        }
+        if (!allowed.includes(words[0]!)) {
+            return false;
+        }
+        commands++;
+        words = [];
+        dangling = separator === '&&' || separator === '||';
+        return true;
+    };
+
+    for (let i = 0; i < command.length; i++) {
+        const char = command[i]!;
+        const next = command[i + 1];
+        if (char === ' ' || char === '\t') {
+            endWord();
+            continue;
+        }
+        if (char === '\n' || char === ';') {
+            if (!endCommand(char)) {
+                return false;
+            }
+            continue;
+        }
+        if ((char === '&' || char === '|') && next === char) {
+            if (!endCommand(char + next)) {
+                return false;
+            }
+            i++;
+            continue;
+        }
+        if (char === '&' || REFUSED.has(char)) {
+            return false;
+        }
+        if (char === '\\') {
+            if (next === undefined) {
+                return false;
+            }
+            i++;
+            if (next !== '\n') {
+                word += next;
+                inWord = true;
+            }
+            continue;
+        }
+        if (char === "'") {
+            const close = command.indexOf("'", i + 1);
+            if (close === -1) {
+                return false;
+            }
+            word += command.slice(i + 1, close);
+            inWord = true;
+            i = close;
+            continue;
+        }
+        if (char === '"') {
+            inWord = true;
+            let closed = false;
+            for (i++; i < command.length; i++) {
+                const quoted = command[i]!;
+                if (quoted === '"') {
+                    closed = true;
+                    break;
+                }
+                if (quoted === '$' || quoted === '`') {
+                    return false;
+                }
+                if (quoted === '\\') {
+                    const escaped = command[i + 1];
+                    if (escaped === undefined) {
+                        return false;
+                    }
+                    i++;
+                    if (escaped === '"' || escaped === '\\' || escaped === '$' || escaped === '`') {
+                        word += escaped;
+                    } else if (escaped !== '\n') {
+                        word += quoted + escaped;
+                    }
+                    continue;
+                }
+                word += quoted;
+            }
+            if (!closed) {
+                return false;
+            }
+            continue;
+        }
+        word += char;
+        inWord = true;
+    }
+    return endCommand('\n') && commands > 0 && !dangling;
+}

package/src/testing/fake-acp.ts

@@ -22,6 +22,8 @@ export interface FakeAcpOptions {
     legacyModels?: boolean;
     // Advertises and answers `session/close`.
     closeSession?: boolean;
+    // The `usage` every `session/prompt` response carries; absent reports none.
+    turnUsage?: Record<string, number>;
 }
 
 export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
@@ -63,7 +65,7 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
                 return;
             }
             update({ sessionUpdate: 'usage_update', used: 1200, size: 200000, cost: { amount: 0.01, currency: 'USD' } });
-            respond(prompt.rpcId, { stopReason });
+            respond(prompt.rpcId, { stopReason, ...(options.turnUsage === undefined ? {} : { usage: options.turnUsage }) });
             prompt = null;
         };
 

package/src/usage/aggregate.ts

@@ -112,7 +112,7 @@ function foldBucket(
     }
     bucket.totals = addTotals(bucket.totals, record.totals);
     bucket.costUsd += cost;
-    bucket.priced ||= price !== null;
+    bucket.priced ||= price !== null || record.costUsd !== undefined;
     bucket.cacheSavingsUsd += price === null ? 0 : cacheSavingsOf(record.totals, price);
     if (record.sessionId !== '') {
         bucket.sessions.add(record.sessionId);
@@ -130,14 +130,15 @@ function foldModel(models: Map<string, ModelRow>, record: UsageRecord, account:
             totals: emptyTotals(),
             costUsd: 0,
             priced: false,
-            basis: lookup.basis,
-            pricedAs: lookup.pricedAs
+            // A cost the CLI reported is the bill itself, not a price looked up for the model.
+            basis: record.costUsd === undefined ? lookup.basis : 'exact',
+            pricedAs: record.costUsd === undefined ? lookup.pricedAs : null
         };
         models.set(key, model);
     }
     model.totals = addTotals(model.totals, record.totals);
     model.costUsd += cost;
-    model.priced ||= lookup.price !== null;
+    model.priced ||= lookup.price !== null || record.costUsd !== undefined;
 }
 
 function foldProject(project: ProjectAccumulator, record: UsageRecord, cost: number): void {
@@ -186,7 +187,7 @@ export async function aggregate(
             continue;
         }
         const lookup = prices.look(record.model);
-        const cost = lookup.price === null ? 0 : costOf(record.totals, lookup.price);
+        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);
         if (record.sessionId !== '') {