@adecore/agents 0.38.0 → 0.40.0

package/src/usage/accounts.ts

@@ -20,8 +20,10 @@ export function machineAccounts(snapshot: ProviderAccounts, nameOf: (kind: Usage
         if (!isUsageProvider(account.kind)) {
             return [];
         }
+
         const isDefault = id === account.kind;
         const state = snapshot.statuses.find((status) => status.id === id)?.state;
+
         return [
             {
                 id,
@@ -52,7 +54,9 @@ export function usageRootsOf(service: ProviderAccountsService): UsageRootPath[]
             if (!isUsageProvider(kind)) {
                 return [];
             }
+
             const folder = service.transcriptFolder(kind, id);
+
             return folder === null || folder === '' ? [] : [{ id, kind, folder }];
         })
     );
@@ -78,10 +82,12 @@ export function limitAccountsOf(
 /* The account every CLI session a chat here ran was under, by `<provider>\0<sessionId>`, for the transcripts accounts share. */
 export function chatSessionAccounts(chats: ReadonlyArray<Pick<ChatInfo, 'provider' | 'agentSessionId' | 'account'>>): Map<string, string> {
     const known = new Map<string, string>();
+
     for (const chat of chats) {
         if (chat.agentSessionId !== null) {
             known.set(`${chat.provider}\0${chat.agentSessionId}`, chat.account ?? chat.provider);
         }
     }
+
     return known;
 }

package/src/usage/aggregate.ts

@@ -30,6 +30,7 @@ function slotFormatter(timeZone: string, resolution: UsageResolution): Intl.Date
         resolution === 'hour'
             ? { timeZone, year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', hourCycle: 'h23' }
             : { timeZone, year: 'numeric', month: '2-digit', day: '2-digit' };
+
     try {
         return new Intl.DateTimeFormat('en-CA', options);
     } catch {
@@ -41,8 +42,11 @@ function slotFormatter(timeZone: string, resolution: UsageResolution): Intl.Date
 /* `2026-09-10` for a day, `2026-09-10T14` for an hour: the day is always the first ten characters. */
 function slotOf(format: Intl.DateTimeFormat, timestampMs: number, resolution: UsageResolution): string {
     const parts = format.formatToParts(new Date(timestampMs));
+
     const at = (type: Intl.DateTimeFormatPartTypes): string => parts.find((part) => part.type === type)?.value ?? '';
+
     const day = `${at('year')}-${at('month')}-${at('day')}`;
+
     return resolution === 'hour' ? `${day}T${at('hour')}` : day;
 }
 
@@ -96,6 +100,7 @@ function foldBucket(
 ): void {
     const key = `${slot}\0${record.provider}\0${record.model}\0${account ?? ''}`;
     let bucket = buckets.get(key);
+
     if (bucket === undefined) {
         bucket = {
             slot,
@@ -108,12 +113,15 @@ function foldBucket(
             cacheSavingsUsd: 0,
             sessions: new Set()
         };
+
         buckets.set(key, bucket);
     }
+
     bucket.totals = addTotals(bucket.totals, record.totals);
     bucket.costUsd += cost;
     bucket.priced ||= price !== null || record.costUsd !== undefined;
     bucket.cacheSavingsUsd += price === null ? 0 : cacheSavingsOf(record.totals, price);
+
     if (record.sessionId !== '') {
         bucket.sessions.add(record.sessionId);
     }
@@ -122,6 +130,7 @@ function foldBucket(
 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,
@@ -134,8 +143,10 @@ function foldModel(models: Map<string, ModelRow>, record: UsageRecord, account:
             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 || record.costUsd !== undefined;
@@ -178,31 +189,39 @@ export async function aggregate(
 
     for (const record of records) {
         const account = only === null ? null : accountOfRecord(record);
+
         if (only !== null && !only.has(account!)) {
             continue;
         }
+
         const slot = slotOf(format, record.timestampMs, payload.resolution);
         const day = slot.slice(0, 10);
+
         if (day < payload.from || day > payload.to) {
             continue;
         }
+
         const lookup = prices.look(record.model, record.serviceTier, record.timestampMs);
         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 !== '') {
             sessions.add(`${record.provider}\0${record.sessionId}`);
         }
 
         let folder = folders.get(record.cwd);
+
         if (folder === undefined) {
             const resolved = await resolver.resolve(record.cwd);
             folder = resolved.folder;
             folders.set(record.cwd, folder);
+
             if (!projects.has(folder)) {
                 projects.set(folder, { folder, name: resolved.name, projectId: resolved.projectId, byProvider: new Map(), totals: emptyTotals(), costUsd: 0 });
             }
         }
+
         foldProject(projects.get(folder)!, record, cost);
     }
 

package/src/usage/exchange.ts

@@ -17,9 +17,11 @@ export function parseRate(document: unknown, currency: string): Omit<UsageRate,
     const body = typeof document === 'object' && document !== null ? (document as Record<string, unknown>) : null;
     const rates = body === null || typeof body.rates !== 'object' || body.rates === null ? null : (body.rates as Record<string, unknown>);
     const rate = rates === null ? undefined : rates[currency];
+
     if (typeof rate !== 'number' || !Number.isFinite(rate) || rate <= 0 || typeof body?.date !== 'string') {
         return null;
     }
+
     return { currency, rate, date: body.date };
 }
 
@@ -47,6 +49,7 @@ export class ExchangeRates {
     /* Reads the rate an earlier run stored, once; asking for a new one is left to `ensure`. */
     load(): Promise<void> {
         this.stored ??= this.readStored();
+
         return this.stored;
     }
 
@@ -57,6 +60,7 @@ export class ExchangeRates {
             .finally(() => {
                 this.inFlight = null;
             });
+
         return this.inFlight;
     }
 
@@ -67,6 +71,7 @@ export class ExchangeRates {
     private async readStored(): Promise<void> {
         try {
             const stored = JSON.parse(await readFile(this.file, 'utf8')) as UsageRate;
+
             if (stored?.currency === TARGET_CURRENCY && typeof stored.rate === 'number' && stored.rate > 0) {
                 this.rate = stored;
             }
@@ -81,16 +86,22 @@ export class ExchangeRates {
         if (!this.allowFetch || (this.rate !== null && Date.now() - this.rate.fetchedAt < TTL_MS)) {
             return false;
         }
+
         let changed = false;
+
         try {
             const response = await fetch(`${FRANKFURTER_URL}?from=USD&to=${TARGET_CURRENCY}`, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+
             if (!response.ok) {
                 throw new Error(`frankfurter.app answered ${response.status}`);
             }
+
             const parsed = parseRate(await response.json(), TARGET_CURRENCY);
+
             if (parsed === null) {
                 throw new Error(`The answer carried no ${TARGET_CURRENCY} rate`);
             }
+
             this.rate = { ...parsed, fetchedAt: Date.now() };
             changed = true;
             await mkdir(join(this.home, 'usage'), { recursive: true, mode: 0o700 });
@@ -99,6 +110,7 @@ export class ExchangeRates {
             // Yesterday's rate still converts; a rate that could not be refreshed is not a failure.
             console.warn('Could not refresh the exchange rate:', errorText(e));
         }
+
         return changed;
     }
 }

package/src/usage/index-file.ts

@@ -58,12 +58,15 @@ class Interner {
 
     index(value: string): number {
         const seen = this.at.get(value);
+
         if (seen !== undefined) {
             return seen;
         }
+
         const next = this.values.length;
         this.values.push(value);
         this.at.set(value, next);
+
         return next;
     }
 }
@@ -74,6 +77,7 @@ export function encodeIndex(index: UsageIndex): string {
     const folders = new Interner();
     const accounts = new Interner();
     const files: Record<string, FileRow> = {};
+
     const row = (record: UsageRecord): RecordRow => {
         const counted: RecordRow = [
             record.timestampMs,
@@ -90,14 +94,18 @@ export function encodeIndex(index: UsageIndex): string {
             record.dedupeKey ?? 0,
             record.account === undefined ? 0 : accounts.index(record.account) + 1
         ];
+
         if (record.costUsd !== undefined || record.serviceTier !== undefined) {
             counted[13] = record.costUsd;
         }
+
         if (record.serviceTier !== undefined) {
             counted[14] = record.serviceTier;
         }
+
         return counted;
     };
+
     for (const [path, file] of index) {
         files[path] = {
             p: file.provider,
@@ -112,6 +120,7 @@ export function encodeIndex(index: UsageIndex): string {
             ...(file.compressed === undefined ? {} : { z: file.compressed })
         };
     }
+
     const document: IndexFile = {
         version: INDEX_VERSION,
         models: models.values,
@@ -120,6 +129,7 @@ export function encodeIndex(index: UsageIndex): string {
         accounts: accounts.values,
         files
     };
+
     return JSON.stringify(document);
 }
 
@@ -142,12 +152,15 @@ function isRow(row: unknown, version: number): row is RecordRow {
 export function decodeIndex(text: string): UsageIndex {
     const index: UsageIndex = new Map();
     let document: IndexFile;
+
     try {
         document = JSON.parse(text) as IndexFile;
     } catch {
         return index;
     }
+
     const version = document?.version;
+
     if (
         (version !== INDEX_VERSION && version !== 2 && version !== ACCOUNTLESS_VERSION) ||
         !Array.isArray(document.models) ||
@@ -156,19 +169,26 @@ export function decodeIndex(text: string): UsageIndex {
     ) {
         return index;
     }
+
     const accounts = Array.isArray(document.accounts) ? document.accounts : [];
+
     const name = (table: string[], at: number): string | null => (typeof table[at] === 'string' ? table[at] : null);
+
     for (const [path, file] of Object.entries(document.files ?? {})) {
         // Every provider the schema knows, so a new one is never dropped from the index it was saved in.
         if (!UsageProviderSchema.safeParse(file.p).success) {
             continue;
         }
+
         if (typeof file.s !== 'number' || typeof file.m !== 'number' || typeof file.o !== 'number' || file.o < 0 || !Array.isArray(file.r)) {
             continue;
         }
+
         let broken = false;
+
         const decode = (rows: RecordRow[]): UsageRecord[] => {
             const records: UsageRecord[] = [];
+
             for (const row of rows) {
                 const valid = isRow(row, version);
                 const model = valid ? name(document.models, row[1]) : null;
@@ -176,10 +196,13 @@ export function decodeIndex(text: string): UsageIndex {
                 const cwd = valid ? name(document.folders, row[3]) : null;
                 const accountAt = valid ? (row[12] ?? 0) : 0;
                 const account = accountAt === 0 ? undefined : name(accounts, accountAt - 1);
+
                 if (!valid || model === null || sessionId === null || cwd === null || account === null) {
                     broken = true;
+
                     return records;
                 }
+
                 records.push({
                     provider: file.p,
                     timestampMs: row[0],
@@ -193,10 +216,13 @@ export function decodeIndex(text: string): UsageIndex {
                     dedupeKey: row[11] === 0 ? null : row[11]
                 });
             }
+
             return records;
         };
+
         const records = decode(file.r);
         const tail = decode(Array.isArray(file.t) ? file.t : []);
+
         if (!broken) {
             index.set(path, {
                 provider: file.p,
@@ -212,5 +238,6 @@ export function decodeIndex(text: string): UsageIndex {
             });
         }
     }
+
     return index;
 }

package/src/usage/limits/monitor.ts

@@ -62,7 +62,6 @@ export interface UsageMonitorOptions {
     providers: ProviderRegistry;
     /* The accounts to read; absent reads the default account of every CLI and names none. */
     accounts?: LimitAccounts;
-    /* How to ask; a test answers without starting a CLI. */
     probe?: (kind: UsageProvider, command: readonly string[], env: ProbeEnv) => Promise<ProbeResult>;
     /*
      * A plan the host reads itself, for a provider whose CLI cannot be asked (a subscription API the host calls,
@@ -100,6 +99,7 @@ export class UsageMonitor {
         this.plans = options.plans ?? {};
         this.probe = options.probe ?? ((kind, command, env) => (kind === 'claude' ? probeClaude(command, env) : probeCodex(command, env, options.client)));
         this.now = options.now ?? Date.now;
+
         for (const kind of PROVIDERS) {
             this.stateOf(kind, kind);
         }
@@ -113,8 +113,10 @@ export class UsageMonitor {
     snapshot(): UsageLimitsSnapshot {
         const providers = this.listed().map(({ id, kind, label, color }) => {
             const published = this.stateOf(kind, id).published;
+
             return this.accounts === null ? published : { ...published, account: { id, label, ...(color === undefined ? {} : { color }) } };
         });
+
         return { providers };
     }
 
@@ -136,6 +138,7 @@ export class UsageMonitor {
         this.inFlight ??= this.runAll(force).finally(() => {
             this.inFlight = null;
         });
+
         return this.inFlight;
     }
 
@@ -153,7 +156,9 @@ export class UsageMonitor {
         if (update.windows.length === 0) {
             return;
         }
+
         const state = this.stateOf(update.kind, update.account ?? update.kind);
+
         state.published = {
             ...state.published,
             plan: update.plan ?? state.published.plan,
@@ -162,27 +167,33 @@ export class UsageMonitor {
             windows: mergeWindows(state.published.windows, update.windows),
             unavailable: null
         };
+
         this.emit();
     }
 
     /* Every account of a CLI whose plan is read, the default one first. */
     private listed(): LimitAccount[] {
         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)];
         });
     }
 
     private stateOf(kind: UsageProvider, id: string): ProviderState {
         let state = this.states.get(id);
+
         if (state === undefined || state.kind !== kind) {
             state = { kind, published: blank(kind), backoffMs: PROBE_INTERVAL_MS, nextAt: 0 };
             this.states.set(id, state);
         }
+
         return state;
     }
 
@@ -191,48 +202,62 @@ export class UsageMonitor {
         if (force) {
             return true;
         }
+
         if (this.now() < state.nextAt) {
             return false;
         }
+
         if (account.isDefault) {
             return true;
         }
+
         const used = this.accounts?.lastUsedAt(account.id) ?? null;
+
         return used !== null && this.now() - used < RECENT_USE_MS;
     }
 
     private async runAll(force: boolean): Promise<void> {
         const installed = await this.registry.list();
         let changed = false;
+
         for (const account of this.listed()) {
             const { kind } = account;
             const state = this.stateOf(kind, account.id);
+
             if (!this.due(account, state, force)) {
                 continue;
             }
+
             const info = installed.find((provider) => provider.kind === kind);
+
             if (this.plans[kind] === undefined && (info === undefined || !info.installed)) {
                 state.published = { ...blank(kind), checkedAt: this.now(), unavailable: { reason: 'not-installed', message: null } };
                 state.nextAt = this.now() + PROBE_INTERVAL_MS;
                 changed = true;
+
                 continue;
             }
+
             // The next read is counted from when this one started, so a read that takes a few seconds does not push the tick of the clock past its time.
             const startedAt = this.now();
             const result = await this.read(account);
             const failed = 'unavailable' in result && result.unavailable?.reason === 'failed';
             state.backoffMs = failed ? Math.min(MAX_BACKOFF_MS, state.backoffMs * 2) : PROBE_INTERVAL_MS;
             state.nextAt = startedAt + state.backoffMs;
+
             if (failed && state.published.windows.length > 0) {
                 // A pass that could not reach the CLI leaves the last good numbers where they are.
                 continue;
             }
+
             state.published =
                 'unavailable' in result
                     ? { ...blank(kind), checkedAt: this.now(), unavailable: result.unavailable }
                     : { kind, plan: result.plan, checkedAt: this.now(), source: 'probe', windows: result.windows, cost: result.cost, unavailable: null };
+
             changed = true;
         }
+
         if (changed) {
             this.emit();
         }
@@ -240,6 +265,7 @@ export class UsageMonitor {
 
     private async read(account: LimitAccount): Promise<ProbeResult> {
         const plan = this.plans[account.kind];
+
         if (plan !== undefined) {
             try {
                 return await plan(account);
@@ -247,17 +273,19 @@ export class UsageMonitor {
                 return { unavailable: { reason: 'failed', message: errorText(e) } };
             }
         }
+
         let env: ProbeEnv;
+
         try {
             env = this.accounts === null ? definedEnv(process.env) : this.accounts.envFor(account.kind, account.id);
         } catch (e) {
             return { unavailable: { reason: 'failed', message: errorText(e) } };
         }
+
         return this.probe(account.kind, this.registry.get(account.kind).command, env);
     }
 
     private emit(): void {
-        const event: AgentEvent = { event: 'usage.limitsChanged', payload: this.snapshot() };
-        this.sinks.emit(event);
+        this.sinks.emit({ event: 'usage.limitsChanged', payload: this.snapshot() });
     }
 }

package/src/usage/limits/normalize.ts

@@ -36,12 +36,15 @@ export function kindOfDuration(durationMs: number | null): UsageWindow['kind'] {
     if (durationMs === null) {
         return 'other';
     }
+
     if (durationMs >= MONTH_MS) {
         return 'monthly';
     }
+
     if (durationMs >= WEEK_MS) {
         return 'weekly';
     }
+
     return 'session';
 }
 
@@ -68,33 +71,44 @@ export function readClaudeUsage(response: unknown): ProviderReading | { unavaila
     if (!isRecord(response)) {
         return { unavailable: { reason: 'failed', message: 'Claude Code returned no readable usage' } };
     }
+
     const plan = typeof response.subscription_type === 'string' ? response.subscription_type : null;
     const limits = isRecord(response.rate_limits) ? response.rate_limits : null;
+
     if (response.rate_limits_available === false || limits === null) {
         // An API key, Bedrock or Vertex account has no plan windows at all, which is not a failure.
         return { unavailable: { reason: 'no-subscription', message: null } };
     }
+
     const windows: UsageWindow[] = [];
+
     const push = (id: string, label: string, kind: UsageWindow['kind'], durationMs: number, entry: unknown): void => {
         const window = isRecord(entry) ? entry : null;
         const utilization = window === null ? null : num(window.utilization);
+
         if (utilization === null) {
             return;
         }
+
         const resetsAt = typeof window?.resets_at === 'string' ? Date.parse(window.resets_at) : Number.NaN;
         windows.push({ id, label, kind, used: fraction(utilization / 100), resetsAt: Number.isNaN(resetsAt) ? null : resetsAt, durationMs });
     };
+
     for (const known of CLAUDE_WINDOWS) {
         push(known.id, known.label, known.kind, known.durationMs, limits[known.key]);
     }
+
     for (const entry of Array.isArray(limits.model_scoped) ? limits.model_scoped : []) {
         const name = isRecord(entry) && typeof entry.display_name === 'string' ? entry.display_name : null;
+
         if (name !== null) {
             push(`seven_day_${slug(name)}`, `Weekly · ${name}`, 'weekly', WEEK_MS, entry);
         }
     }
+
     const session = isRecord(response.session) ? response.session : null;
     const sessionUsd = session === null ? null : num(session.total_cost_usd);
+
     return { plan, windows, cost: sessionUsd === null ? null : { sessionUsd } };
 }
 
@@ -103,11 +117,14 @@ export function readClaudeEvent(info: unknown): LimitsUpdate | null {
     const event = isRecord(info) ? info : null;
     const type = event !== null && typeof event.rateLimitType === 'string' ? event.rateLimitType : null;
     const utilization = event === null ? null : num(event.utilization);
+
     if (type === null || utilization === null) {
         return null;
     }
+
     const known = CLAUDE_WINDOWS.find((window) => window.key === type);
     const resetsAt = num(event?.resetsAt);
+
     return {
         kind: 'claude',
         windows: [
@@ -127,24 +144,30 @@ export function readClaudeEvent(info: unknown): LimitsUpdate | null {
  */
 export function readCodexLimits(snapshot: unknown): ProviderReading | null {
     const limits = isRecord(snapshot) ? snapshot : null;
+
     if (limits === null || (typeof limits.limitId === 'string' && limits.limitId !== 'codex')) {
         return null;
     }
+
     const plan = typeof limits.planType === 'string' ? limits.planType : null;
     const windows: UsageWindow[] = [];
+
     for (const [position, entry] of [
         ['primary', limits.primary],
         ['secondary', limits.secondary]
     ] as const) {
         const window = isRecord(entry) ? entry : null;
         const usedPercent = window === null ? null : num(window.usedPercent);
+
         if (usedPercent === null) {
             continue;
         }
+
         const minutes = num(window?.windowDurationMins);
         const durationMs = minutes === null ? null : Math.round(minutes * MINUTE_MS);
         const kind = kindOfDuration(durationMs);
         const resetsAt = num(window?.resetsAt);
+
         windows.push({
             id: position,
             kind,
@@ -154,6 +177,7 @@ export function readCodexLimits(snapshot: unknown): ProviderReading | null {
             durationMs
         });
     }
+
     return { plan, windows, cost: null };
 }
 
@@ -164,11 +188,14 @@ export function readCodexLimits(snapshot: unknown): ProviderReading | null {
  */
 export function mergeWindows(known: readonly UsageWindow[], updates: readonly Partial<UsageWindow>[]): UsageWindow[] {
     const merged = known.map((window) => ({ ...window }));
+
     for (const update of updates) {
         if (update.id === undefined || update.used === undefined) {
             continue;
         }
+
         const at = merged.findIndex((window) => window.id === update.id);
+
         if (at === -1) {
             merged.push({
                 id: update.id,
@@ -178,9 +205,12 @@ export function mergeWindows(known: readonly UsageWindow[], updates: readonly Pa
                 resetsAt: update.resetsAt ?? null,
                 durationMs: update.durationMs ?? null
             });
+
             continue;
         }
+
         merged[at] = { ...merged[at]!, ...update } as UsageWindow;
     }
+
     return merged;
 }