@adecore/agents 0.38.0 → 0.40.0

package/src/usage/limits/probe.ts

@@ -26,6 +26,7 @@ function timeoutOf<T>(work: Promise<T>, ms: number, what: string): Promise<T> {
  */
 export async function probeClaude(command: readonly string[], env: Record<string, string>, spawn: SpawnChatProcess = spawnChatProcess): Promise<ProbeResult> {
     let child: ChatProcess;
+
     try {
         child = spawn({
             command: [...command, '-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose'],
@@ -36,45 +37,58 @@ export async function probeClaude(command: readonly string[], env: Record<string
     } catch (error) {
         return failure(errorText(error));
     }
+
     const write = (frame: unknown): void => {
         child.stdin.write(`${JSON.stringify(frame)}\n`);
         child.stdin.flush();
     };
+
     const read = async (): Promise<ProbeResult> => {
         write({ type: 'control_request', request_id: 'probe-init', request: { subtype: 'initialize', hooks: {} } });
         let asked = false;
         let buffer = '';
         const decoder = new TextDecoder();
+
         for await (const chunk of child.stdout as unknown as AsyncIterable<Uint8Array>) {
             buffer += decoder.decode(chunk, { stream: true });
             let at = buffer.indexOf('\n');
+
             for (; at !== -1; at = buffer.indexOf('\n')) {
                 const line = buffer.slice(0, at);
                 buffer = buffer.slice(at + 1);
                 let frame: unknown;
+
                 try {
                     frame = JSON.parse(line);
                 } catch {
                     continue;
                 }
+
                 if (typeof frame !== 'object' || frame === null) {
                     continue;
                 }
+
                 const envelope = frame as { type?: unknown; request_id?: unknown; response?: { subtype?: unknown; response?: unknown } };
+
                 if (envelope.type !== 'control_response') {
                     continue;
                 }
+
                 if (!asked) {
                     asked = true;
                     write({ type: 'control_request', request_id: 'probe-usage', request: { subtype: 'get_usage' } });
+
                     continue;
                 }
+
                 if (envelope.response?.subtype === 'error') {
                     return failure('Claude Code refused to report its usage');
                 }
+
                 return readClaudeUsage(envelope.response?.response ?? envelope.response);
             }
         }
+
         return failure('Claude Code closed without reporting its usage');
     };
 
@@ -95,6 +109,7 @@ export async function probeCodex(
     client: CodexClientInfo = DEFAULT_CODEX_CLIENT
 ): Promise<ProbeResult> {
     let transport: CodexTransport | null = null;
+
     try {
         transport = new CodexTransport({
             command: [...command],
@@ -103,12 +118,14 @@ export async function probeCodex(
             onFrame: () => undefined,
             onExit: () => undefined
         });
+
         const open = transport;
         await timeoutOf(open.request('initialize', { clientInfo: client, capabilities: { experimentalApi: true } }), PROBE_TIMEOUT_MS, 'Codex');
         open.notify('initialized', {});
         const answer = await timeoutOf(open.request('account/rateLimits/read', undefined), CODEX_READ_TIMEOUT_MS, 'Codex');
         const snapshot = typeof answer === 'object' && answer !== null ? (answer as { rateLimits?: unknown }).rateLimits : null;
         const reading = readCodexLimits(snapshot);
+
         // An account on an API key has no plan windows; Codex answers, with nothing in it.
         return reading ?? { unavailable: { reason: 'no-subscription', message: null } };
     } catch (error) {

package/src/usage/pricing.ts

@@ -61,24 +61,31 @@ function rate(value: unknown): number | null {
  */
 export function parsePriceTable(document: unknown): PriceTable {
     const table: PriceTable = new Map();
+
     if (typeof document !== 'object' || document === null) {
         return table;
     }
+
     for (const [name, value] of Object.entries(document as Record<string, LiteLlmEntry>)) {
         if (typeof value !== 'object' || value === null) {
             continue;
         }
+
         if (typeof value.litellm_provider !== 'string' || !PROVIDERS.has(value.litellm_provider)) {
             continue;
         }
+
         if (typeof value.mode !== 'string' || !MODES.has(value.mode)) {
             continue;
         }
+
         const input = rate(value.input_cost_per_token);
         const output = rate(value.output_cost_per_token);
+
         if (input === null || output === null) {
             continue;
         }
+
         const price: ModelPrice = {
             input,
             output,
@@ -86,7 +93,9 @@ export function parsePriceTable(document: unknown): PriceTable {
             cacheWrite: rate(value.cache_creation_input_token_cost) ?? input * CACHE_WRITE_SHARE,
             cacheWrite1h: input * CACHE_WRITE_1H_SHARE
         };
+
         const tiers: Partial<Record<string, ModelPrice>> = {};
+
         for (const [tier, multiplier] of [
             ['priority', 2],
             ['flex', 0.5],
@@ -100,22 +109,27 @@ export function parsePriceTable(document: unknown): PriceTable {
                 cacheWrite1h: price.cacheWrite1h * multiplier
             };
         }
+
         if (value.litellm_provider === 'openai') {
             price.tiers = tiers;
         }
+
         const key = name.trim().toLowerCase();
         table.set(key, price);
         const bare = key.slice(key.lastIndexOf('/') + 1);
+
         if (bare !== key && !table.has(bare)) {
             table.set(bare, price);
         }
     }
+
     return table;
 }
 
 /* `claude-opus-4-5-20251101` is the same model as `claude-opus-4-5`, dated. */
 function withoutDate(key: string): string | null {
     const match = /^(.*)-\d{6,8}$/.exec(key);
+
     return match === null ? null : match[1]!;
 }
 
@@ -134,37 +148,48 @@ const REVIEW_MODELS = [
 export function lookupPrice(table: PriceTable, model: string, serviceTier?: string, timestampMs?: number): PriceLookup {
     const found = lookupBasePrice(table, model, timestampMs);
     const tier = serviceTier === 'fast' ? 'priority' : serviceTier;
+
     return { ...found, price: (tier === undefined ? undefined : found.price?.tiers?.[tier]) ?? found.price };
 }
 
 function lookupBasePrice(table: PriceTable, model: string, timestampMs?: number): PriceLookup {
     const key = model.trim().toLowerCase().split('[')[0]!;
     const bare = key.slice(key.lastIndexOf('/') + 1);
+
     if (bare === '' || AMBIGUOUS.has(bare)) {
         return { price: null, basis: 'unknown', pricedAs: null };
     }
+
     const exact = table.get(key) ?? table.get(bare);
+
     if (exact !== undefined) {
         return { price: exact, basis: 'exact', pricedAs: null };
     }
+
     if (bare === 'codex-auto-review' && timestampMs !== undefined && Number.isFinite(timestampMs)) {
         const date = new Date(timestampMs).toISOString().slice(0, 10);
         const fallback = REVIEW_MODELS.find(([released]) => date >= released)?.[1] ?? 'gpt-5';
         const found = lookupBasePrice(table, fallback);
+
         return { price: found.price, basis: found.price === null ? 'unknown' : 'family', pricedAs: found.price === null ? null : fallback };
     }
+
     const dated = withoutDate(bare);
     const undated = dated === null ? undefined : table.get(dated);
+
     if (undated !== undefined && dated !== null) {
         return { price: undated, basis: 'exact', pricedAs: dated };
     }
+
     for (let family = dated ?? bare; family.includes('-');) {
         family = family.slice(0, family.lastIndexOf('-'));
         const found = AMBIGUOUS.has(family) ? undefined : table.get(family);
+
         if (found !== undefined) {
             return { price: found, basis: 'family', pricedAs: family };
         }
     }
+
     return { price: null, basis: 'unknown', pricedAs: null };
 }
 
@@ -222,6 +247,7 @@ export class PriceBook {
     /* Reads the table an earlier run stored, once; asking LiteLLM is left to `ensure`. */
     load(): Promise<void> {
         this.stored ??= this.readStored();
+
         return this.stored;
     }
 
@@ -232,6 +258,7 @@ export class PriceBook {
             .finally(() => {
                 this.inFlight = null;
             });
+
         return this.inFlight;
     }
 
@@ -243,6 +270,7 @@ export class PriceBook {
         try {
             const snapshot = JSON.parse(await readFile(this.file, 'utf8')) as Snapshot;
             const table = parsePriceTable(snapshot?.document);
+
             if (table.size > 0 && typeof snapshot.fetchedAt === 'number') {
                 this.table = table;
                 this.source = 'litellm';
@@ -259,17 +287,23 @@ export class PriceBook {
         if (!this.allowFetch || (this.fetchedAt !== null && Date.now() - this.fetchedAt < TTL_MS)) {
             return false;
         }
+
         let changed = false;
+
         try {
             const response = await fetch(LITELLM_URL, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+
             if (!response.ok) {
                 throw new Error(`LiteLLM answered ${response.status}`);
             }
+
             const document: unknown = await response.json();
             const table = parsePriceTable(document);
+
             if (table.size === 0) {
                 throw new Error('The LiteLLM table held no model this app prices');
             }
+
             this.table = table;
             this.source = 'litellm';
             this.fetchedAt = Date.now();
@@ -280,6 +314,7 @@ export class PriceBook {
             // Whatever is loaded keeps pricing; a table that could not be refreshed is not a failure.
             console.warn('Could not refresh the price table:', errorText(e));
         }
+
         return changed;
     }
 }

package/src/usage/projects.ts

@@ -22,6 +22,7 @@ async function mainCheckoutOf(gitPath: string): Promise<string | null> {
     const match = /^gitdir:\s*(.+)$/m.exec(text);
     const gitDir = match?.[1]?.trim();
     const at = gitDir?.indexOf('/.git/worktrees/') ?? -1;
+
     return gitDir !== undefined && at > 0 ? gitDir.slice(0, at) : null;
 }
 
@@ -41,25 +42,32 @@ export class ProjectResolver {
     async resolve(cwd: string): Promise<ResolvedProject> {
         const folder = cwd === '' ? '' : await this.rootOf(cwd);
         const project = this.known.get(folder);
+
         return { folder, name: project?.name ?? (folder === '' ? 'Elsewhere' : basename(folder)), projectId: project?.projectId ?? null };
     }
 
     private async rootOf(cwd: string): Promise<string> {
         const cached = this.roots.get(cwd);
+
         if (cached !== undefined) {
             return cached;
         }
+
         let root = cwd;
+
         for (let at = cwd; at !== dirname(at); at = dirname(at)) {
             try {
                 const info = await stat(join(at, '.git'));
                 root = (info.isFile() ? await mainCheckoutOf(join(at, '.git')) : null) ?? at;
+
                 break;
             } catch {
                 // Not a checkout at this level; the one above it may be.
             }
         }
+
         this.roots.set(cwd, root);
+
         return root;
     }
 }

package/src/usage/readers/claude.ts

@@ -1,4 +1,4 @@
-import { asObject, asString, int, type UsageRecord } from '../record.ts';
+import { asObject, asString, countsTokens, int, parseObject, type UsageRecord } from '../record.ts';
 
 /* Only a line with this in it can carry counts, which keeps `JSON.parse` off about two thirds of them. */
 export function claudeMightCarryUsage(line: string): boolean {
@@ -11,31 +11,32 @@ export function claudeMightCarryUsage(line: string): boolean {
  * Anthropic's, so `input_tokens` already excludes what was read from or written to the cache.
  */
 export function parseClaudeLine(line: string): UsageRecord | null {
-    let parsed: unknown;
-    try {
-        parsed = JSON.parse(line);
-    } catch {
-        return null;
-    }
-    const record = asObject(parsed);
+    const record = parseObject(line);
+
     if (record === null || record.type !== 'assistant') {
         return null;
     }
+
     const message = asObject(record.message);
     const usage = message === null ? null : asObject(message.usage);
+
     if (message === null || usage === null) {
         return null;
     }
+
     const model = asString(message.model);
     const timestampMs = Date.parse(asString(record.timestamp));
+
     // `<synthetic>` is what Claude Code writes for a message it made up itself, an error or an
     // interruption. It never reached the API, and its counts are zero, so it is not a call.
     if (model === '' || model === '<synthetic>' || Number.isNaN(timestampMs)) {
         return null;
     }
+
     const creation = asObject(usage.cache_creation);
     const outputDetails = asObject(usage.output_tokens_details);
     const messageId = asString(message.id);
+
     const totals = {
         calls: 1,
         input: int(usage.input_tokens),
@@ -45,9 +46,11 @@ export function parseClaudeLine(line: string): UsageRecord | null {
         output: int(usage.output_tokens),
         reasoning: outputDetails === null ? 0 : int(outputDetails.thinking_tokens)
     };
-    if (totals.input + totals.cacheRead + totals.cacheWrite + totals.output === 0) {
+
+    if (!countsTokens(totals)) {
         return null;
     }
+
     return {
         provider: 'claude',
         timestampMs,

package/src/usage/readers/codex.ts

@@ -1,4 +1,4 @@
-import { asObject, asString, int, type UsageRecord } from '../record.ts';
+import { asObject, asString, int, parseObject, type UsageRecord } from '../record.ts';
 
 export function codexMightCarryUsage(line: string): boolean {
     return ['token_count', 'turn_context', 'session_meta', 'thread_settings_applied', 'token_usage_record', 'compacted'].some((type) => line.includes(type));
@@ -76,6 +76,7 @@ function deltaOf(total: CodexCounts, previous: CodexCounts | null): CodexCounts
     if (previous === null) {
         return total;
     }
+
     const delta: CodexCounts = {
         input: total.input - previous.input,
         cached: total.cached - previous.cached,
@@ -83,6 +84,7 @@ function deltaOf(total: CodexCounts, previous: CodexCounts | null): CodexCounts
         output: total.output - previous.output,
         reasoning: total.reasoning - previous.reasoning
     };
+
     // A compaction or a resume restarts the count, so anything falling is not a delta at all.
     return delta.input < 0 || delta.cached < 0 || delta.cacheWrite < 0 || delta.output < 0 || delta.reasoning < 0 ? null : delta;
 }
@@ -92,21 +94,18 @@ export function isForkOrSubagent(payload: Record<string, unknown>): boolean {
     if (typeof payload.forked_from_id === 'string' || typeof payload.parent_thread_id === 'string') {
         return true;
     }
+
     const spawn = asObject(asObject(payload.source)?.subagent)?.thread_spawn;
+
     return typeof asObject(spawn)?.parent_thread_id === 'string';
 }
 
 /* Codex includes cache reads and writes in input_tokens. Compaction can appear separately from
    cumulative token_count events, so response identities prevent charging the same request twice. */
 export function parseCodexLine(line: string, state: CodexParserState): UsageRecord | null {
-    let parsed: unknown;
-    try {
-        parsed = JSON.parse(line);
-    } catch {
-        return null;
-    }
-    const record = asObject(parsed);
+    const record = parseObject(line);
     const payload = record === null ? null : asObject(record.payload);
+
     if (record === null || payload === null) {
         return null;
     }
@@ -116,33 +115,42 @@ export function parseCodexLine(line: string, state: CodexParserState): UsageReco
         if (state.sawSessionMeta) {
             return null;
         }
+
         state.sawSessionMeta = true;
         state.sessionId = asString(payload.id) || asString(payload.session_id);
         state.cwd = asString(payload.cwd);
+
         if (isForkOrSubagent(payload)) {
             state.suppressing = true;
             state.anchorMs = Date.parse(asString(record.timestamp)) || 0;
         }
+
         return null;
     }
 
     if (record.type === 'turn_context') {
         const model = asString(payload.model);
+
         if (model !== '') {
             state.model = model;
         }
+
         const cwd = asString(payload.cwd);
+
         if (cwd !== '') {
             state.cwd = cwd;
         }
+
         return null;
     }
 
     if (payload.type === 'thread_settings_applied') {
         const settings = asObject(payload.thread_settings);
+
         if (settings !== null && typeof settings.service_tier === 'string') {
             state.serviceTier = settings.service_tier;
         }
+
         return null;
     }
 
@@ -153,26 +161,33 @@ export function parseCodexLine(line: string, state: CodexParserState): UsageReco
     if (payload.type !== 'token_count') {
         return null;
     }
+
     const info = asObject(payload.info);
     const total = info === null ? null : asObject(info.total_token_usage);
+
     if (info === null || total === null || state.model === null) {
         return null;
     }
+
     const timestampMs = Date.parse(asString(record.timestamp));
+
     if (Number.isNaN(timestampMs)) {
         return null;
     }
 
     const signature = JSON.stringify(info.total_token_usage);
+
     if (signature === state.lastSignature) {
         return null;
     }
+
     state.lastSignature = signature;
 
     const cumulative = countsOf(total);
     const last = asObject(info.last_token_usage);
     const counts = deltaOf(cumulative, state.total) ?? (last === null ? null : countsOf(last));
     state.total = cumulative;
+
     if (counts === null) {
         return null;
     }
@@ -180,19 +195,23 @@ export function parseCodexLine(line: string, state: CodexParserState): UsageReco
     if (state.suppressing) {
         if (timestampMs - state.anchorMs <= FORK_COPY_MAX_GAP_MS) {
             state.anchorMs = timestampMs;
+
             return null;
         }
+
         // The first event that is not part of the replayed burst is this thread's own work.
         state.suppressing = false;
     }
 
     let dedupeKey: string | null = null;
     const pending = state.latestResponse === null ? undefined : state.pendingCompactions[state.latestResponse];
+
     if (pending !== undefined && (sameCounts(pending.counts, counts) || sameCounts(pending.threadTotal, cumulative))) {
         dedupeKey = `codex:response:${state.latestResponse}`;
         delete state.pendingCompactions[state.latestResponse!];
         state.handledResponses.push(state.latestResponse!);
     }
+
     return usageRecord(counts, timestampMs, state.model, state, dedupeKey);
 }
 
@@ -209,9 +228,11 @@ function sameCounts(first: CodexCounts | null, second: CodexCounts): boolean {
 
 function parseCompaction(record: Record<string, unknown>, payload: Record<string, unknown>, state: CodexParserState): UsageRecord | null {
     const id = asString(record.type === 'compacted' ? payload.compaction_response_id : payload.response_id);
+
     if (id === '' || state.handledResponses.includes(id)) {
         return null;
     }
+
     if (record.type === 'compacted') {
         if (!state.compacted.includes(id)) {
             state.compacted.push(id);
@@ -220,29 +241,38 @@ function parseCompaction(record: Record<string, unknown>, payload: Record<string
         const usage = asObject(payload.usage);
         const model = asString(payload.model) || state.model;
         const timestampMs = Date.parse(asString(record.timestamp));
+
         if (usage === null || model === null || !Number.isFinite(timestampMs)) {
             return null;
         }
+
         const counts = countsOf(usage);
         const parsed = usageRecord(counts, timestampMs, model, state, `codex:response:${id}`);
+
         if (parsed === null) {
             return null;
         }
+
         state.latestResponse = id;
         const threadTotal = asObject(payload.thread_token_usage);
         state.pendingCompactions[id] ??= { record: parsed, counts, threadTotal: threadTotal === null ? null : countsOf(threadTotal) };
     }
+
     const pending = state.pendingCompactions[id];
+
     if (!state.compacted.includes(id) || pending === undefined) {
         return null;
     }
+
     state.handledResponses.push(id);
     delete state.pendingCompactions[id];
+
     return pending.record;
 }
 
 function usageRecord(counts: CodexCounts, timestampMs: number, model: string, state: CodexParserState, dedupeKey: string | null): UsageRecord | null {
     const uncached = Math.max(0, counts.input - counts.cached - counts.cacheWrite);
+
     const totals = {
         calls: 1,
         input: uncached,
@@ -252,9 +282,11 @@ function usageRecord(counts: CodexCounts, timestampMs: number, model: string, st
         output: counts.output,
         reasoning: Math.min(counts.output, counts.reasoning)
     };
+
     if (uncached + counts.cached + counts.cacheWrite + counts.output === 0) {
         return null;
     }
+
     return {
         provider: 'codex',
         timestampMs,

package/src/usage/readers/grok.ts

@@ -1,5 +1,5 @@
 import { basename, dirname } from 'node:path';
-import { asObject, asString, int, type UsageRecord } from '../record.ts';
+import { asObject, asString, countsTokens, int, parseObject, type UsageRecord } from '../record.ts';
 
 /* 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';
@@ -19,6 +19,7 @@ function cwdOf(path: string): string {
 function recordOf(counts: Record<string, unknown>, model: string, base: Omit<UsageRecord, 'model' | 'totals' | 'dedupeKey'>, turn: string): UsageRecord | null {
     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.
@@ -29,10 +30,13 @@ function recordOf(counts: Record<string, unknown>, model: string, base: Omit<Usa
         output: int(counts.outputTokens),
         reasoning: int(counts.reasoningTokens)
     };
-    if (totals.input + totals.cacheRead + totals.cacheWrite + totals.output === 0) {
+
+    if (!countsTokens(totals)) {
         return null;
     }
+
     const ticks = int(counts.costUsdTicks);
+
     return {
         ...base,
         model,
@@ -49,41 +53,45 @@ function recordOf(counts: Record<string, unknown>, model: string, base: Omit<Usa
  * read as one, which leaves what the scanner held of it.
  */
 export function parseGrokUsage(text: string, path: string): UsageRecord[] | null {
-    let parsed: unknown;
-    try {
-        parsed = JSON.parse(text);
-    } catch {
-        return null;
-    }
-    const file = asObject(parsed);
+    const file = parseObject(text);
+
     if (file === null || !Array.isArray(file.turns)) {
         return null;
     }
+
     const sessionId = asString(file.sessionId) || basename(dirname(path));
     const cwd = cwdOf(path);
     const records: UsageRecord[] = [];
+
     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' as const, timestampMs, sessionId, cwd };
         const byModel = asObject(turn.modelUsage);
+
         const models: Array<[string, Record<string, unknown>]> =
             byModel === null
                 ? [[asString(turn.primaryModelId), turn]]
                 : Object.entries(byModel).flatMap(([model, counts]) => {
                       const object = asObject(counts);
+
                       return object === null ? [] : [[model, object] as [string, Record<string, unknown>]];
                   });
+
         for (const [model, counts] of models) {
             const record = model === '' ? null : recordOf(counts, model, base, number);
+
             if (record !== null) {
                 records.push(record);
             }
         }
     }
+
     return records;
 }