@adecore/agents 0.31.1 → 0.31.3

package/dist/chat/acp-backend.d.ts

@@ -1,5 +1,5 @@
 import { type ModelSelection } from '@adecore/agent-contracts';
-import { type AcpModeMap, type AcpSessionInfo } from './acp-protocol.ts';
+import { type AcpModeMap, type AcpPermissionRequest, type AcpSessionInfo, type AcpTurnUsage } from './acp-protocol.ts';
 import type { ApprovalDecision, BackendHost, BackendLaunch, ChatBackend, TurnInput } from './backend.ts';
 export interface AcpClientInfo {
     name: string;
@@ -16,6 +16,13 @@ export interface AcpAgentSpec {
     client?: AcpClientInfo;
     model?(selection: ModelSelection): string | null;
     onSession?(info: AcpSessionInfo): void;
+    onUsage?(usage: AcpUsageReport): void;
+    autoAllow?(request: AcpPermissionRequest): boolean;
+}
+export interface AcpUsageReport extends AcpTurnUsage {
+    sessionId: string;
+    cwd: string;
+    model: string;
 }
 export declare class AcpBackend implements ChatBackend {
     private readonly launch;
@@ -29,6 +36,7 @@ export declare class AcpBackend implements ChatBackend {
     private replaying;
     private contextPending;
     private prompt;
+    private model;
     constructor(launch: BackendLaunch, host: BackendHost, spec: AcpAgentSpec);
     get running(): boolean;
     get pid(): number | null;
@@ -52,7 +60,9 @@ export declare class AcpBackend implements ChatBackend {
     private respond;
     private fail;
     private handleFrame;
+    private hostAllows;
     private handleExit;
+    private report;
     private emitAll;
     private emit;
 }

package/dist/chat/acp-backend.js

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs';
 import { attachmentImageMime } from '@adecore/agent-contracts';
 import { errorText } from '../error-text.js';
 import { MODE_ORDER } from '../modes.js';
-import { ACP_AUTH_REQUIRED, ACP_PROTOCOL_VERSION, AcpProtocol, acpStopWords, autoAllows, parseInitialize, parseSessionInfo, resolveAcpMode, runtimeModeOf, sessionIdOf } from './acp-protocol.js';
+import { ACP_AUTH_REQUIRED, ACP_PROTOCOL_VERSION, AcpProtocol, acpStopWords, autoAllows, parseInitialize, parseSessionInfo, promptUsageOf, resolveAcpMode, runtimeModeOf, sessionIdOf } from './acp-protocol.js';
 import { attachmentNote } from './input.js';
 import { JsonRpcError, JsonRpcTransport } from './json-rpc-transport.js';
 export const DEFAULT_ACP_CLIENT = { name: 'agents', title: 'Agents', version: '0.1.0' };
@@ -30,6 +30,7 @@ export class AcpBackend {
     replaying = false;
     contextPending = null;
     prompt = null;
+    model = null;
     constructor(launch, host, spec) {
         this.launch = launch;
         this.host = host;
@@ -86,6 +87,7 @@ export class AcpBackend {
         const info = await this.openSession(transport, capabilities);
         const modeId = await this.applyMode(transport, info);
         const model = await this.applyModel(transport, info);
+        this.model = model;
         await this.applyThoughtLevel(transport, info);
         this.spec.onSession?.(info);
         this.emit({
@@ -265,6 +267,7 @@ export class AcpBackend {
             .then((result) => {
             if (this.transport === transport && this.prompt === turn) {
                 this.prompt = null;
+                this.report(result);
                 this.emitAll(this.protocol.finish(turn.cancelled ? { stopReason: 'cancelled' } : result, turn.promptId));
             }
         })
@@ -373,7 +376,7 @@ export class AcpBackend {
             }
             return;
         }
-        if (autoAllows(this.launch.runtimeMode, permission.kind)) {
+        if (autoAllows(this.launch.runtimeMode, permission.kind) || this.hostAllows(permission.request)) {
             this.emitAll(permission.events.filter((event) => event.type !== 'approval.requested'));
             const answer = this.protocol.answer(permission.requestId, 'allow');
             if (answer) {
@@ -383,6 +386,14 @@ export class AcpBackend {
         }
         this.emitAll(permission.events);
     }
+    hostAllows(request) {
+        try {
+            return this.spec.autoAllow?.(request) === true;
+        }
+        catch {
+            return false;
+        }
+    }
     handleExit(transport, exitCode, stderr) {
         if (this.transport !== transport) {
             return;
@@ -392,12 +403,23 @@ export class AcpBackend {
         this.protocol.cancelPermissions();
         this.emit({ type: 'exit', exitCode, ...(stderr === null ? {} : { stderr }) });
     }
+    /* A cancelled turn still spent what it reports. */
+    report(result) {
+        const usage = this.spec.onUsage === undefined ? null : promptUsageOf(result);
+        if (usage === null) {
+            return;
+        }
+        this.spec.onUsage?.({ ...usage, sessionId: this.sessionId, cwd: this.launch.cwd, model: this.model ?? this.launch.selection.model });
+    }
     emitAll(events) {
         for (const event of events) {
             this.emit(event);
         }
     }
     emit(event) {
+        if (event.type === 'model') {
+            this.model = event.model;
+        }
         this.host.onEvent(event);
     }
 }

package/dist/chat/acp-protocol.d.ts

@@ -9,6 +9,14 @@ declare const DiffSchema: z.ZodObject<{
     oldText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     newText: z.ZodString;
 }, z.core.$loose>;
+export interface AcpTurnUsage {
+    input: number;
+    cacheRead: number;
+    cacheWrite: number;
+    output: number;
+    reasoning: number;
+}
+export declare function promptUsageOf(result: unknown): AcpTurnUsage | null;
 export interface AcpAgentInfo {
     name: string;
     title: string | null;
@@ -19,6 +27,7 @@ export interface AcpAgentCapabilities {
     loadSession: boolean;
     resumeSession: boolean;
     additionalDirectories: boolean;
+    closeSession: boolean;
     images: boolean;
     authMethods: string[];
     agent: AcpAgentInfo | null;
@@ -83,10 +92,16 @@ export declare function toolRow(tool: Pick<ToolState, 'title' | 'name' | 'kind'
     input: Record<string, unknown>;
     changes?: ChatFileChange[];
 };
+export interface AcpPermissionRequest {
+    kind: string | null;
+    title: string | null;
+    commands: string[];
+}
 export interface AcpPermission {
     requestId: string;
     rpcId: number | string;
     kind: string | null;
+    request: AcpPermissionRequest;
     events: BackendEvent[];
 }
 export interface AcpStopWords {

package/dist/chat/acp-protocol.js

@@ -40,6 +40,36 @@ const PermissionRequestSchema = z.looseObject({
 });
 const SessionNotificationSchema = z.looseObject({ sessionId: z.string(), update: z.looseObject({ sessionUpdate: z.string() }) });
 const PromptResponseSchema = z.looseObject({ stopReason: z.string() });
+const tokenCount = z.number().int().nonnegative();
+// Unstable in the protocol (`PromptResponse.usage`); only the three totals are required.
+const PromptUsageSchema = z.looseObject({
+    totalTokens: tokenCount,
+    inputTokens: tokenCount,
+    outputTokens: tokenCount,
+    thoughtTokens: tokenCount.nullish(),
+    cachedReadTokens: tokenCount.nullish(),
+    cachedWriteTokens: tokenCount.nullish()
+});
+/*
+ * The `usage` a `session/prompt` response carries, or null where the agent reports none. The protocol
+ * leaves open whether the input holds the cached part, so the total decides: when the kinds add up
+ * to more than it, the input counted the cache too and loses it here.
+ */
+export function promptUsageOf(result) {
+    const response = z.looseObject({ usage: PromptUsageSchema }).safeParse(result);
+    if (!response.success) {
+        return null;
+    }
+    const usage = response.data.usage;
+    const cacheRead = usage.cachedReadTokens ?? 0;
+    const cacheWrite = usage.cachedWriteTokens ?? 0;
+    const apart = usage.inputTokens + usage.outputTokens + cacheRead + cacheWrite <= usage.totalTokens;
+    const input = apart ? usage.inputTokens : Math.max(0, usage.inputTokens - cacheRead - cacheWrite);
+    if (input + cacheRead + cacheWrite + usage.outputTokens === 0) {
+        return null;
+    }
+    return { input, cacheRead, cacheWrite, output: usage.outputTokens, reasoning: usage.thoughtTokens ?? 0 };
+}
 const ModeStateSchema = z.looseObject({
     currentModeId: z.string(),
     availableModes: z.array(z.unknown())
@@ -70,7 +100,8 @@ const InitializeResponseSchema = z.looseObject({
         sessionCapabilities: z
             .looseObject({
             resume: z.unknown().optional(),
-            additionalDirectories: z.unknown().optional()
+            additionalDirectories: z.unknown().optional(),
+            close: z.unknown().optional()
         })
             .optional()
     })
@@ -99,6 +130,7 @@ export function parseInitialize(result) {
         loadSession: capabilities?.loadSession === true,
         resumeSession: sessions?.resume !== undefined && sessions.resume !== null,
         additionalDirectories: sessions?.additionalDirectories !== undefined && sessions.additionalDirectories !== null,
+        closeSession: sessions?.close !== undefined && sessions.close !== null,
         images: capabilities?.promptCapabilities?.image === true,
         authMethods: validItems(AuthMethodSchema, parsed.data.authMethods).map((method) => method.id),
         agent: agent ? { name: agent.name, title: agent.title ?? null, version: agent.version } : null
@@ -414,7 +446,9 @@ export class AcpProtocol {
             description: tool.title === '' ? null : tool.title,
             canAllowAlways: options.some((option) => option.kind === 'allow_always')
         });
-        return { requestId, rpcId, kind: tool.kind, events };
+        const command = rawField(tool.rawInput, 'command', 'cmd');
+        const asked = { kind: tool.kind, title: tool.title === '' ? null : tool.title, commands: [...(command === null ? [] : [command]), ...tool.text] };
+        return { requestId, rpcId, kind: tool.kind, request: asked, events };
     }
     /*
      * The answer to a permission request: allow once, reject, or allow always only when the agent offered it.

package/dist/chat/index.d.ts

@@ -1,5 +1,5 @@
-export { type AcpAgentSpec, type AcpClientInfo, createAcpBackend } from './acp-backend.ts';
-export type { AcpAgentInfo, AcpModel, AcpModelState, AcpMode, AcpModeState, AcpSessionInfo, AcpModeMap } from './acp-protocol.ts';
+export { type AcpAgentSpec, type AcpClientInfo, type AcpUsageReport, createAcpBackend } from './acp-backend.ts';
+export type { AcpAgentInfo, AcpModel, AcpModelState, AcpMode, AcpModeState, AcpPermissionRequest, AcpSessionInfo, AcpModeMap, AcpTurnUsage } from './acp-protocol.ts';
 export { AttachmentStore } from './attachment-store.ts';
 export type { BackendLaunch, TurnInput, ApprovalDecision, BackendEvent, BackendHost, ChatBackend } from './backend.ts';
 export { runningInBackground, type BackgroundWork } from './background-work.ts';

package/dist/providers/accounts/acp-account.d.ts

@@ -0,0 +1,19 @@
+import { type AcpClientInfo } from '../../chat/acp-backend.ts';
+import { type AcpSessionInfo } from '../../chat/acp-protocol.ts';
+import type { SpawnChatProcess } from '../../chat/chat-process.ts';
+import { type AccountReading } from './status.ts';
+export interface ProbeTimer {
+    setTimeout(run: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+export interface AcpAccountProbe {
+    name: string;
+    command: readonly string[];
+    env: Record<string, string | undefined>;
+    client?: AcpClientInfo;
+    spawn?: SpawnChatProcess;
+    timeoutMs?: number;
+    timer?: ProbeTimer;
+    onSession?(info: AcpSessionInfo): void;
+}
+export declare function askAcpAccount(probe: AcpAccountProbe): Promise<AccountReading>;

package/dist/providers/accounts/acp-account.js

@@ -0,0 +1,101 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DEFAULT_ACP_CLIENT } from '../../chat/acp-backend.js';
+import { ACP_AUTH_REQUIRED, ACP_PROTOCOL_VERSION, parseInitialize, parseSessionInfo, sessionIdOf } from '../../chat/acp-protocol.js';
+import { JsonRpcError, JsonRpcTransport } from '../../chat/json-rpc-transport.js';
+import { ASK_TIMEOUT_MS } from './status.js';
+const SIGNED_OUT = { signedIn: false, email: null, plan: null, organization: null };
+const SIGNED_IN = { signedIn: true, email: null, plan: null, organization: null };
+const REAL_TIMER = {
+    setTimeout: (run, ms) => setTimeout(run, ms),
+    clearTimeout: (handle) => clearTimeout(handle)
+};
+function definedEnv(env) {
+    return Object.fromEntries(Object.entries(env).filter((entry) => entry[1] !== undefined));
+}
+function withDeadline(work, ms, timer, message) {
+    return new Promise((resolve, reject) => {
+        const handle = timer.setTimeout(() => reject(new Error(message)), ms);
+        work.then((value) => {
+            timer.clearTimeout(handle);
+            resolve(value);
+        }, (e) => {
+            timer.clearTimeout(handle);
+            reject(e instanceof Error ? e : new Error(String(e)));
+        });
+    });
+}
+/*
+ * Asks an ACP agent whether the account's environment is signed in: a session it opens means yes, "authentication
+ * required" means no. ACP has no request that says who, so a reading carries no email or plan. The session is opened
+ * in an empty folder of its own with no MCP servers, and `authenticate` is never sent: a probe must not start a login.
+ */
+export async function askAcpAccount(probe) {
+    const folder = await mkdtemp(join(tmpdir(), 'acp-account-'));
+    const client = probe.client ?? DEFAULT_ACP_CLIENT;
+    let transport = null;
+    try {
+        const started = new JsonRpcTransport({
+            command: [...probe.command],
+            cwd: folder,
+            env: definedEnv(probe.env),
+            ...(probe.spawn ? { spawn: probe.spawn } : {}),
+            label: probe.name,
+            errorName: 'AcpRpcError',
+            // The probe's own deadline covers every request.
+            requestTimeoutMs: null,
+            versionField: true,
+            onFrame: (frame) => refuseRequest(started, frame),
+            onExit: () => undefined
+        });
+        transport = started;
+        const reading = async () => {
+            const capabilities = parseInitialize(await started.request('initialize', {
+                protocolVersion: ACP_PROTOCOL_VERSION,
+                clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+                clientInfo: { name: client.name, title: client.title ?? client.name, version: client.version }
+            }));
+            if (capabilities.protocolVersion !== ACP_PROTOCOL_VERSION) {
+                throw new Error(`${probe.name} speaks ACP version ${capabilities.protocolVersion}; only version ${ACP_PROTOCOL_VERSION} is supported`);
+            }
+            let result;
+            try {
+                result = await started.request('session/new', { cwd: folder, mcpServers: [] });
+            }
+            catch (error) {
+                if (error instanceof JsonRpcError && error.code === ACP_AUTH_REQUIRED) {
+                    return SIGNED_OUT;
+                }
+                throw error;
+            }
+            const sessionId = sessionIdOf(result);
+            if (sessionId === null) {
+                throw new Error(`${probe.name} opened a session without an id`);
+            }
+            probe.onSession?.(parseSessionInfo(result, sessionId, capabilities.agent));
+            if (capabilities.closeSession) {
+                // The answer is known by now; an agent that cannot close it keeps an empty session, nothing worse.
+                await started.request('session/close', { sessionId }).catch(() => undefined);
+            }
+            return SIGNED_IN;
+        };
+        return await withDeadline(reading(), probe.timeoutMs ?? ASK_TIMEOUT_MS, probe.timer ?? REAL_TIMER, `${probe.name} did not answer in time`);
+    }
+    finally {
+        await transport?.dispose();
+        await rm(folder, { recursive: true, force: true });
+    }
+}
+/* The probe advertises nothing, so a request from the agent gets a refusal rather than a silence it would wait on. */
+function refuseRequest(transport, frame) {
+    if (frame.id === undefined || frame.id === null || !transport.alive) {
+        return;
+    }
+    try {
+        transport.respondError(frame.id, -32601, `Method not found: ${String(frame.method)}`);
+    }
+    catch {
+        // The agent closed its input; the deadline or the exit settles the probe.
+    }
+}

package/dist/providers/accounts/service.d.ts

@@ -33,6 +33,7 @@ export declare class ProviderAccountsService implements AccountLaunches {
     private readonly providers;
     private readonly env;
     private readonly ask;
+    private readonly asksEveryKind;
     private readonly prepareShadow;
     private readonly folderExists;
     private readonly install;

package/dist/providers/accounts/service.js

@@ -8,7 +8,7 @@ import { errorText } from '../../error-text.js';
 import { accountEnv, accountFolder, canContinue, defaultFolder, expandHome, isDefaultAccount, isOfferedKind, transcriptFolder } from './accounts.js';
 import { AccountError, isDefaultAccountOf } from './launch.js';
 import { prepareShadowHome } from './shadow-home.js';
-import { askAccountAs } from './status.js';
+import { ASKED_KINDS, askAccountAs } from './status.js';
 import { acceptAccounts, accountsPath, InvalidAccountError, readAccounts, wireAccounts, writeAccounts } from './store.js';
 import { DEFAULT_ACCOUNTS_HOST, platformSecrets, secretKey, SecretsUnavailableError } from './variables.js';
 /* Who is signed in changes by hand and rarely; often enough to notice, rarely enough not to start CLIs all day. */
@@ -61,6 +61,8 @@ export class ProviderAccountsService {
     providers;
     env;
     ask;
+    // A host's own `ask` is taken to answer for every kind; the default only for `ASKED_KINDS`.
+    asksEveryKind;
     prepareShadow;
     folderExists;
     install;
@@ -87,6 +89,7 @@ export class ProviderAccountsService {
         this.providers = options.providers;
         this.env = options.env ?? process.env;
         this.ask = options.ask ?? askAccountAs(options.client ?? DEFAULT_CODEX_CLIENT);
+        this.asksEveryKind = options.ask !== undefined;
         this.prepareShadow = options.prepareShadow ?? prepareShadowHome;
         this.folderExists = options.folderExists ?? isFolder;
         this.install = options.install;
@@ -106,10 +109,15 @@ export class ProviderAccountsService {
     snapshot() {
         const loginCommands = {};
         const chatLogins = [];
+        const silentLogins = [];
         for (const kind of this.kinds()) {
-            const home = this.providers.get(kind).home;
+            const provider = this.providers.get(kind);
+            const home = provider.home;
             if (home?.loginCommand !== undefined) {
                 loginCommands[kind] = home.loginCommand;
+                if (provider.askAccount === undefined && !this.asksEveryKind && !ASKED_KINDS.includes(kind)) {
+                    silentLogins.push(kind);
+                }
             }
             else if (home !== undefined) {
                 chatLogins.push(kind);
@@ -120,7 +128,8 @@ export class ProviderAccountsService {
             statuses: Object.entries(this.accounts).map(([id, account]) => this.statusOf(id, account)),
             secretsAvailable: this.secrets !== null,
             loginCommands,
-            ...(chatLogins.length > 0 ? { chatLogins } : {})
+            ...(chatLogins.length > 0 ? { chatLogins } : {}),
+            ...(silentLogins.length > 0 ? { silentLogins } : {})
         };
     }
     /* The account under an id, for a launch; null for an id this machine does not have. */
@@ -510,7 +519,8 @@ export class ProviderAccountsService {
             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));
+            const env = accountEnv(id, account, provider, this.env, values);
+            const reading = await (provider.askAccount ? provider.askAccount(provider.command, env) : this.ask(kind, provider.command, env));
             return this.status(id, account, reading.signedIn ? 'ready' : 'signed-out', {
                 email: reading.email,
                 plan: reading.plan,

package/dist/providers/accounts/status.d.ts

@@ -1,5 +1,6 @@
 import type { AgentKind } from '@adecore/agent-contracts';
 import { type CodexClientInfo } from '../../chat/codex-transport.ts';
+export declare const ASK_TIMEOUT_MS = 20000;
 export interface AccountReading {
     signedIn: boolean;
     email: string | null;
@@ -9,4 +10,5 @@ export interface AccountReading {
 export type AskAccount = (kind: AgentKind, command: readonly string[], env: Record<string, string | undefined>) => Promise<AccountReading>;
 export declare function readClaudeAuthStatus(output: string): AccountReading;
 export declare function readCodexAccount(answer: unknown): AccountReading;
+export declare const ASKED_KINDS: readonly AgentKind[];
 export declare function askAccountAs(client: CodexClientInfo): AskAccount;

package/dist/providers/accounts/status.js

@@ -3,7 +3,7 @@ import { withTimeout } from '../../async.js';
 import { CodexTransport } from '../../chat/codex-transport.js';
 import { runProcess } from '../../run-process.js';
 /* A CLI that has not said who is signed in by now is not going to; the next pass asks again. */
-const ASK_TIMEOUT_MS = 20_000;
+export const ASK_TIMEOUT_MS = 20_000;
 function text(value) {
     return typeof value === 'string' && value !== '' ? value : null;
 }
@@ -69,6 +69,8 @@ async function askCodex(command, env, client) {
         transport.kill();
     }
 }
+/* The kinds `askAccountAs` can ask; a provider with a reader of its own answers for itself. */
+export const ASKED_KINDS = ['claude', 'codex'];
 /* Starts the CLI in the account's environment and asks it; only Claude Code and Codex can say. */
 export function askAccountAs(client) {
     return (kind, command, env) => {

package/dist/providers/acp-provider.d.ts

@@ -19,5 +19,8 @@ export interface AcpProviderSpec extends AcpAgentSpec {
     firstPromptArgs?(prompt: string): string[];
     detect?(command: string, env: Record<string, string | undefined>): Promise<CliDetection>;
     enabled?(): boolean;
+    accountProbe?: boolean;
+    adoptModels?: boolean;
+    usageLog?: string;
 }
 export declare function createAcpProvider(spec: AcpProviderSpec): ChatProvider;

package/dist/providers/acp-provider.js

@@ -1,4 +1,6 @@
 import { createAcpBackend } from '../chat/acp-backend.js';
+import { askAcpAccount } from './accounts/acp-account.js';
+import { writeAcpUsage } from './acp-usage-log.js';
 import { detectCli } from './detect.js';
 /*
  * What every ACP agent can do through this backend. A file change comes as the text before and after;
@@ -21,8 +23,27 @@ export const ACP_CAPABILITIES = {
     reportsThinking: true,
     slashCommands: true
 };
+/* Agents whose own usage files the scanner reads; a log of their turns would count every one twice. */
+const OWN_USAGE_FILES = new Set(['grok']);
+/* An agent's model id may reach a command line, so one that reads as a flag is left out. */
+function adoptableModels(info) {
+    return (info.models?.models ?? []).filter((model) => model.id !== '' && !model.id.startsWith('-')).map((model) => ({ slug: model.id, name: model.name }));
+}
 export function createAcpProvider(spec) {
     const capabilities = { ...ACP_CAPABILITIES, ...spec.capabilities };
+    const onSession = (info) => {
+        if (spec.adoptModels !== false && info.models !== null) {
+            spec.catalog.adopt(adoptableModels(info), info.models.current);
+        }
+        spec.onSession?.(info);
+    };
+    const usageLog = spec.usageLog === undefined || OWN_USAGE_FILES.has(spec.kind) ? null : spec.usageLog;
+    const onUsage = usageLog === null
+        ? spec.onUsage
+        : (report) => {
+            writeAcpUsage(usageLog, report, Date.now());
+            spec.onUsage?.(report);
+        };
     return {
         kind: spec.kind,
         name: spec.name,
@@ -41,6 +62,17 @@ export function createAcpProvider(spec) {
                 throw new Error(`${spec.name} is only available as a chat.`);
             }),
         detect: spec.detect ?? ((command, env) => detectCli(command, env)),
-        createBackend: createAcpBackend(spec)
+        ...(spec.accountProbe === false
+            ? {}
+            : {
+                askAccount: (command, env) => askAcpAccount({
+                    name: spec.name,
+                    command,
+                    env: { ...env, ...spec.env },
+                    ...(spec.client ? { client: spec.client } : {}),
+                    onSession
+                })
+            }),
+        createBackend: createAcpBackend({ ...spec, onSession, ...(onUsage === undefined ? {} : { onUsage }) })
     };
 }

package/dist/providers/acp-usage-log.d.ts

@@ -0,0 +1,2 @@
+import type { AcpUsageReport } from '../chat/acp-backend.ts';
+export declare function writeAcpUsage(folder: string, report: AcpUsageReport, at: number): void;

package/dist/providers/acp-usage-log.js

@@ -0,0 +1,21 @@
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { errorText } from '../error-text.js';
+import { hostUsageLine } from '../usage/readers/host-log.js';
+/*
+ * Appends one turn to the session's own file in the folder, so a scan that hashes what it already read
+ * of a file never rereads the log of every other session. Written at once, since it is one line per turn.
+ */
+export function writeAcpUsage(folder, report, at) {
+    const { sessionId, cwd, model, ...tokens } = report;
+    try {
+        mkdirSync(folder, { recursive: true, mode: 0o700 });
+        appendFileSync(join(folder, `${encodeURIComponent(sessionId === '' ? 'session' : sessionId)}.jsonl`), hostUsageLine({ at, model, session: sessionId, cwd, ...tokens }), {
+            mode: 0o600
+        });
+    }
+    catch (e) {
+        // A turn whose line could not be written is missing from the usage page; the chat itself goes on.
+        console.warn('Could not write the usage of an ACP turn:', errorText(e));
+    }
+}

package/dist/providers/catalog.d.ts

@@ -8,6 +8,10 @@ export declare class ModelCatalog {
     constructor(data?: ModelCatalogInput);
     get defaultModel(): string;
     replace(data: ModelCatalogData): boolean;
+    adopt(models: ReadonlyArray<{
+        slug: string;
+        name: string;
+    }>, defaultModel: string): boolean;
     list(): ModelInfo[];
     nameOf(slug: string): string;
     resolveModel(name: string): string | null;

package/dist/providers/catalog.js

@@ -1,4 +1,5 @@
 import manifest from './claude-models.json' with { type: 'json' };
+const ADOPTED_PROFILE = 'agent';
 function timeOf(data) {
     return data.updatedAt === undefined ? 0 : Date.parse(data.updatedAt);
 }
@@ -26,6 +27,26 @@ export class ModelCatalog {
         this.data = data;
         return changed;
     }
+    /*
+     * Takes the models an agent reported for itself in place of the list, the agent's current model as the
+     * default and its order kept; answers whether the models changed. Every model gets the profile the
+     * default has now, as an agent names its models but not what each can be asked for.
+     */
+    adopt(models, defaultModel) {
+        if (models.length === 0 || !models.some((model) => model.slug === defaultModel)) {
+            return false;
+        }
+        const profile = this.profileOf(this.data.defaultModel) ?? { options: [], contextWindowTokens: {} };
+        const data = {
+            ...(this.data.updatedAt === undefined ? {} : { updatedAt: this.data.updatedAt }),
+            defaultModel,
+            profiles: { [ADOPTED_PROFILE]: profile },
+            models: models.map((model) => ({ slug: model.slug, name: model.name, profile: ADOPTED_PROFILE }))
+        };
+        const changed = JSON.stringify(data) !== JSON.stringify(this.data);
+        this.data = data;
+        return changed;
+    }
     list() {
         return this.data.models.map((model) => ({
             slug: model.slug,

package/dist/providers/index.d.ts

@@ -1,4 +1,5 @@
 export { ACP_CAPABILITIES, type AcpProviderSpec, createAcpProvider } from './acp-provider.ts';
+export { type AcpAccountProbe, askAcpAccount, type ProbeTimer } from './accounts/acp-account.ts';
 export { AccountError, type AccountLaunches, storedAccount, launchEnv } from './accounts/launch.ts';
 export { ProviderAccountsService, type ProviderAccountsOptions } from './accounts/service.ts';
 export type { ShadowHomeReport } from './accounts/shadow-home.ts';
@@ -11,5 +12,6 @@ export { type CodexRules, codexRulesText, codexRulesPathIn, defaultCodexHome, in
 export { codexThreadOptions, codexServiceTier } from './codex.ts';
 export { type CliDetection, detectCli } from './detect.ts';
 export type { ChatProvider, ProviderHome } from './provider.ts';
+export { isOnlyCommands } from './shell-commands.ts';
 export { ProviderRegistry, type ProviderRegistryOptions } from './registry.ts';
 export { MODE_ORDER, narrowerMode, ceilingForOpening, modeFlag } from '../modes.ts';

package/dist/providers/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 { ACP_CAPABILITIES, createAcpProvider } from './acp-provider.js';
+export { askAcpAccount } from './accounts/acp-account.js';
 export { AccountError, storedAccount, launchEnv } from './accounts/launch.js';
 export { ProviderAccountsService } from './accounts/service.js';
 export { variablesProblem, keychainService } from './accounts/variables.js';
@@ -9,5 +10,6 @@ export { createCodexProvider } from './codex-provider.js';
 export { codexRulesText, codexRulesPathIn, defaultCodexHome, installCodexRules } from './codex-rules.js';
 export { codexThreadOptions, codexServiceTier } from './codex.js';
 export { detectCli } from './detect.js';
+export { isOnlyCommands } from './shell-commands.js';
 export { ProviderRegistry } from './registry.js';
 export { MODE_ORDER, narrowerMode, ceilingForOpening, modeFlag } from '../modes.js';

package/dist/providers/provider.d.ts

@@ -1,5 +1,6 @@
 import type { AgentKind, ProviderCapabilities, ProviderInstall } from '@adecore/agent-contracts';
 import type { BackendHost, BackendLaunch, ChatBackend } from '../chat/backend.ts';
+import type { AccountReading } from './accounts/status.ts';
 import type { ModelCatalog } from './catalog.ts';
 import type { CliDetection } from './detect.ts';
 export interface ProviderHome {
@@ -23,5 +24,6 @@ export interface ChatProvider {
     firstPromptArgs(prompt: string): string[];
     detect(command: string, env: Record<string, string | undefined>): Promise<CliDetection>;
     enabled?(): boolean;
+    askAccount?(command: readonly string[], env: Record<string, string | undefined>): Promise<AccountReading>;
     createBackend(launch: BackendLaunch, host: BackendHost): ChatBackend;
 }

package/dist/providers/shell-commands.d.ts

@@ -0,0 +1 @@
+export declare function isOnlyCommands(command: string, allowed: readonly string[]): boolean;