@adecore/agents 0.30.0 → 0.31.0

package/dist/providers/accounts/service.js

@@ -105,17 +105,22 @@ export class ProviderAccountsService {
     }
     snapshot() {
         const loginCommands = {};
+        const chatLogins = [];
         for (const kind of this.kinds()) {
-            const command = this.providers.get(kind).home?.loginCommand;
-            if (command !== undefined) {
-                loginCommands[kind] = command;
+            const home = this.providers.get(kind).home;
+            if (home?.loginCommand !== undefined) {
+                loginCommands[kind] = home.loginCommand;
+            }
+            else if (home !== undefined) {
+                chatLogins.push(kind);
             }
         }
         return {
             accounts: this.accounts,
             statuses: Object.entries(this.accounts).map(([id, account]) => this.statusOf(id, account)),
             secretsAvailable: this.secrets !== null,
-            loginCommands
+            loginCommands,
+            ...(chatLogins.length > 0 ? { chatLogins } : {})
         };
     }
     /* The account under an id, for a launch; null for an id this machine does not have. */
@@ -501,6 +506,10 @@ export class ProviderAccountsService {
             if (missing !== null) {
                 throw new Error(`The keychain does not give the value of ${missing}`);
             }
+            // A CLI that signs in from its chat has no command that says who is signed in; its chat asks when it must.
+            if (provider.home.loginCommand === undefined) {
+                return this.status(id, account, 'ready', { message });
+            }
             const reading = await this.ask(kind, provider.command, accountEnv(id, account, provider, this.env, values));
             return this.status(id, account, reading.signedIn ? 'ready' : 'signed-out', {
                 email: reading.email,

package/dist/providers/provider.d.ts

@@ -6,7 +6,7 @@ export interface ProviderHome {
     readonly env: string;
     readonly fallback: string;
     readonly loginEnv: readonly string[];
-    readonly loginCommand: string;
+    readonly loginCommand?: string;
 }
 export interface ChatProvider {
     readonly kind: AgentKind;

package/dist/usage/index-file.d.ts

@@ -1,4 +1,4 @@
-import type { UsageProvider } from '@adecore/agent-contracts';
+import { type UsageProvider } from '@adecore/agent-contracts';
 import type { UsageRecord } from './record.ts';
 import type { CodexParserState } from './readers/codex.ts';
 export interface IndexedFile {

package/dist/usage/index-file.js

@@ -1,3 +1,4 @@
+import { UsageProviderSchema } from '@adecore/agent-contracts';
 /* Another version is thrown away rather than migrated, since rebuilding costs one cold scan; version 1 is read as it is. */
 const INDEX_VERSION = 2;
 /* Before accounts: every record was the default account's, so it reads as that without a scan. */
@@ -89,7 +90,8 @@ export function decodeIndex(text) {
     const accounts = Array.isArray(document.accounts) ? document.accounts : [];
     const name = (table, at) => (typeof table[at] === 'string' ? table[at] : null);
     for (const [path, file] of Object.entries(document.files ?? {})) {
-        if (file.p !== 'claude' && file.p !== 'codex') {
+        // 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)) {

package/dist/usage/index.d.ts

@@ -1,8 +1,9 @@
 export { usageAccountsOf, usageRootsOf, limitAccountsOf, chatSessionAccounts } from './accounts.ts';
 export { UsageMonitor, type ProbeEnv, type LimitAccount, type LimitAccounts, type UsageMonitorOptions } from './limits/monitor.ts';
-export type { LimitsUpdate, ProviderReading } from './limits/normalize.ts';
+export { fraction, type LimitsUpdate, type ProviderReading } from './limits/normalize.ts';
 export type { ProbeResult } from './limits/probe.ts';
 export { LITELLM_URL } from './pricing.ts';
+export { hostUsageLine, type HostUsageEntry } from './readers/host-log.ts';
 export type { KnownProject } from './projects.ts';
 export { type UsageRootPath, usageRoots } from './roots.ts';
 export type { UsageScannerOptions } from './scanner.ts';

package/dist/usage/index.js

@@ -1,6 +1,8 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
 export { usageAccountsOf, usageRootsOf, limitAccountsOf, chatSessionAccounts } from './accounts.js';
 export { UsageMonitor } from './limits/monitor.js';
+export { fraction } from './limits/normalize.js';
 export { LITELLM_URL } from './pricing.js';
+export { hostUsageLine } from './readers/host-log.js';
 export { usageRoots } from './roots.js';
 export { UsageService } from './usage-service.js';

package/dist/usage/limits/monitor.d.ts

@@ -1,4 +1,4 @@
-import type { UsageLimitsSnapshot, UsageProvider } from '@adecore/agent-contracts';
+import { type UsageLimitsSnapshot, type UsageProvider } from '@adecore/agent-contracts';
 import type { CodexClientInfo } from '../../chat/codex-transport.ts';
 import type { AgentSink } from '../../events.ts';
 import type { ProviderRegistry } from '../../providers/registry.ts';
@@ -21,6 +21,7 @@ export interface UsageMonitorOptions {
     providers: ProviderRegistry;
     accounts?: LimitAccounts;
     probe?: (kind: UsageProvider, command: readonly string[], env: ProbeEnv) => Promise<ProbeResult>;
+    plans?: Partial<Record<UsageProvider, () => Promise<ProbeResult>>>;
     now?: () => number;
     client?: CodexClientInfo;
 }
@@ -28,6 +29,7 @@ export declare class UsageMonitor {
     private readonly registry;
     private readonly accounts;
     private readonly probe;
+    private readonly plans;
     private readonly now;
     private readonly sinks;
     private readonly states;

package/dist/usage/limits/monitor.js

@@ -1,3 +1,4 @@
+import { USAGE_PROVIDERS } from '@adecore/agent-contracts';
 import { ClientSinks } from '../../client-sinks.js';
 import { errorText } from '../../error-text.js';
 import { definedEnv } from '../../providers/accounts/launch.js';
@@ -8,7 +9,7 @@ const PROBE_INTERVAL_MS = 5 * 60_000;
 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 = ['claude', 'codex'];
+const PROVIDERS = USAGE_PROVIDERS;
 function blank(kind) {
     return {
         kind,
@@ -24,12 +25,14 @@ function blank(kind) {
  * What is left of each plan, per account. Two sources feed it: a read of our own every five minutes,
  * which starts the CLI, asks and ends it, and the events a running turn streams in between, which
  * cost nothing and arrive the moment a number moves. Neither reads a credential: both CLIs already
- * hold their own login and answer the question themselves.
+ * hold their own login and answer the question themselves. A provider without a CLI is read by the
+ * host that holds its key (`plans`), on the same clock.
  */
 export class UsageMonitor {
     registry;
     accounts;
     probe;
+    plans;
     now;
     sinks = new ClientSinks();
     // By account id, so the default account of a CLI is under the CLI's kind.
@@ -39,6 +42,7 @@ export class UsageMonitor {
     constructor(options) {
         this.registry = options.providers;
         this.accounts = options.accounts ?? null;
+        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) {
@@ -138,16 +142,18 @@ export class UsageMonitor {
                 continue;
             }
             const info = installed.find((provider) => provider.kind === kind);
-            if (info === undefined || !info.installed) {
+            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 = this.now() + state.backoffMs;
+            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;
@@ -163,6 +169,15 @@ export class UsageMonitor {
         }
     }
     async read(account) {
+        const plan = this.plans[account.kind];
+        if (plan !== undefined) {
+            try {
+                return await plan();
+            }
+            catch (e) {
+                return { unavailable: { reason: 'failed', message: errorText(e) } };
+            }
+        }
         let env;
         try {
             env = this.accounts === null ? definedEnv(process.env) : this.accounts.envFor(account.kind, account.id);

package/dist/usage/limits/normalize.d.ts

@@ -12,6 +12,7 @@ export interface LimitsUpdate {
     plan?: string | null;
     windows: Partial<UsageWindow>[];
 }
+export declare function fraction(value: number): number;
 export declare function kindOfDuration(durationMs: number | null): UsageWindow['kind'];
 export declare function readClaudeUsage(response: unknown): ProviderReading | {
     unavailable: UsageLimitsProvider['unavailable'];

package/dist/usage/limits/normalize.js

@@ -6,7 +6,8 @@ const MONTH_MS = 30 * 24 * 60 * MINUTE_MS;
 function num(value) {
     return typeof value === 'number' && Number.isFinite(value) ? value : null;
 }
-function fraction(value) {
+/* A share of a plan used, held to the bar: a provider may report more than all of it. */
+export function fraction(value) {
     return Math.min(1, Math.max(0, value));
 }
 /* A window is named after how long it lasts, never after the position it came in. */

package/dist/usage/readers/host-log.d.ts

@@ -0,0 +1,16 @@
+import type { UsageProvider } from '@adecore/agent-contracts';
+import { type UsageRecord } from '../record.ts';
+export interface HostUsageEntry {
+    at: number;
+    model: string;
+    session: string;
+    cwd: string;
+    input: number;
+    cacheRead: number;
+    cacheWrite: number;
+    output: number;
+    reasoning: number;
+}
+export declare function hostUsageLine(entry: HostUsageEntry): string;
+export declare function hostLogMightCarryUsage(line: string): boolean;
+export declare function parseHostUsageLine(line: string, provider: UsageProvider): UsageRecord | null;

package/dist/usage/readers/host-log.js

@@ -0,0 +1,49 @@
+import { asObject, asString, int } from '../record.js';
+export function hostUsageLine(entry) {
+    return `${JSON.stringify(entry)}\n`;
+}
+/* A line of this log names its model, which keeps `JSON.parse` off anything else a folder holds. */
+export function hostLogMightCarryUsage(line) {
+    return line.includes('"model"');
+}
+/* The provider is the root's, so one reader serves every API a host logs. */
+export function parseHostUsageLine(line, provider) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    const entry = asObject(parsed);
+    if (entry === null) {
+        return null;
+    }
+    const model = asString(entry.model);
+    const timestampMs = typeof entry.at === 'number' && Number.isFinite(entry.at) ? entry.at : Number.NaN;
+    if (model === '' || Number.isNaN(timestampMs)) {
+        return null;
+    }
+    const totals = {
+        calls: 1,
+        input: int(entry.input),
+        cacheRead: int(entry.cacheRead),
+        cacheWrite: int(entry.cacheWrite),
+        cacheWrite1h: 0,
+        output: int(entry.output),
+        reasoning: int(entry.reasoning)
+    };
+    if (totals.input + totals.cacheRead + totals.cacheWrite + totals.output === 0) {
+        return null;
+    }
+    return {
+        provider,
+        timestampMs,
+        model,
+        sessionId: asString(entry.session),
+        cwd: asString(entry.cwd),
+        totals,
+        // Every line is a call of its own, so nothing is folded.
+        dedupeKey: null
+    };
+}

package/dist/usage/roots.js

@@ -1,6 +1,6 @@
 import { join } from 'node:path';
 import { homeFolder } from '../home-folder.js';
-/* Where in its config folder each CLI leaves its transcripts. */
+/* 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' };
 /* The transcripts of the default accounts, found through the variables the CLIs themselves read. */
 export function usageRoots(env = process.env) {
@@ -14,7 +14,11 @@ export function usageRoots(env = process.env) {
 export function accountRoots(folders) {
     const roots = new Map();
     for (const { id, kind, folder } of folders) {
-        const path = join(folder, TRANSCRIPTS[kind]);
+        const transcripts = TRANSCRIPTS[kind];
+        if (transcripts === undefined) {
+            continue;
+        }
+        const path = join(folder, transcripts);
         const key = `${kind}\0${path}`;
         const root = roots.get(key);
         if (root === undefined) {

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 { hostLogMightCarryUsage, parseHostUsageLine } from './readers/host-log.js';
 import { cloneCodexState, codexMightCarryUsage, createCodexState, parseCodexLine } from './readers/codex.js';
 import { usageRoots } from './roots.js';
 const HASH_CHUNK_BYTES = 65536;
@@ -93,8 +94,18 @@ function parseChunk(text, provider, from, state) {
                 }
                 continue;
             }
-            if (codex !== null && codexMightCarryUsage(line)) {
-                const record = parseCodexLine(line, codex);
+            if (provider === 'codex') {
+                if (codex !== null && codexMightCarryUsage(line)) {
+                    const record = parseCodexLine(line, codex);
+                    if (record !== null) {
+                        records.push(record);
+                    }
+                }
+                continue;
+            }
+            // Claude Code and Codex write transcripts of their own; every other provider is a log its host keeps.
+            if (hostLogMightCarryUsage(line)) {
+                const record = parseHostUsageLine(line, provider);
                 if (record !== null) {
                     records.push(record);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "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.30.0",
-    "@adecore/intelligent-ui": "0.30.0",
+    "@adecore/agent-contracts": "0.31.0",
+    "@adecore/intelligent-ui": "0.31.0",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/providers/accounts/service.ts

@@ -175,17 +175,21 @@ export class ProviderAccountsService implements AccountLaunches {
 
     snapshot(): ProviderAccounts {
         const loginCommands: Partial<Record<AgentKind, string>> = {};
+        const chatLogins: AgentKind[] = [];
         for (const kind of this.kinds()) {
-            const command = this.providers.get(kind).home?.loginCommand;
-            if (command !== undefined) {
-                loginCommands[kind] = command;
+            const home = this.providers.get(kind).home;
+            if (home?.loginCommand !== undefined) {
+                loginCommands[kind] = home.loginCommand;
+            } else if (home !== undefined) {
+                chatLogins.push(kind);
             }
         }
         return {
             accounts: this.accounts,
             statuses: Object.entries(this.accounts).map(([id, account]) => this.statusOf(id, account)),
             secretsAvailable: this.secrets !== null,
-            loginCommands
+            loginCommands,
+            ...(chatLogins.length > 0 ? { chatLogins } : {})
         };
     }
 
@@ -611,6 +615,10 @@ export class ProviderAccountsService implements AccountLaunches {
             if (missing !== null) {
                 throw new Error(`The keychain does not give the value of ${missing}`);
             }
+            // A CLI that signs in from its chat has no command that says who is signed in; its chat asks when it must.
+            if (provider.home.loginCommand === undefined) {
+                return this.status(id, account, 'ready', { message });
+            }
             const reading = await this.ask(kind, provider.command, accountEnv(id, account, provider, this.env, values));
             return this.status(id, account, reading.signedIn ? 'ready' : 'signed-out', {
                 email: reading.email,

package/src/providers/provider.ts

@@ -11,7 +11,8 @@ export interface ProviderHome {
     // Variables that sign the CLI in on their own, over whatever login the folder holds.
     readonly loginEnv: readonly string[];
     // What a person types in a terminal to sign in; the account's folder comes from the terminal's environment.
-    readonly loginCommand: string;
+    // Absent on a CLI that signs in from its first chat, which nothing outside that chat can ask about.
+    readonly loginCommand?: string;
 }
 
 /*

package/src/usage/index-file.ts

@@ -1,4 +1,4 @@
-import type { UsageProvider } from '@adecore/agent-contracts';
+import { UsageProviderSchema, type UsageProvider } from '@adecore/agent-contracts';
 import type { UsageRecord } from './record.ts';
 import type { CodexParserState } from './readers/codex.ts';
 
@@ -147,7 +147,8 @@ export function decodeIndex(text: string): UsageIndex {
     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 ?? {})) {
-        if (file.p !== 'claude' && file.p !== 'codex') {
+        // 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)) {

package/src/usage/index.ts

@@ -1,9 +1,10 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
 export { usageAccountsOf, usageRootsOf, limitAccountsOf, chatSessionAccounts } from './accounts.ts';
 export { UsageMonitor, type ProbeEnv, type LimitAccount, type LimitAccounts, type UsageMonitorOptions } from './limits/monitor.ts';
-export type { LimitsUpdate, ProviderReading } from './limits/normalize.ts';
+export { fraction, type LimitsUpdate, type ProviderReading } from './limits/normalize.ts';
 export type { ProbeResult } from './limits/probe.ts';
 export { LITELLM_URL } from './pricing.ts';
+export { hostUsageLine, type HostUsageEntry } from './readers/host-log.ts';
 export type { KnownProject } from './projects.ts';
 export { type UsageRootPath, usageRoots } from './roots.ts';
 export type { UsageScannerOptions } from './scanner.ts';

package/src/usage/limits/monitor.ts

@@ -1,4 +1,4 @@
-import type { UsageLimitsProvider, UsageLimitsSnapshot, UsageProvider } from '@adecore/agent-contracts';
+import { USAGE_PROVIDERS, type UsageLimitsProvider, type UsageLimitsSnapshot, type 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';
@@ -14,7 +14,7 @@ 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: readonly UsageProvider[] = ['claude', 'codex'];
+const PROVIDERS: readonly UsageProvider[] = USAGE_PROVIDERS;
 
 export type ProbeEnv = Record<string, string>;
 
@@ -62,6 +62,12 @@ export interface UsageMonitorOptions {
     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 with no CLI to ask (a subscription API the host calls with
+     * its own key). It answers in place of the probe, with no environment and no check that a CLI is installed:
+     * what it says is the whole story, a missing key included.
+     */
+    plans?: Partial<Record<UsageProvider, () => Promise<ProbeResult>>>;
     now?: () => number;
     // How the host names itself to the app-server a probe opens.
     client?: CodexClientInfo;
@@ -71,12 +77,14 @@ export interface UsageMonitorOptions {
  * What is left of each plan, per account. Two sources feed it: a read of our own every five minutes,
  * which starts the CLI, asks and ends it, and the events a running turn streams in between, which
  * cost nothing and arrive the moment a number moves. Neither reads a credential: both CLIs already
- * hold their own login and answer the question themselves.
+ * hold their own login and answer the question themselves. A provider without a CLI is read by the
+ * host that holds its key (`plans`), on the same clock.
  */
 export class UsageMonitor {
     private readonly registry: ProviderRegistry;
     private readonly accounts: LimitAccounts | null;
     private readonly probe: NonNullable<UsageMonitorOptions['probe']>;
+    private readonly plans: NonNullable<UsageMonitorOptions['plans']>;
     private readonly now: () => number;
     private readonly sinks = new ClientSinks<AgentEvent>();
     // By account id, so the default account of a CLI is under the CLI's kind.
@@ -87,6 +95,7 @@ export class UsageMonitor {
     constructor(options: UsageMonitorOptions) {
         this.registry = options.providers;
         this.accounts = options.accounts ?? null;
+        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) {
@@ -197,16 +206,18 @@ export class UsageMonitor {
                 continue;
             }
             const info = installed.find((provider) => provider.kind === kind);
-            if (info === undefined || !info.installed) {
+            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 = this.now() + state.backoffMs;
+            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;
@@ -223,6 +234,14 @@ export class UsageMonitor {
     }
 
     private async read(account: LimitAccount): Promise<ProbeResult> {
+        const plan = this.plans[account.kind];
+        if (plan !== undefined) {
+            try {
+                return await plan();
+            } catch (e) {
+                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);

package/src/usage/limits/normalize.ts

@@ -26,7 +26,8 @@ function num(value: unknown): number | null {
     return typeof value === 'number' && Number.isFinite(value) ? value : null;
 }
 
-function fraction(value: number): number {
+/* A share of a plan used, held to the bar: a provider may report more than all of it. */
+export function fraction(value: number): number {
     return Math.min(1, Math.max(0, value));
 }
 

package/src/usage/readers/host-log.ts

@@ -0,0 +1,72 @@
+import type { UsageProvider } from '@adecore/agent-contracts';
+import { asObject, asString, int, type UsageRecord } from '../record.ts';
+
+/*
+ * One call to an API a host makes itself, a line of the usage log it keeps. Such an API has no CLI and so
+ * no transcript, so the host writes this line for each call and the scanner reads the folder like one.
+ * The kinds are disjoint, as they are in a record: `input` is what was neither read from nor written to
+ * a cache, and `reasoning` is a part of `output`. Each host maps the counts of its own API onto them, since
+ * the APIs do not agree: some report a prompt that holds its cached part, some report the input apart from both
+ * cache kinds, and only some have a cache write at all.
+ */
+export interface HostUsageEntry {
+    at: number;
+    model: string;
+    session: string;
+    cwd: string;
+    input: number;
+    cacheRead: number;
+    cacheWrite: number;
+    output: number;
+    reasoning: number;
+}
+
+export function hostUsageLine(entry: HostUsageEntry): string {
+    return `${JSON.stringify(entry)}\n`;
+}
+
+/* A line of this log names its model, which keeps `JSON.parse` off anything else a folder holds. */
+export function hostLogMightCarryUsage(line: string): boolean {
+    return line.includes('"model"');
+}
+
+/* The provider is the root's, so one reader serves every API a host logs. */
+export function parseHostUsageLine(line: string, provider: UsageProvider): UsageRecord | null {
+    let parsed: unknown;
+    try {
+        parsed = JSON.parse(line);
+    } catch {
+        return null;
+    }
+    const entry = asObject(parsed);
+    if (entry === null) {
+        return null;
+    }
+    const model = asString(entry.model);
+    const timestampMs = typeof entry.at === 'number' && Number.isFinite(entry.at) ? entry.at : Number.NaN;
+    if (model === '' || Number.isNaN(timestampMs)) {
+        return null;
+    }
+    const totals = {
+        calls: 1,
+        input: int(entry.input),
+        cacheRead: int(entry.cacheRead),
+        cacheWrite: int(entry.cacheWrite),
+        cacheWrite1h: 0,
+        output: int(entry.output),
+        reasoning: int(entry.reasoning)
+    };
+    if (totals.input + totals.cacheRead + totals.cacheWrite + totals.output === 0) {
+        return null;
+    }
+    return {
+        provider,
+        timestampMs,
+        model,
+        sessionId: asString(entry.session),
+        cwd: asString(entry.cwd),
+        totals,
+        // Every line is a call of its own, so nothing is folded.
+        dedupeKey: null
+    };
+}

package/src/usage/roots.ts

@@ -9,8 +9,8 @@ export interface UsageRootPath {
     accounts?: string[];
 }
 
-/* Where in its config folder each CLI leaves its transcripts. */
-const TRANSCRIPTS: Record<UsageProvider, string> = { claude: 'projects', codex: 'sessions' };
+/* 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: Partial<Record<UsageProvider, string>> & Record<'claude' | 'codex', string> = { claude: 'projects', codex: 'sessions' };
 
 /* 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[] {
@@ -25,7 +25,11 @@ export function usageRoots(env: Record<string, string | undefined> = process.env
 export function accountRoots(folders: ReadonlyArray<{ id: string; kind: UsageProvider; folder: string }>): UsageRootPath[] {
     const roots = new Map<string, UsageRootPath & { accounts: string[] }>();
     for (const { id, kind, folder } of folders) {
-        const path = join(folder, TRANSCRIPTS[kind]);
+        const transcripts = TRANSCRIPTS[kind];
+        if (transcripts === undefined) {
+            continue;
+        }
+        const path = join(folder, transcripts);
         const key = `${kind}\0${path}`;
         const root = roots.get(key);
         if (root === undefined) {

package/src/usage/scanner.ts

@@ -1,12 +1,13 @@
 import { createHash, type Hash } from 'node:crypto';
 import { mkdir, open, readFile, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import type { UsageRoot } from '@adecore/agent-contracts';
+import type { UsageProvider, 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 { hostLogMightCarryUsage, parseHostUsageLine } from './readers/host-log.ts';
 import { cloneCodexState, codexMightCarryUsage, createCodexState, parseCodexLine, type CodexParserState } from './readers/codex.ts';
 import { usageRoots, type UsageRootPath } from './roots.ts';
 
@@ -98,7 +99,7 @@ async function listJsonl(dir: string, out: string[] = []): Promise<string[]> {
  * after the last newline is a line still being written, so it is parsed for what it is worth and
  * 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 {
+function parseChunk(text: string, provider: UsageProvider, from: number, state: CodexParserState | null): ParsedFile {
     const end = text.lastIndexOf('\n');
     const whole = end === -1 ? '' : text.slice(0, end);
     const tail = text.slice(end + 1);
@@ -118,8 +119,18 @@ function parseChunk(text: string, provider: 'claude' | 'codex', from: number, st
                 }
                 continue;
             }
-            if (codex !== null && codexMightCarryUsage(line)) {
-                const record = parseCodexLine(line, codex);
+            if (provider === 'codex') {
+                if (codex !== null && codexMightCarryUsage(line)) {
+                    const record = parseCodexLine(line, codex);
+                    if (record !== null) {
+                        records.push(record);
+                    }
+                }
+                continue;
+            }
+            // Claude Code and Codex write transcripts of their own; every other provider is a log its host keeps.
+            if (hostLogMightCarryUsage(line)) {
+                const record = parseHostUsageLine(line, provider);
                 if (record !== null) {
                     records.push(record);
                 }
@@ -265,7 +276,7 @@ export class UsageScanner {
         return foldByKey(all);
     }
 
-    private async readFileInto(path: string, provider: 'claude' | 'codex', accountOf: AccountOf): Promise<boolean> {
+    private async readFileInto(path: string, provider: UsageProvider, accountOf: AccountOf): Promise<boolean> {
         const info = await stat(path);
         const known = this.index.get(path);
         if (known !== undefined && known.provider === provider && known.size === info.size && known.mtimeMs === info.mtimeMs) {