@adecore/agents 0.29.3 → 0.31.0

package/dist/providers/index.js

@@ -1,4 +1,5 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
+export { ACP_CAPABILITIES, createAcpProvider } from './acp-provider.js';
 export { AccountError, storedAccount, launchEnv } from './accounts/launch.js';
 export { ProviderAccountsService } from './accounts/service.js';
 export { variablesProblem, keychainService } from './accounts/variables.js';

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/providers/registry.d.ts

@@ -18,6 +18,7 @@ export declare class ProviderRegistry {
     private readonly cache;
     constructor(options?: ProviderRegistryOptions);
     list(): Promise<ProviderInfo[]>;
+    kinds(): AgentKind[];
     get(kind: AgentKind): ChatProvider;
     oneShotProvider(preferred?: AgentKind): Promise<ChatProvider | null>;
     catalogFor(kind: AgentKind): ModelCatalog;

package/dist/providers/registry.js

@@ -68,6 +68,10 @@ export class ProviderRegistry {
             resumeCommand: provider.resumeCommand
         })));
     }
+    /* The kinds this host offers, in the order every menu lists them. */
+    kinds() {
+        return this.providers.map((provider) => provider.kind);
+    }
     /* The provider of a kind, one this host does not offer included. */
     get(kind) {
         return this.providers.find((provider) => provider.kind === kind) ?? this.fallback(kind);

package/dist/testing/fake-acp.d.ts

@@ -0,0 +1,10 @@
+import type { FakeCli } from './fake-cli.ts';
+export interface FakeAcpOptions {
+    loadSession?: boolean;
+    resumeSession?: boolean;
+    authMethod?: string;
+    modes?: readonly string[];
+    legacyModels?: boolean;
+}
+export declare function fakeAcpWith(options: FakeAcpOptions): FakeCli;
+export declare const fakeAcp: FakeCli;

package/dist/testing/fake-acp.js

@@ -0,0 +1,262 @@
+// The prompts of every session, outside any one process: a real agent keeps them on disk, so a later process loads them too.
+const sessionHistory = new Map();
+export function fakeAcpWith(options) {
+    return (io) => {
+        const modes = options.modes ?? ['ask', 'edit', 'yolo'];
+        let authenticated = options.authMethod === undefined;
+        let sessionId = '';
+        let mode = modes[0] ?? '';
+        let model = 'fake-small';
+        let serverRequestId = 0;
+        let callCounter = 0;
+        let prompt = null;
+        let permission = null;
+        const send = (frame) => {
+            io.out({ jsonrpc: '2.0', ...frame });
+        };
+        const respond = (id, result) => {
+            send({ id, result });
+        };
+        const refuse = (id, code, message) => {
+            send({ id, error: { code, message } });
+        };
+        const update = (fields) => {
+            send({ method: 'session/update', params: { sessionId, update: fields } });
+        };
+        const say = (text) => {
+            const half = Math.ceil(text.length / 2);
+            update({ sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: text.slice(0, half) } });
+            update({ sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: text.slice(half) } });
+        };
+        const endTurn = (stopReason) => {
+            if (prompt === null) {
+                return;
+            }
+            update({ sessionUpdate: 'usage_update', used: 1200, size: 200000, cost: { amount: 0.01, currency: 'USD' } });
+            respond(prompt.rpcId, { stopReason });
+            prompt = null;
+        };
+        const sessionState = () => {
+            const modelChoices = [
+                { value: 'fake-small', name: 'Fake small' },
+                { value: 'fake-large', name: 'Fake large' }
+            ];
+            return {
+                ...(modes.length === 0 ? {} : { modes: { currentModeId: mode, availableModes: modes.map((id) => ({ id, name: id })) } }),
+                ...(options.legacyModels
+                    ? { models: { currentModelId: model, availableModels: modelChoices.map((choice) => ({ modelId: choice.value, name: choice.name })) } }
+                    : { configOptions: [{ id: 'model', name: 'Model', type: 'select', category: 'model', currentValue: model, options: modelChoices }] })
+            };
+        };
+        const askPermission = (toolCall, onAnswer) => {
+            const rpcId = serverRequestId++;
+            permission = { rpcId, onAnswer };
+            send({
+                id: rpcId,
+                method: 'session/request_permission',
+                params: {
+                    sessionId,
+                    toolCall,
+                    options: [
+                        { optionId: 'once', name: 'Allow once', kind: 'allow_once' },
+                        { optionId: 'always', name: 'Always allow', kind: 'allow_always' },
+                        { optionId: 'no', name: 'Reject', kind: 'reject_once' }
+                    ]
+                }
+            });
+        };
+        const handlePrompt = (id, params) => {
+            const blocks = Array.isArray(params.prompt) ? params.prompt : [];
+            const text = blocks
+                .filter((block) => block.type === 'text')
+                .map((block) => String(block.text))
+                .join('\n');
+            const images = blocks.filter((block) => block.type === 'image').length;
+            const history = sessionHistory.get(sessionId) ?? [];
+            sessionHistory.set(sessionId, [...history, text]);
+            prompt = { rpcId: id, cancelled: false };
+            const last = text.split('\n\n').at(-1) ?? text;
+            if (last === 'history?') {
+                say(`prompts before: ${history.length}`);
+                endTurn('end_turn');
+                return;
+            }
+            if (last === 'mode?') {
+                say(`mode: ${mode}, model: ${model}`);
+                endTurn('end_turn');
+                return;
+            }
+            if (last === 'crash') {
+                io.exit(1);
+                return;
+            }
+            if (last === 'slow') {
+                say('working');
+                return;
+            }
+            if (last === 'plan') {
+                update({
+                    sessionUpdate: 'plan',
+                    entries: [
+                        { content: 'Read the code', priority: 'high', status: 'completed' },
+                        { content: 'Write the fix', priority: 'medium', status: 'in_progress' }
+                    ]
+                });
+                endTurn('end_turn');
+                return;
+            }
+            if (last === 'refuse' || last === 'max tokens') {
+                say('no');
+                endTurn(last === 'refuse' ? 'refusal' : 'max_tokens');
+                return;
+            }
+            if (last.startsWith('edit:')) {
+                const path = last.slice(5).trim();
+                const toolCallId = `call-${++callCounter}`;
+                const content = [{ type: 'diff', path, oldText: 'one\ntwo\n', newText: 'one\nthree\n' }];
+                update({ sessionUpdate: 'tool_call', toolCallId, title: `Edit ${path}`, kind: 'edit', status: 'pending', locations: [{ path }] });
+                askPermission({ toolCallId, title: `Edit ${path}`, kind: 'edit', content }, (outcome) => {
+                    const allowed = outcome.outcome === 'selected' && outcome.optionId !== 'no';
+                    update({ sessionUpdate: 'tool_call_update', toolCallId, status: allowed ? 'completed' : 'failed', content });
+                    endTurn(outcome.outcome === 'cancelled' ? 'cancelled' : 'end_turn');
+                });
+                return;
+            }
+            if (last.startsWith('tool:')) {
+                const command = last.slice(5).trim();
+                const toolCallId = `call-${++callCounter}`;
+                update({ sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text: 'I should run it.' } });
+                update({ sessionUpdate: 'tool_call', toolCallId, title: `Run ${command}`, kind: 'execute', status: 'pending', rawInput: { command } });
+                askPermission({ toolCallId }, (outcome) => {
+                    if (outcome.outcome === 'cancelled') {
+                        update({ sessionUpdate: 'tool_call_update', toolCallId, status: 'failed' });
+                        endTurn('cancelled');
+                        return;
+                    }
+                    if (outcome.optionId === 'no') {
+                        update({
+                            sessionUpdate: 'tool_call_update',
+                            toolCallId,
+                            status: 'failed',
+                            content: [{ type: 'content', content: { type: 'text', text: 'rejected' } }]
+                        });
+                        say('not run');
+                        endTurn('end_turn');
+                        return;
+                    }
+                    update({ sessionUpdate: 'tool_call_update', toolCallId, status: 'in_progress' });
+                    update({
+                        sessionUpdate: 'tool_call_update',
+                        toolCallId,
+                        status: 'completed',
+                        content: [{ type: 'content', content: { type: 'text', text: `ran ${command} (${String(outcome.optionId)})` } }]
+                    });
+                    say('done');
+                    endTurn('end_turn');
+                });
+                return;
+            }
+            update({ sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text: 'Thinking.' } });
+            say(`echo: ${text}${images > 0 ? ` (${images} images)` : ''}`);
+            endTurn('end_turn');
+        };
+        const handle = (frame) => {
+            const id = frame.id;
+            const params = (typeof frame.params === 'object' && frame.params !== null ? frame.params : {});
+            if (frame.method === undefined) {
+                // The client's answer to a permission request.
+                if (permission !== null && id === permission.rpcId) {
+                    const answered = permission;
+                    permission = null;
+                    const result = frame.result;
+                    answered.onAnswer(result?.outcome ?? { outcome: 'cancelled' });
+                }
+                return;
+            }
+            switch (frame.method) {
+                case 'initialize':
+                    respond(id, {
+                        protocolVersion: 1,
+                        agentCapabilities: {
+                            loadSession: options.loadSession ?? true,
+                            promptCapabilities: { image: true, audio: false, embeddedContext: false },
+                            sessionCapabilities: options.resumeSession ? { resume: {} } : {}
+                        },
+                        authMethods: options.authMethod === undefined ? [] : [{ id: options.authMethod, name: 'Sign in' }],
+                        agentInfo: { name: 'fake-acp', title: 'Fake ACP', version: '0.0.1' }
+                    });
+                    return;
+                case 'authenticate':
+                    authenticated = params.methodId === options.authMethod;
+                    respond(id, {});
+                    return;
+                case 'session/new':
+                    if (!authenticated) {
+                        refuse(id, -32000, 'Authentication required');
+                        return;
+                    }
+                    sessionId = `fake-session-${Math.random().toString(36).slice(2, 8)}`;
+                    sessionHistory.set(sessionId, []);
+                    respond(id, { sessionId, ...sessionState() });
+                    return;
+                case 'session/load':
+                case 'session/resume': {
+                    const history = sessionHistory.get(String(params.sessionId));
+                    if (!authenticated) {
+                        refuse(id, -32000, 'Authentication required');
+                        return;
+                    }
+                    if (history === undefined) {
+                        refuse(id, -32002, 'Session not found');
+                        return;
+                    }
+                    sessionId = String(params.sessionId);
+                    if (frame.method === 'session/load') {
+                        for (const earlier of history) {
+                            update({ sessionUpdate: 'user_message_chunk', content: { type: 'text', text: earlier } });
+                            update({ sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'replayed' } });
+                        }
+                    }
+                    respond(id, sessionState());
+                    return;
+                }
+                case 'session/set_mode':
+                    mode = String(params.modeId);
+                    respond(id, {});
+                    update({ sessionUpdate: 'current_mode_update', currentModeId: mode });
+                    return;
+                case 'session/set_model':
+                    model = String(params.modelId);
+                    respond(id, {});
+                    return;
+                case 'session/set_config_option':
+                    if (params.configId === 'model') {
+                        model = String(params.value);
+                    }
+                    respond(id, { configOptions: sessionState().configOptions ?? [] });
+                    return;
+                case 'session/prompt':
+                    handlePrompt(id, params);
+                    return;
+                case 'session/cancel':
+                    if (prompt !== null) {
+                        prompt.cancelled = true;
+                        if (permission === null) {
+                            endTurn('cancelled');
+                        }
+                    }
+                    return;
+                default:
+                    if (id !== undefined) {
+                        refuse(id, -32601, `Method not found: ${String(frame.method)}`);
+                    }
+            }
+        };
+        return {
+            onLine: (line) => {
+                handle(JSON.parse(line));
+            }
+        };
+    };
+}
+export const fakeAcp = fakeAcpWith({});

package/dist/testing/index.d.ts

@@ -1,4 +1,5 @@
 export { type FakeIo, type FakeProgram, type FakeCli, type StartedFake, type InProcessCli, inProcess, runOverStdio } from './fake-cli.ts';
+export { type FakeAcpOptions, fakeAcpWith, fakeAcp } from './fake-acp.ts';
 export { fakeClaude, claudeStoppingOnResume } from './fake-claude.ts';
 export { FAKE_CHILD_STEPS, fakeCodexForks, type FakeCodexOptions, fakeCodexWith, fakeCodex } from './fake-codex.ts';
 export { testAccounts } from './accounts.ts';

package/dist/testing/index.js

@@ -1,5 +1,6 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
 export { inProcess, runOverStdio } from './fake-cli.js';
+export { fakeAcpWith, fakeAcp } from './fake-acp.js';
 export { fakeClaude, claudeStoppingOnResume } from './fake-claude.js';
 export { FAKE_CHILD_STEPS, fakeCodexForks, fakeCodexWith, fakeCodex } from './fake-codex.js';
 export { testAccounts } from './accounts.js';

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.29.3",
+  "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.29.3",
-    "@adecore/intelligent-ui": "0.29.3",
+    "@adecore/agent-contracts": "0.31.0",
+    "@adecore/intelligent-ui": "0.31.0",
     "zod": "^4.6.5"
   },
   "devDependencies": {