@adecore/agents 0.31.2 → 0.31.4

package/dist/testing/fake-acp.js

@@ -7,6 +7,7 @@ export function fakeAcpWith(options) {
         let sessionId = '';
         let mode = modes[0] ?? '';
         let model = 'fake-small';
+        let effort = 'low';
         let serverRequestId = 0;
         let callCounter = 0;
         let prompt = null;
@@ -33,7 +34,7 @@ export function fakeAcpWith(options) {
                 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;
         };
         const sessionState = () => {
@@ -41,11 +42,24 @@ export function fakeAcpWith(options) {
                 { value: 'fake-small', name: 'Fake small' },
                 { value: 'fake-large', name: 'Fake large' }
             ];
+            const effortChoices = [
+                { value: 'low', name: 'Low', description: 'Answers quickly' },
+                { value: 'high', name: 'High' },
+                ...(model === 'fake-large' ? [{ value: 'xhigh', name: 'Extra high' }] : [])
+            ];
+            const effortOption = options.reasoningEffort === undefined
+                ? []
+                : [{ id: 'reasoning_effort', name: 'Reasoning effort', type: 'select', currentValue: effort, options: effortChoices }];
             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 })) } }
-                    : { configOptions: [{ id: 'model', name: 'Model', type: 'select', category: 'model', currentValue: model, options: modelChoices }] })
+                    : {
+                        configOptions: [
+                            { id: 'model', name: 'Model', type: 'select', category: 'model', currentValue: model, options: modelChoices },
+                            ...effortOption
+                        ]
+                    })
             };
         };
         const askPermission = (toolCall, onAnswer) => {
@@ -241,6 +255,13 @@ export function fakeAcpWith(options) {
                     if (params.configId === 'model') {
                         model = String(params.value);
                     }
+                    if (params.configId === 'reasoning_effort') {
+                        if (options.reasoningEffort === 'reject') {
+                            refuse(id, -32602, 'Reasoning effort is locked');
+                            return;
+                        }
+                        effort = String(params.value);
+                    }
                     respond(id, { configOptions: sessionState().configOptions ?? [] });
                     return;
                 case 'session/prompt':

package/dist/usage/aggregate.js

@@ -47,7 +47,7 @@ function foldBucket(buckets, slot, record, account, price, cost) {
     }
     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);
@@ -64,14 +64,15 @@ function foldModel(models, record, account, lookup, cost) {
             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, record, cost) {
     project.totals = addTotals(project.totals, record.totals);
@@ -111,7 +112,7 @@ export async function aggregate(records, payload, prices, known) {
             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 !== '') {

package/dist/usage/index-file.js

@@ -23,21 +23,27 @@ export function encodeIndex(index) {
     const folders = new Interner();
     const accounts = new Interner();
     const files = {};
-    const row = (record) => [
-        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
-    ];
+    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) {
+            counted.push(record.costUsd);
+        }
+        return counted;
+    };
     for (const [path, file] of index) {
         files[path] = {
             p: file.provider,
@@ -62,10 +68,11 @@ export function encodeIndex(index) {
 }
 function isRow(row, version) {
     return (Array.isArray(row) &&
-        row.length === (version === ACCOUNTLESS_VERSION ? 12 : 13) &&
+        (version === ACCOUNTLESS_VERSION ? row.length === 12 : row.length === 13 || row.length === 14) &&
         row.slice(0, 11).every((value) => typeof value === 'number') &&
         (typeof row[11] === 'string' || row[11] === 0) &&
-        (version === ACCOUNTLESS_VERSION || typeof row[12] === 'number'));
+        (version === ACCOUNTLESS_VERSION || typeof row[12] === 'number') &&
+        (row.length < 14 || typeof row[13] === 'number'));
 }
 /*
  * A row that does not read back costs a cold parse of the file it belonged to, never a wrong total,
@@ -119,6 +126,7 @@ 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] }),
                     dedupeKey: row[11] === 0 ? null : row[11]
                 });
             }

package/dist/usage/limits/monitor.js

@@ -10,6 +10,8 @@ const MAX_BACKOFF_MS = 60 * 60_000;
 /* An account other than the default one that nobody started a CLI under for this long is only read when a person asks. */
 const RECENT_USE_MS = 24 * 60 * 60_000;
 const PROVIDERS = USAGE_PROVIDERS;
+/* The CLIs the probes know how to ask; any other provider has a plan only through the host's `plans`. */
+const PROBED = ['claude', 'codex'];
 function blank(kind) {
     return {
         kind,
@@ -106,6 +108,9 @@ export class UsageMonitor {
     listed() {
         const accounts = this.accounts?.list() ?? PROVIDERS.map((kind) => ({ id: kind, kind, label: kind, isDefault: true }));
         return PROVIDERS.flatMap((kind) => {
+            if (!PROBED.includes(kind) && this.plans[kind] === undefined) {
+                return [];
+            }
             const own = accounts.filter((account) => account.kind === kind);
             return [...own.filter((account) => account.isDefault), ...own.filter((account) => !account.isDefault)];
         });

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

@@ -0,0 +1,3 @@
+import { type UsageRecord } from '../record.ts';
+export declare const GROK_USAGE_FILE = "usage.json";
+export declare function parseGrokUsage(text: string, path: string): UsageRecord[] | null;

package/dist/usage/readers/grok.js

@@ -0,0 +1,85 @@
+import { basename, dirname } from 'node:path';
+import { asObject, asString, int } from '../record.js';
+/* The file Grok keeps the counts of a session in, beside its other files in the session's folder. */
+export const GROK_USAGE_FILE = 'usage.json';
+// `costUsdTicks` counts in ticks of 10^-10 USD, as Grok's own docs on `grok usage` say.
+const TICKS_PER_USD = 1e10;
+/* The folder above a session's is its working directory, URL-encoded into one name. */
+function cwdOf(path) {
+    try {
+        return decodeURIComponent(basename(dirname(dirname(path))));
+    }
+    catch {
+        return '';
+    }
+}
+function recordOf(counts, model, base, turn) {
+    const cacheRead = int(counts.cachedReadTokens);
+    const cacheWrite = int(counts.cacheCreationTokens);
+    const totals = {
+        calls: int(counts.modelCalls),
+        // Grok's input holds both cache kinds: its total is input plus output.
+        input: Math.max(0, int(counts.inputTokens) - cacheRead - cacheWrite),
+        cacheRead,
+        cacheWrite,
+        cacheWrite1h: 0,
+        output: int(counts.outputTokens),
+        reasoning: int(counts.reasoningTokens)
+    };
+    if (totals.input + totals.cacheRead + totals.cacheWrite + totals.output === 0) {
+        return null;
+    }
+    const ticks = int(counts.costUsdTicks);
+    return {
+        ...base,
+        model,
+        totals,
+        // A missing or zero cost is one Grok did not report, which the price table then estimates.
+        ...(ticks === 0 ? {} : { costUsd: ticks / TICKS_PER_USD }),
+        dedupeKey: `grok\0${base.sessionId}\0${turn}\0${model}`
+    };
+}
+/*
+ * A session's `usage.json` under `$GROK_HOME/sessions/<cwd>/<session id>/`, which Grok rewrites whole
+ * at the end of every turn. One record per turn per model the turn called; null when the file does not
+ * read as one, which leaves what the scanner held of it.
+ */
+export function parseGrokUsage(text, path) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    const file = asObject(parsed);
+    if (file === null || !Array.isArray(file.turns)) {
+        return null;
+    }
+    const sessionId = asString(file.sessionId) || basename(dirname(path));
+    const cwd = cwdOf(path);
+    const records = [];
+    for (const entry of file.turns) {
+        const turn = asObject(entry);
+        const timestampMs = turn === null ? Number.NaN : Date.parse(asString(turn.endedAt));
+        if (turn === null || Number.isNaN(timestampMs)) {
+            continue;
+        }
+        const number = typeof turn.turnNumber === 'number' ? String(turn.turnNumber) : asString(turn.endedAt);
+        const base = { provider: 'grok', timestampMs, sessionId, cwd };
+        const byModel = asObject(turn.modelUsage);
+        const models = byModel === null
+            ? [[asString(turn.primaryModelId), turn]]
+            : Object.entries(byModel).flatMap(([model, counts]) => {
+                const object = asObject(counts);
+                return object === null ? [] : [[model, object]];
+            });
+        for (const [model, counts] of models) {
+            const record = model === '' ? null : recordOf(counts, model, base, number);
+            if (record !== null) {
+                records.push(record);
+            }
+        }
+    }
+    return records;
+}

package/dist/usage/record.d.ts

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

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.4",
   "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.4",
+    "@adecore/intelligent-ui": "0.31.4",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/chat/acp-backend.ts

@@ -10,12 +10,17 @@ import {
     autoAllows,
     parseInitialize,
     parseSessionInfo,
+    promptUsageOf,
     resolveAcpMode,
     runtimeModeOf,
     sessionIdOf,
+    thoughtLevelOf,
     type AcpAgentCapabilities,
     type AcpModeMap,
-    type AcpSessionInfo
+    type AcpPermissionRequest,
+    type AcpSessionInfo,
+    type AcpThoughtLevel,
+    type AcpTurnUsage
 } from './acp-protocol.ts';
 import type { ApprovalDecision, BackendEvent, BackendHost, BackendLaunch, ChatBackend, TurnInput } from './backend.ts';
 import { attachmentNote } from './input.ts';
@@ -49,6 +54,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 +94,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;
@@ -138,8 +156,9 @@ export class AcpBackend implements ChatBackend {
         this.capabilities = capabilities;
         const info = await this.openSession(transport, capabilities);
         const modeId = await this.applyMode(transport, info);
-        const model = await this.applyModel(transport, info);
-        await this.applyThoughtLevel(transport, info);
+        const { model, thoughtLevel } = await this.applyModel(transport, info);
+        this.model = model;
+        await this.applyThoughtLevel(transport, thoughtLevel);
         this.spec.onSession?.(info);
         this.emit({
             type: 'session',
@@ -246,24 +265,29 @@ export class AcpBackend implements ChatBackend {
         return resolved.modeId;
     }
 
-    /* Switches to the selected model where the agent offers it; answers the model the session runs. */
-    private async applyModel(transport: JsonRpcTransport, info: AcpSessionInfo): Promise<string | null> {
+    /*
+     * Switches to the selected model where the agent offers it; answers the model the session runs and the
+     * reasoning effort it offers there, which may change with the model.
+     */
+    private async applyModel(transport: JsonRpcTransport, info: AcpSessionInfo): Promise<{ model: string | null; thoughtLevel: AcpThoughtLevel | null }> {
         const models = info.models;
+        const thoughtLevel = info.thoughtLevel;
         const wanted = this.spec.model ? this.spec.model(this.launch.selection) : this.launch.selection.model;
         if (models === null || wanted === null || wanted === models.current) {
-            return models?.current ?? wanted;
+            return { model: models?.current ?? wanted, thoughtLevel };
         }
         if (!models.models.some((model) => model.id === wanted)) {
             this.emit({ type: 'note', level: 'warning', text: `${this.spec.name} does not offer ${this.launch.modelName}. It runs ${models.current}.` });
-            return models.current;
+            return { model: models.current, thoughtLevel };
         }
         try {
             if (models.configId === null) {
                 await transport.request('session/set_model', { sessionId: this.sessionId, modelId: wanted });
-            } else {
-                await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: models.configId, value: wanted });
+                return { model: wanted, thoughtLevel };
             }
-            return wanted;
+            const result = await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: models.configId, value: wanted });
+            const after = thoughtLevelOf(result);
+            return { model: wanted, thoughtLevel: after === undefined ? thoughtLevel : after };
         } catch (error) {
             if (!(error instanceof JsonRpcError)) {
                 throw error;
@@ -273,21 +297,26 @@ export class AcpBackend implements ChatBackend {
                 level: 'warning',
                 text: `${this.spec.name} did not switch to ${this.launch.modelName} (${errorText(error)}). It runs ${models.current}.`
             });
-            return models.current;
+            return { model: models.current, thoughtLevel };
         }
     }
 
-    private async applyThoughtLevel(transport: JsonRpcTransport, info: AcpSessionInfo): Promise<void> {
-        const level = info.thoughtLevel;
+    /* Sets the selected effort where the session offers it; a model without one runs as it is. */
+    private async applyThoughtLevel(transport: JsonRpcTransport, level: AcpThoughtLevel | null): Promise<void> {
         const effort = this.launch.selection.options.effort;
-        if (level === null || typeof effort !== 'string' || effort === level.current || !level.values.includes(effort)) {
+        const choice = level?.choices.find((entry) => entry.id === effort);
+        if (level === null || choice === undefined || effort === level.current) {
             return;
         }
-        await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: level.configId, value: effort }).catch((error: unknown) => {
+        try {
+            await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: level.configId, value: choice.id });
+        } catch (error) {
             if (!(error instanceof JsonRpcError)) {
                 throw error;
             }
-        });
+            const current = level.choices.find((entry) => entry.id === level.current)?.name ?? level.current;
+            this.emit({ type: 'note', level: 'warning', text: `${this.spec.name} kept its reasoning at ${current} instead of ${choice.name}.` });
+        }
     }
 
     private promptBlocks(input: TurnInput): unknown[] {
@@ -322,6 +351,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 +468,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 +479,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 +497,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 +513,9 @@ export class AcpBackend implements ChatBackend {
     }
 
     private emit(event: BackendEvent): void {
+        if (event.type === 'model') {
+            this.model = event.model;
+        }
         this.host.onEvent(event);
     }
 }