@adecore/agents 0.21.1 → 0.21.2

package/src/usage/aggregate.ts

@@ -9,7 +9,7 @@ import type {
     UsageSummaryPayload,
     UsageTotals
 } from '@adecore/agent-contracts';
-import { cacheSavingsOf, costOf, type PriceBook } from './pricing.ts';
+import { cacheSavingsOf, costOf, type ModelPrice, type PriceBook, type PriceLookup } from './pricing.ts';
 import { ProjectResolver, type KnownProject } from './projects.ts';
 import type { UsageRecord } from './record.ts';
 
@@ -80,6 +80,75 @@ interface ProjectAccumulator {
     costUsd: number;
 }
 
+interface ModelRow extends ModelAccumulator {
+    /* The basis of the first record of a model prices the whole row: a model has one price. */
+    basis: UsagePriceBasis;
+    pricedAs: string | null;
+}
+
+function foldBucket(
+    buckets: Map<string, BucketAccumulator>,
+    slot: string,
+    record: UsageRecord,
+    account: string | null,
+    price: ModelPrice | null,
+    cost: number
+): void {
+    const key = `${slot}\0${record.provider}\0${record.model}\0${account ?? ''}`;
+    let bucket = buckets.get(key);
+    if (bucket === undefined) {
+        bucket = {
+            slot,
+            provider: record.provider,
+            model: record.model,
+            account,
+            totals: emptyTotals(),
+            costUsd: 0,
+            priced: false,
+            cacheSavingsUsd: 0,
+            sessions: new Set()
+        };
+        buckets.set(key, bucket);
+    }
+    bucket.totals = addTotals(bucket.totals, record.totals);
+    bucket.costUsd += cost;
+    bucket.priced ||= price !== null;
+    bucket.cacheSavingsUsd += price === null ? 0 : cacheSavingsOf(record.totals, price);
+    if (record.sessionId !== '') {
+        bucket.sessions.add(record.sessionId);
+    }
+}
+
+function foldModel(models: Map<string, ModelRow>, record: UsageRecord, account: string | null, lookup: PriceLookup, cost: number): void {
+    const key = `${record.provider}\0${record.model}\0${account ?? ''}`;
+    let model = models.get(key);
+    if (model === undefined) {
+        model = {
+            provider: record.provider,
+            model: record.model,
+            account,
+            totals: emptyTotals(),
+            costUsd: 0,
+            priced: false,
+            basis: lookup.basis,
+            pricedAs: lookup.pricedAs
+        };
+        models.set(key, model);
+    }
+    model.totals = addTotals(model.totals, record.totals);
+    model.costUsd += cost;
+    model.priced ||= lookup.price !== null;
+}
+
+function foldProject(project: ProjectAccumulator, record: UsageRecord, cost: number): void {
+    project.totals = addTotals(project.totals, record.totals);
+    project.costUsd += cost;
+    const share = project.byProvider.get(record.provider) ?? { costUsd: 0, tokens: 0 };
+    share.costUsd += cost;
+    share.tokens += totalTokensOf(record.totals);
+    project.byProvider.set(record.provider, share);
+}
+
 /* The account a record was made under, the default one under its CLI's kind. */
 export function accountOfRecord(record: UsageRecord): string {
     return record.account ?? record.provider;
@@ -98,9 +167,7 @@ export async function aggregate(
 ): Promise<Aggregation> {
     const format = slotFormatter(payload.timeZone, payload.resolution);
     const buckets = new Map<string, BucketAccumulator>();
-    const models = new Map<string, ModelAccumulator>();
-    /* The basis of the first record of a model prices the whole row: a model has one price. */
-    const modelBasis = new Map<string, { basis: UsagePriceBasis; pricedAs: string | null }>();
+    const models = new Map<string, ModelRow>();
     const projects = new Map<string, ProjectAccumulator>();
     const sessions = new Set<string>();
     const resolver = new ProjectResolver(known);
@@ -118,45 +185,14 @@ export async function aggregate(
         if (day < payload.from || day > payload.to) {
             continue;
         }
-        const { price, basis, pricedAs } = prices.look(record.model);
-        const cost = price === null ? 0 : costOf(record.totals, price);
-
-        const bucketKey = `${slot}\0${record.provider}\0${record.model}\0${account ?? ''}`;
-        let bucket = buckets.get(bucketKey);
-        if (bucket === undefined) {
-            bucket = {
-                slot,
-                provider: record.provider,
-                model: record.model,
-                account,
-                totals: emptyTotals(),
-                costUsd: 0,
-                priced: false,
-                cacheSavingsUsd: 0,
-                sessions: new Set()
-            };
-            buckets.set(bucketKey, bucket);
-        }
-        bucket.totals = addTotals(bucket.totals, record.totals);
-        bucket.costUsd += cost;
-        bucket.priced ||= price !== null;
-        bucket.cacheSavingsUsd += price === null ? 0 : cacheSavingsOf(record.totals, price);
+        const lookup = prices.look(record.model);
+        const cost = 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 !== '') {
-            bucket.sessions.add(record.sessionId);
             sessions.add(`${record.provider}\0${record.sessionId}`);
         }
 
-        const modelKey = `${record.provider}\0${record.model}\0${account ?? ''}`;
-        let model = models.get(modelKey);
-        if (model === undefined) {
-            model = { provider: record.provider, model: record.model, account, totals: emptyTotals(), costUsd: 0, priced: false };
-            models.set(modelKey, model);
-            modelBasis.set(modelKey, { basis, pricedAs });
-        }
-        model.totals = addTotals(model.totals, record.totals);
-        model.costUsd += cost;
-        model.priced ||= price !== null;
-
         let folder = folders.get(record.cwd);
         if (folder === undefined) {
             const resolved = await resolver.resolve(record.cwd);
@@ -166,13 +202,7 @@ export async function aggregate(
                 projects.set(folder, { folder, name: resolved.name, projectId: resolved.projectId, byProvider: new Map(), totals: emptyTotals(), costUsd: 0 });
             }
         }
-        const project = projects.get(folder)!;
-        project.totals = addTotals(project.totals, record.totals);
-        project.costUsd += cost;
-        const share = project.byProvider.get(record.provider) ?? { costUsd: 0, tokens: 0 };
-        share.costUsd += cost;
-        share.tokens += totalTokensOf(record.totals);
-        project.byProvider.set(record.provider, share);
+        foldProject(projects.get(folder)!, record, cost);
     }
 
     return {
@@ -194,15 +224,15 @@ export async function aggregate(
                     a.model.localeCompare(b.model) ||
                     (a.account ?? '').localeCompare(b.account ?? '')
             ),
-        models: [...models.entries()]
-            .map(([key, model]) => ({
+        models: [...models.values()]
+            .map((model) => ({
                 provider: model.provider,
                 model: model.model,
                 ...(model.account === null ? {} : { account: model.account }),
                 totals: model.totals,
                 costUsd: model.priced ? model.costUsd : null,
-                priceBasis: modelBasis.get(key)?.basis ?? 'unknown',
-                pricedAs: modelBasis.get(key)?.pricedAs ?? null
+                priceBasis: model.basis,
+                pricedAs: model.pricedAs
             }))
             .sort((a, b) => (b.costUsd ?? -1) - (a.costUsd ?? -1)),
         projects: [...projects.values()]

package/src/usage/exchange.ts

@@ -1,8 +1,8 @@
 import { mkdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import type { UsageRate } from '@adecore/agent-contracts';
-import { isNotFound, writeAtomic } from '../fs.ts';
 import { errorText } from '../error-text.ts';
+import { isNotFound, writeAtomic } from '../fs.ts';
 
 export const FRANKFURTER_URL = 'https://api.frankfurter.app/latest';
 

package/src/usage/limits/monitor.ts

@@ -1,12 +1,12 @@
 import type { UsageLimitsProvider, UsageLimitsSnapshot, UsageProvider } from '@adecore/agent-contracts';
+import type { CodexClientInfo } from '../../chat/codex-transport.ts';
+import { ClientSinks } from '../../client-sinks.ts';
+import { errorText } from '../../error-text.ts';
+import type { AgentEvent, AgentSink } from '../../events.ts';
 import { definedEnv } from '../../providers/accounts/launch.ts';
 import type { ProviderRegistry } from '../../providers/registry.ts';
-import type { AgentEvent, AgentSink } from '../../events.ts';
 import { mergeWindows, type LimitsUpdate } from './normalize.ts';
-import type { CodexClientInfo } from '../../chat/codex-transport.ts';
 import { probeClaude, probeCodex, type ProbeResult } from './probe.ts';
-import { ClientSinks } from '../../client-sinks.ts';
-import { errorText } from '../../error-text.ts';
 
 /* Often enough that a bar is never far behind, rarely enough that two CLIs are not started all day. */
 const PROBE_INTERVAL_MS = 5 * 60_000;

package/src/usage/limits/probe.ts

@@ -1,9 +1,9 @@
-import { withTimeout } from '../../async.ts';
 import type { UsageLimitsProvider } from '@adecore/agent-contracts';
+import { withTimeout } from '../../async.ts';
 import { spawnChatProcess, type ChatProcess, type SpawnChatProcess } from '../../chat/chat-process.ts';
 import { CodexTransport, DEFAULT_CODEX_CLIENT, type CodexClientInfo } from '../../chat/codex-transport.ts';
-import { readClaudeUsage, readCodexLimits, type ProviderReading } from './normalize.ts';
 import { errorText } from '../../error-text.ts';
+import { readClaudeUsage, readCodexLimits, type ProviderReading } from './normalize.ts';
 
 /* A CLI that has not answered by now is not going to; the next pass tries again. */
 const PROBE_TIMEOUT_MS = 20_000;

package/src/usage/pricing.ts

@@ -1,8 +1,8 @@
 import { mkdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import type { UsagePriceBasis, UsagePricing, UsageTotals } from '@adecore/agent-contracts';
-import { isNotFound, writeAtomic } from '../fs.ts';
 import { errorText } from '../error-text.ts';
+import { isNotFound, writeAtomic } from '../fs.ts';
 import bundled from './prices-snapshot.json' with { type: 'json' };
 
 export const LITELLM_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';

package/src/usage/roots.ts

@@ -12,8 +12,7 @@ export interface UsageRootPath {
 /* Where in its config folder each CLI leaves its transcripts. */
 const TRANSCRIPTS: Record<UsageProvider, string> = { claude: 'projects', codex: 'sessions' };
 
-/* Where each CLI leaves its transcripts. The same environment variables the hooks installer reads,
-   so the scanner and the installer never disagree about where a CLI keeps its things. */
+/* The transcripts of the default accounts, found through the variables the CLIs themselves read. */
 export function usageRoots(env: Record<string, string | undefined> = process.env): UsageRootPath[] {
     const home = env.HOME ?? homedir();
     return [

package/src/usage/scanner.ts

@@ -1,13 +1,13 @@
 import { mkdir, open, readFile, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import type { UsageRoot } from '@adecore/agent-contracts';
+import { errorText } from '../error-text.ts';
 import { isNotFound, writeAtomic } from '../fs.ts';
 import { decodeIndex, encodeIndex, type IndexedFile, type UsageIndex } from './index-file.ts';
 import { foldByKey, type UsageRecord } from './record.ts';
 import { claudeMightCarryUsage, parseClaudeLine } from './readers/claude.ts';
 import { cloneCodexState, codexMightCarryUsage, createCodexState, parseCodexLine, type CodexParserState } from './readers/codex.ts';
 import { usageRoots, type UsageRootPath } from './roots.ts';
-import { errorText } from '../error-text.ts';
 
 /* What a file holds from `from` to its end, as it is at the read. */
 async function readFrom(path: string, from: number): Promise<string> {
@@ -69,11 +69,11 @@ async function listJsonl(dir: string, out: string[] = []): Promise<string[]> {
  * read again next time. The Codex state is snapshotted before that tail for the same reason.
  */
 function parseChunk(text: string, provider: 'claude' | 'codex', from: number, state: CodexParserState | null): ParsedFile {
-    let records: UsageRecord[] = [];
     const end = text.lastIndexOf('\n');
     const whole = end === -1 ? '' : text.slice(0, end);
     const tail = text.slice(end + 1);
-    const read = (chunk: string, codex: CodexParserState | null): void => {
+    const read = (chunk: string, codex: CodexParserState | null): UsageRecord[] => {
+        const records: UsageRecord[] = [];
         for (const raw of chunk.split('\n')) {
             const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
             if (line === '') {
@@ -95,14 +95,12 @@ function parseChunk(text: string, provider: 'claude' | 'codex', from: number, st
                 }
             }
         }
+        return records;
     };
     const codex = provider === 'codex' ? (state ?? createCodexState()) : null;
-    read(whole, codex);
+    const counted = read(whole, codex);
     const committed = codex === null ? null : cloneCodexState(codex);
-    const counted = records;
-    records = [];
-    read(tail, codex);
-    return { records: counted, tail: records, offset: from + (end === -1 ? 0 : Buffer.byteLength(whole, 'utf8') + 1), codex: committed };
+    return { records: counted, tail: read(tail, codex), offset: from + (end === -1 ? 0 : Buffer.byteLength(whole, 'utf8') + 1), codex: committed };
 }
 
 export interface UsageScannerOptions {
@@ -139,8 +137,8 @@ function withAccount(records: UsageRecord[], accountOf: AccountOf): UsageRecord[
 }
 
 /*
- * Read appended transcript bytes incrementally, but restart after rewrites or truncation. Preserve
- * totals for deleted transcripts because their usage still happened.
+ * Reads only what a transcript appended since the last scan, and starts a file over once it was
+ * rewritten or cut. A deleted transcript keeps its totals, since its usage still happened.
  */
 export class UsageScanner {
     private readonly home: string;

package/src/usage/usage-service.ts

@@ -1,21 +1,21 @@
 import type { UsageAccount, UsageSummaryPayload, UsageSummaryResult } from '@adecore/agent-contracts';
+import { ClientSinks } from '../client-sinks.ts';
+import { errorText } from '../error-text.ts';
 import type { AgentEvent, AgentSink } from '../events.ts';
 import { accountOfRecord, aggregate } from './aggregate.ts';
 import { ExchangeRates } from './exchange.ts';
 import { PriceBook } from './pricing.ts';
 import type { KnownProject } from './projects.ts';
 import type { UsageRecord } from './record.ts';
-import { UsageScanner, type ScanReport, type UsageScannerOptions } from './scanner.ts';
 import type { UsageRootPath } from './roots.ts';
-import { errorText } from '../error-text.ts';
-import { ClientSinks } from '../client-sinks.ts';
+import { UsageScanner, type ScanReport, type UsageScannerOptions } from './scanner.ts';
 
 /* A scan this fresh answers the question the page is asking, so nothing is opened for it. */
 const SCAN_TTL_MS = 60_000;
 
 export interface UsageServiceOptions {
     home: string;
-    /* Off with `--no-price-fetch`: the bundled table then prices everything and no rate is asked for. */
+    /* Off, the bundled table prices everything and no rate is asked for. */
     allowPriceFetch?: boolean;
     /* The projects the host knows, so a folder can wear the name it has in the app. */
     knownProjects(): Promise<KnownProject[]>;
@@ -151,11 +151,7 @@ export class UsageService {
         }
         this.report = report;
         if (report.changedFiles > 0) {
-            this.emit({ event: 'usage.changed', payload: { scannedAt: report.at } });
+            this.sinks.emit({ event: 'usage.changed', payload: { scannedAt: report.at } });
         }
     }
-
-    private emit(event: AgentEvent): void {
-        this.sinks.emit(event);
-    }
 }