@adecore/agents 0.31.1 → 0.31.2

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

@@ -19,6 +19,7 @@ export interface AcpAgentCapabilities {
     loadSession: boolean;
     resumeSession: boolean;
     additionalDirectories: boolean;
+    closeSession: boolean;
     images: boolean;
     authMethods: string[];
     agent: AcpAgentInfo | null;

package/dist/chat/acp-protocol.js

@@ -70,7 +70,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 +100,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

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,7 @@ 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;
 }
 export declare function createAcpProvider(spec: AcpProviderSpec): ChatProvider;

package/dist/providers/acp-provider.js

@@ -1,4 +1,5 @@
 import { createAcpBackend } from '../chat/acp-backend.js';
+import { askAcpAccount } from './accounts/acp-account.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 +22,18 @@ export const ACP_CAPABILITIES = {
     reportsThinking: true,
     slashCommands: true
 };
+/* 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);
+    };
     return {
         kind: spec.kind,
         name: spec.name,
@@ -41,6 +52,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 })
     };
 }

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';

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';

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/testing/fake-acp.d.ts

@@ -5,6 +5,7 @@ export interface FakeAcpOptions {
     authMethod?: string;
     modes?: readonly string[];
     legacyModels?: boolean;
+    closeSession?: boolean;
 }
 export declare function fakeAcpWith(options: FakeAcpOptions): FakeCli;
 export declare const fakeAcp: FakeCli;

package/dist/testing/fake-acp.js

@@ -180,7 +180,7 @@ export function fakeAcpWith(options) {
                         agentCapabilities: {
                             loadSession: options.loadSession ?? true,
                             promptCapabilities: { image: true, audio: false, embeddedContext: false },
-                            sessionCapabilities: options.resumeSession ? { resume: {} } : {}
+                            sessionCapabilities: { ...(options.resumeSession ? { resume: {} } : {}), ...(options.closeSession ? { close: {} } : {}) }
                         },
                         authMethods: options.authMethod === undefined ? [] : [{ id: options.authMethod, name: 'Sign in' }],
                         agentInfo: { name: 'fake-acp', title: 'Fake ACP', version: '0.0.1' }
@@ -220,6 +220,14 @@ export function fakeAcpWith(options) {
                     respond(id, sessionState());
                     return;
                 }
+                case 'session/close':
+                    if (!options.closeSession) {
+                        refuse(id, -32601, 'Method not found: session/close');
+                        return;
+                    }
+                    sessionHistory.delete(String(params.sessionId));
+                    respond(id, {});
+                    return;
                 case 'session/set_mode':
                     mode = String(params.modeId);
                     respond(id, {});

package/package.json

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

package/src/chat/acp-protocol.ts

@@ -95,7 +95,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()
         })
@@ -126,6 +127,8 @@ export interface AcpAgentCapabilities {
     loadSession: boolean;
     resumeSession: boolean;
     additionalDirectories: boolean;
+    // Whether the agent takes `session/close`, which ends a session it would otherwise keep.
+    closeSession: boolean;
     images: boolean;
     authMethods: string[];
     agent: AcpAgentInfo | null;
@@ -144,6 +147,7 @@ export function parseInitialize(result: unknown): AcpAgentCapabilities {
         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

package/src/providers/accounts/acp-account.ts

@@ -0,0 +1,129 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DEFAULT_ACP_CLIENT, type AcpClientInfo } from '../../chat/acp-backend.ts';
+import { ACP_AUTH_REQUIRED, ACP_PROTOCOL_VERSION, parseInitialize, parseSessionInfo, sessionIdOf, type AcpSessionInfo } from '../../chat/acp-protocol.ts';
+import type { SpawnChatProcess } from '../../chat/chat-process.ts';
+import { JsonRpcError, JsonRpcTransport, type JsonRpcFrame } from '../../chat/json-rpc-transport.ts';
+import { ASK_TIMEOUT_MS, type AccountReading } from './status.ts';
+
+/* The clock the probe's deadline runs on; a test hands in one it moves itself. */
+export interface ProbeTimer {
+    setTimeout(run: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+
+export interface AcpAccountProbe {
+    // The agent as a person reads it, in the error a failed read carries.
+    name: string;
+    command: readonly string[];
+    env: Record<string, string | undefined>;
+    client?: AcpClientInfo;
+    spawn?: SpawnChatProcess;
+    timeoutMs?: number;
+    timer?: ProbeTimer;
+    // What the probe's session offered, for a host that fills its model catalog from the agent.
+    onSession?(info: AcpSessionInfo): void;
+}
+
+const SIGNED_OUT: AccountReading = { signedIn: false, email: null, plan: null, organization: null };
+const SIGNED_IN: AccountReading = { signedIn: true, email: null, plan: null, organization: null };
+
+const REAL_TIMER: ProbeTimer = {
+    setTimeout: (run, ms) => setTimeout(run, ms),
+    clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>)
+};
+
+function definedEnv(env: Record<string, string | undefined>): Record<string, string> {
+    return Object.fromEntries(Object.entries(env).filter((entry): entry is [string, string] => entry[1] !== undefined));
+}
+
+function withDeadline<T>(work: Promise<T>, ms: number, timer: ProbeTimer, message: string): Promise<T> {
+    return new Promise((resolve, reject) => {
+        const handle = timer.setTimeout(() => reject(new Error(message)), ms);
+        work.then(
+            (value) => {
+                timer.clearTimeout(handle);
+                resolve(value);
+            },
+            (e: unknown) => {
+                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: AcpAccountProbe): Promise<AccountReading> {
+    const folder = await mkdtemp(join(tmpdir(), 'acp-account-'));
+    const client = probe.client ?? DEFAULT_ACP_CLIENT;
+    let transport: JsonRpcTransport | null = 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 (): Promise<AccountReading> => {
+            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: unknown;
+            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: JsonRpcTransport, frame: JsonRpcFrame): void {
+    if (frame.id === undefined || frame.id === null || !transport.alive) {
+        return;
+    }
+    try {
+        transport.respondError(frame.id as number | string, -32601, `Method not found: ${String(frame.method)}`);
+    } catch {
+        // The agent closed its input; the deadline or the exit settles the probe.
+    }
+}

package/src/providers/accounts/service.ts

@@ -32,7 +32,7 @@ import {
 } from './accounts.ts';
 import { AccountError, isDefaultAccountOf, type AccountLaunches } from './launch.ts';
 import { prepareShadowHome, type ShadowHomeReport } from './shadow-home.ts';
-import { askAccountAs, type AskAccount } from './status.ts';
+import { ASKED_KINDS, askAccountAs, type AskAccount } from './status.ts';
 import { acceptAccounts, accountsPath, InvalidAccountError, readAccounts, wireAccounts, writeAccounts, type StoredAccounts } from './store.ts';
 import { DEFAULT_ACCOUNTS_HOST, platformSecrets, secretKey, SecretsUnavailableError, type AccountsHost, type SecretStore } from './variables.ts';
 
@@ -52,7 +52,7 @@ export interface ProviderAccountsOptions {
     // `kinds` are the CLIs that get a default account; absent, every kind this version knows.
     providers: { list(): Promise<ProviderInfo[]>; get(kind: AgentKind): ChatProvider; enabled?(kind: AgentKind): boolean; kinds?(): readonly AgentKind[] };
     env?: Env;
-    // How to ask a CLI who is signed in; a test answers without starting one.
+    // How to ask a CLI who is signed in, for every kind whose provider has no reader of its own; a test answers without starting one.
     ask?: AskAccount;
     prepareShadow?: (home: string, shadow: string) => Promise<ShadowHomeReport>;
     folderExists?: (path: string) => boolean;
@@ -127,6 +127,8 @@ export class ProviderAccountsService implements AccountLaunches {
     private readonly providers: ProviderAccountsOptions['providers'];
     private readonly env: Env;
     private readonly ask: AskAccount;
+    // A host's own `ask` is taken to answer for every kind; the default only for `ASKED_KINDS`.
+    private readonly asksEveryKind: boolean;
     private readonly prepareShadow: NonNullable<ProviderAccountsOptions['prepareShadow']>;
     private readonly folderExists: NonNullable<ProviderAccountsOptions['folderExists']>;
     private readonly install: ProviderAccountsOptions['install'];
@@ -154,6 +156,7 @@ export class ProviderAccountsService implements AccountLaunches {
         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;
@@ -176,10 +179,15 @@ export class ProviderAccountsService implements AccountLaunches {
     snapshot(): ProviderAccounts {
         const loginCommands: Partial<Record<AgentKind, string>> = {};
         const chatLogins: AgentKind[] = [];
+        const silentLogins: AgentKind[] = [];
         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);
             }
@@ -189,7 +197,8 @@ export class ProviderAccountsService implements AccountLaunches {
             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 } : {})
         };
     }
 
@@ -619,7 +628,8 @@ export class ProviderAccountsService implements AccountLaunches {
             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/src/providers/accounts/status.ts

@@ -5,7 +5,7 @@ import { CodexTransport, type CodexClientInfo } from '../../chat/codex-transport
 import { runProcess } from '../../run-process.ts';
 
 /* 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;
 
 /* Who a CLI says is signed in, from the CLI itself; the host never opens a credential. */
 export interface AccountReading {
@@ -89,6 +89,9 @@ async function askCodex(command: readonly string[], env: Record<string, string |
     }
 }
 
+/* The kinds `askAccountAs` can ask; a provider with a reader of its own answers for itself. */
+export const ASKED_KINDS: readonly AgentKind[] = ['claude', 'codex'];
+
 /* Starts the CLI in the account's environment and asks it; only Claude Code and Codex can say. */
 export function askAccountAs(client: CodexClientInfo): AskAccount {
     return (kind, command, env) => {

package/src/providers/acp-provider.ts

@@ -1,5 +1,7 @@
 import type { AgentKind, ProviderCapabilities, ProviderInstall } from '@adecore/agent-contracts';
 import { createAcpBackend, type AcpAgentSpec } from '../chat/acp-backend.ts';
+import type { AcpSessionInfo } from '../chat/acp-protocol.ts';
+import { askAcpAccount } from './accounts/acp-account.ts';
 import type { ModelCatalog } from './catalog.ts';
 import { detectCli, type CliDetection } from './detect.ts';
 import type { ChatProvider, ProviderHome } from './provider.ts';
@@ -47,10 +49,25 @@ export interface AcpProviderSpec extends AcpAgentSpec {
     // Absent asks the executable for `--version`.
     detect?(command: string, env: Record<string, string | undefined>): Promise<CliDetection>;
     enabled?(): boolean;
+    // Absent or true asks the agent over ACP whether an account is signed in; false leaves that to the host.
+    accountProbe?: boolean;
+    // Absent or true lets the models a session reports replace the catalog's; false keeps the catalog as the host built it.
+    adoptModels?: boolean;
+}
+
+/* An agent's model id may reach a command line, so one that reads as a flag is left out. */
+function adoptableModels(info: AcpSessionInfo): Array<{ slug: string; name: string }> {
+    return (info.models?.models ?? []).filter((model) => model.id !== '' && !model.id.startsWith('-')).map((model) => ({ slug: model.id, name: model.name }));
 }
 
 export function createAcpProvider(spec: AcpProviderSpec): ChatProvider {
     const capabilities = { ...ACP_CAPABILITIES, ...spec.capabilities };
+    const onSession = (info: AcpSessionInfo): void => {
+        if (spec.adoptModels !== false && info.models !== null) {
+            spec.catalog.adopt(adoptableModels(info), info.models.current);
+        }
+        spec.onSession?.(info);
+    };
     return {
         kind: spec.kind,
         name: spec.name,
@@ -70,6 +87,18 @@ export function createAcpProvider(spec: AcpProviderSpec): ChatProvider {
                 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 })
     };
 }

package/src/providers/catalog.ts

@@ -4,6 +4,8 @@ import manifest from './claude-models.json' with { type: 'json' };
 // What a host builds a catalog from; one that is never replaced needs no date.
 export type ModelCatalogInput = Omit<ModelCatalogData, 'updatedAt'> & { updatedAt?: string };
 
+const ADOPTED_PROFILE = 'agent';
+
 function timeOf(data: ModelCatalogInput): number {
     return data.updatedAt === undefined ? 0 : Date.parse(data.updatedAt);
 }
@@ -36,6 +38,27 @@ export class ModelCatalog {
         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: ReadonlyArray<{ slug: string; name: string }>, defaultModel: string): boolean {
+        if (models.length === 0 || !models.some((model) => model.slug === defaultModel)) {
+            return false;
+        }
+        const profile = this.profileOf(this.data.defaultModel) ?? { options: [], contextWindowTokens: {} };
+        const data: ModelCatalogInput = {
+            ...(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(): ModelInfo[] {
         return this.data.models.map((model) => ({
             slug: model.slug,

package/src/providers/index.ts

@@ -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, 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';

package/src/providers/provider.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';
 
@@ -47,5 +48,7 @@ export interface ChatProvider {
     detect(command: string, env: Record<string, string | undefined>): Promise<CliDetection>;
     // Whether a person turned this provider on, for one that is off until they do; absent is always on.
     enabled?(): boolean;
+    /* Asks the CLI, started in an account's environment, who is signed in there. Absent leaves the host's own reader. */
+    askAccount?(command: readonly string[], env: Record<string, string | undefined>): Promise<AccountReading>;
     createBackend(launch: BackendLaunch, host: BackendHost): ChatBackend;
 }

package/src/testing/fake-acp.ts

@@ -20,6 +20,8 @@ export interface FakeAcpOptions {
     modes?: readonly string[];
     // Reports models the way agents did before config options: `models` and `session/set_model`.
     legacyModels?: boolean;
+    // Advertises and answers `session/close`.
+    closeSession?: boolean;
 }
 
 export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
@@ -212,7 +214,7 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
                         agentCapabilities: {
                             loadSession: options.loadSession ?? true,
                             promptCapabilities: { image: true, audio: false, embeddedContext: false },
-                            sessionCapabilities: options.resumeSession ? { resume: {} } : {}
+                            sessionCapabilities: { ...(options.resumeSession ? { resume: {} } : {}), ...(options.closeSession ? { close: {} } : {}) }
                         },
                         authMethods: options.authMethod === undefined ? [] : [{ id: options.authMethod, name: 'Sign in' }],
                         agentInfo: { name: 'fake-acp', title: 'Fake ACP', version: '0.0.1' }
@@ -252,6 +254,14 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
                     respond(id, sessionState());
                     return;
                 }
+                case 'session/close':
+                    if (!options.closeSession) {
+                        refuse(id, -32601, 'Method not found: session/close');
+                        return;
+                    }
+                    sessionHistory.delete(String(params.sessionId));
+                    respond(id, {});
+                    return;
                 case 'session/set_mode':
                     mode = String(params.modeId);
                     respond(id, {});