@adecore/agents 0.29.3 → 0.31.0

package/dist/chat/json-rpc-transport.js

@@ -0,0 +1,203 @@
+import { errorText } from '../error-text.js';
+import { ChatChild, MAX_LINE_LENGTH, readStreamLines } from './chat-process.js';
+/* An error the other side answered a request with. */
+export class JsonRpcError extends Error {
+    code;
+    data;
+    constructor(name, method, error) {
+        const detail = typeof error === 'object' && error !== null ? error : {};
+        super(`${method} failed: ${typeof detail.message === 'string' ? detail.message : JSON.stringify(error)}`);
+        this.name = name;
+        this.code = typeof detail.code === 'number' ? detail.code : null;
+        this.data = detail.data;
+    }
+}
+/*
+ * One child process and JSON-RPC on its stdio: newline-delimited JSON, a request carries an id and
+ * gets a result or an error back under the same id, a notification has no id. The child also sends
+ * requests of its own, answered with `respond` or `respondError`.
+ */
+export class JsonRpcTransport {
+    child;
+    options;
+    pending = new Map();
+    nextId = 1;
+    closed = false;
+    // Set once stdin ended or broke; a write after an EPIPE only raises the next one.
+    inputClosed = false;
+    constructor(options) {
+        this.options = options;
+        this.child = new ChatChild({
+            command: options.command,
+            cwd: options.cwd,
+            env: options.env,
+            ...(options.spawn ? { spawn: options.spawn } : {}),
+            onError: (error) => this.broken(error),
+            onExit: (exitCode, stderr) => this.handleExit(exitCode, stderr)
+        });
+        void this.readLines();
+    }
+    get pid() {
+        return this.child.pid;
+    }
+    get alive() {
+        return !this.closed;
+    }
+    request(method, params, options = {}) {
+        const label = this.options.label;
+        const timeoutMs = options.timeoutMs === undefined ? this.options.requestTimeoutMs : options.timeoutMs;
+        return new Promise((resolve, reject) => {
+            if (this.closed) {
+                reject(new Error(`${method} failed: ${label} is not running`));
+                return;
+            }
+            const id = this.nextId++;
+            let timer = null;
+            if (timeoutMs !== null) {
+                timer = setTimeout(() => {
+                    this.pending.delete(id);
+                    reject(new Error(`${method} failed: ${label} did not answer in ${timeoutMs / 1000} seconds`));
+                }, timeoutMs);
+                timer.unref?.();
+            }
+            this.pending.set(id, { resolve, reject, method, timer });
+            try {
+                this.write({ id, method, params });
+            }
+            catch (error) {
+                if (timer !== null) {
+                    clearTimeout(timer);
+                }
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    notify(method, params) {
+        this.write({ method, params });
+    }
+    respond(id, result) {
+        this.write({ id, result });
+    }
+    respondError(id, code, message) {
+        this.write({ id, error: { code, message } });
+    }
+    /* Closes stdin; the child ends on its own once it has nothing more to say. */
+    end() {
+        this.inputClosed = true;
+        try {
+            this.child.process.stdin.end();
+        }
+        catch {
+            // Already closed by the other side.
+        }
+    }
+    kill(signal = 'SIGTERM') {
+        this.child.process.kill(signal);
+    }
+    stop() {
+        this.end();
+        this.child.endAfterGrace();
+    }
+    dispose() {
+        return this.child.end();
+    }
+    write(frame) {
+        if (this.closed || this.inputClosed) {
+            throw new Error(`${this.options.label} stdin is closed`);
+        }
+        try {
+            const framed = this.options.versionField ? { jsonrpc: '2.0', ...frame } : frame;
+            this.child.process.stdin.write(`${JSON.stringify(framed)}\n`);
+            this.child.process.stdin.flush();
+        }
+        catch (error) {
+            this.inputClosed = true;
+            throw error;
+        }
+    }
+    /* A pipe that failed takes no more writes; a frame a consumer choked on leaves it as it was. */
+    broken(error) {
+        this.inputClosed = true;
+        this.failed(error);
+    }
+    failed(error) {
+        const failure = new Error(`${this.options.label} transport failed: ${errorText(error)}`);
+        this.rejectPending(() => failure);
+        try {
+            this.options.onError?.(failure);
+        }
+        catch (reportError) {
+            console.error(`Reporting a ${this.options.label} transport failure failed:`, errorText(reportError));
+        }
+    }
+    readLine(line) {
+        try {
+            this.handleLine(line);
+        }
+        catch (error) {
+            this.failed(error);
+        }
+    }
+    async readLines() {
+        try {
+            await readStreamLines(this.child.process.stdout, (line) => this.readLine(line), () => this.failed(new Error(`${this.options.label} wrote a frame of more than ${MAX_LINE_LENGTH / 1_000_000} million characters, which was dropped`)));
+        }
+        catch (error) {
+            if (!this.closed) {
+                this.broken(error);
+            }
+        }
+    }
+    handleLine(line) {
+        if (this.closed || line.trim() === '') {
+            return;
+        }
+        let frame;
+        try {
+            frame = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (typeof frame !== 'object' || frame === null || Array.isArray(frame)) {
+            return;
+        }
+        const message = frame;
+        if (typeof message.method === 'string') {
+            this.options.onFrame(message);
+            return;
+        }
+        const settle = typeof message.id === 'number' ? this.pending.get(message.id) : undefined;
+        if (!settle) {
+            return;
+        }
+        this.pending.delete(message.id);
+        if (settle.timer !== null) {
+            clearTimeout(settle.timer);
+        }
+        if (message.error !== undefined) {
+            settle.reject(new JsonRpcError(this.options.errorName ?? 'JsonRpcError', settle.method, message.error));
+        }
+        else {
+            settle.resolve(message.result);
+        }
+    }
+    handleExit(exitCode, stderr) {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.rejectPending((method) => new Error(`${method} failed: ${this.options.label} exited`));
+        this.options.onExit(exitCode, stderr);
+    }
+    rejectPending(reason) {
+        for (const settle of this.pending.values()) {
+            if (settle.timer !== null) {
+                clearTimeout(settle.timer);
+            }
+            settle.reject(reason(settle.method));
+        }
+        this.pending.clear();
+    }
+}

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

@@ -2,12 +2,16 @@ import { type AgentKind, type ProviderAccount, type ProviderAccountMap } from '@
 import type { ChatProvider } from '../provider.ts';
 import { type AccountsHost, type ReservedVariables } from './variables.ts';
 export type Env = Record<string, string | undefined>;
-export declare function isKnownKind(kind: string): kind is AgentKind;
+export interface AccountProviders {
+    kinds: readonly AgentKind[];
+    get(kind: AgentKind): ChatProvider;
+}
+export declare function isOfferedKind(kind: string, kinds: readonly AgentKind[]): boolean;
 export declare function isDefaultAccount(id: string, account: Pick<ProviderAccount, 'kind'>): boolean;
 export declare function expandHome(path: string, env: Env): string;
-export declare function accountProblem(id: string, account: ProviderAccount, provider: ChatProvider, env: Env, reserved?: ReservedVariables): string | null;
-export declare function folderVariablesOf(providerOf: (kind: AgentKind) => ChatProvider): string[];
-export declare function withDefaults(accounts: ProviderAccountMap): ProviderAccountMap;
+export declare function accountProblem(id: string, account: ProviderAccount, provider: ChatProvider, env: Env, reserved?: ReservedVariables, kinds?: readonly AgentKind[]): string | null;
+export declare function folderVariablesOf(providers: AccountProviders): string[];
+export declare function withDefaults(accounts: ProviderAccountMap, kinds: readonly AgentKind[]): ProviderAccountMap;
 export declare function defaultFolder(provider: ChatProvider, env: Env): string;
 export declare function accountFolder(id: string, account: ProviderAccount, provider: ChatProvider, env: Env): string;
 export declare function transcriptFolder(id: string, account: ProviderAccount, provider: ChatProvider, env: Env): string;
@@ -16,5 +20,5 @@ export interface NamedAccount {
     id: string;
     account: ProviderAccount;
 }
-export declare function canContinue(from: NamedAccount, to: NamedAccount, providerOf: (kind: AgentKind) => ChatProvider, env: Env): boolean;
-export declare function readAccount(id: string, raw: unknown, providerOf: (kind: AgentKind) => ChatProvider, env: Env, host?: AccountsHost): unknown;
+export declare function canContinue(from: NamedAccount, to: NamedAccount, providers: AccountProviders, env: Env): boolean;
+export declare function readAccount(id: string, raw: unknown, providers: AccountProviders, env: Env, host?: AccountsHost): unknown;

package/dist/providers/accounts/accounts.js

@@ -1,10 +1,9 @@
 import { isAbsolute, join, resolve } from 'node:path';
-import { AgentKindSchema, ProviderAccountSchema } from '@adecore/agent-contracts';
+import { KNOWN_AGENT_KINDS, ProviderAccountSchema } from '@adecore/agent-contracts';
 import { DEFAULT_ACCOUNTS_HOST, variablesProblem } from './variables.js';
 import { homeFolder } from '../../home-folder.js';
-const KNOWN_KINDS = AgentKindSchema.options;
-export function isKnownKind(kind) {
-    return KNOWN_KINDS.includes(kind);
+export function isOfferedKind(kind, kinds) {
+    return kinds.includes(kind);
 }
 /* The default account of a CLI is the folder the CLI uses without being told, and its id is the CLI's kind. */
 export function isDefaultAccount(id, account) {
@@ -28,8 +27,8 @@ function isRootedPath(path) {
  * What is wrong with an account of a CLI this version knows, or null when nothing is. An account of
  * an unknown kind is never judged: it is kept the way it was written, for a version that knows it.
  */
-export function accountProblem(id, account, provider, env, reserved = { host: DEFAULT_ACCOUNTS_HOST, folderVariables: [] }) {
-    if (isKnownKind(id) && id !== account.kind) {
+export function accountProblem(id, account, provider, env, reserved = { host: DEFAULT_ACCOUNTS_HOST, folderVariables: [] }, kinds = KNOWN_AGENT_KINDS) {
+    if (isOfferedKind(id, kinds) && id !== account.kind) {
         return `"${id}" is the id of the default ${id} account`;
     }
     const variables = variablesProblem(account.env ?? [], reserved);
@@ -63,16 +62,16 @@ export function accountProblem(id, account, provider, env, reserved = { host: DE
     return null;
 }
 /* The variables that point a CLI at its folder, which no account may set by hand. */
-export function folderVariablesOf(providerOf) {
-    return AgentKindSchema.options.flatMap((kind) => {
-        const home = providerOf(kind).home;
+export function folderVariablesOf(providers) {
+    return providers.kinds.flatMap((kind) => {
+        const home = providers.get(kind).home;
         return home === undefined ? [] : [home.env];
     });
 }
-/* The map with a default account for every CLI this version knows, those first and in catalog order. */
-export function withDefaults(accounts) {
+/* The map with a default account for every CLI the host offers, those first and in catalog order. */
+export function withDefaults(accounts, kinds) {
     const complete = {};
-    for (const kind of KNOWN_KINDS) {
+    for (const kind of kinds) {
         complete[kind] = accounts[kind] ?? { kind };
     }
     for (const [id, account] of Object.entries(accounts)) {
@@ -124,22 +123,22 @@ export function accountEnv(id, account, provider, baseEnv, variables = {}) {
  * Whether a conversation of one account can go on under the other: the same CLI, reading the same
  * transcripts. Two Codex accounts over one `home` can, shadow home or not; two Claude folders never.
  */
-export function canContinue(from, to, providerOf, env) {
+export function canContinue(from, to, providers, env) {
     if (from.id === to.id) {
         return true;
     }
     const kind = from.account.kind;
-    if (kind !== to.account.kind || !isKnownKind(kind)) {
+    if (kind !== to.account.kind || !isOfferedKind(kind, providers.kinds)) {
         return false;
     }
-    const provider = providerOf(kind);
+    const provider = providers.get(kind);
     return transcriptFolder(from.id, from.account, provider, env) === transcriptFolder(to.id, to.account, provider, env);
 }
 /*
  * An account as the file holds it, or null for one to drop. An unknown kind comes back as it was
  * read, extra fields included; a known kind has to parse and make sense.
  */
-export function readAccount(id, raw, providerOf, env, host = DEFAULT_ACCOUNTS_HOST) {
+export function readAccount(id, raw, providers, env, host = DEFAULT_ACCOUNTS_HOST) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
         return null;
     }
@@ -147,11 +146,12 @@ export function readAccount(id, raw, providerOf, env, host = DEFAULT_ACCOUNTS_HO
     if (typeof kind !== 'string' || kind === '') {
         return null;
     }
-    if (!isKnownKind(kind)) {
-        return isKnownKind(id) ? null : raw;
+    if (!isOfferedKind(kind, providers.kinds)) {
+        return isOfferedKind(id, providers.kinds) ? null : raw;
     }
     const parsed = ProviderAccountSchema.safeParse(raw);
-    if (!parsed.success || accountProblem(id, parsed.data, providerOf(kind), env, { host, folderVariables: folderVariablesOf(providerOf) }) !== null) {
+    const reserved = { host, folderVariables: folderVariablesOf(providers) };
+    if (!parsed.success || accountProblem(id, parsed.data, providers.get(kind), env, reserved, providers.kinds) !== null) {
         return null;
     }
     return parsed.data;

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

@@ -15,6 +15,7 @@ export interface ProviderAccountsOptions {
         list(): Promise<ProviderInfo[]>;
         get(kind: AgentKind): ChatProvider;
         enabled?(kind: AgentKind): boolean;
+        kinds?(): readonly AgentKind[];
     };
     env?: Env;
     ask?: AskAccount;
@@ -70,6 +71,8 @@ export declare class ProviderAccountsService implements AccountLaunches {
     refresh(): Promise<ProviderAccounts>;
     private folderOf;
     private runWatch;
+    private kinds;
+    private accountProviders;
     private serial;
     private commit;
     private planSecrets;

package/dist/providers/accounts/service.js

@@ -1,11 +1,11 @@
 import { existsSync, statSync } from 'node:fs';
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { AgentKindSchema } from '@adecore/agent-contracts';
+import { KNOWN_AGENT_KINDS } from '@adecore/agent-contracts';
 import { DEFAULT_CODEX_CLIENT } from '../../chat/codex-transport.js';
 import { ClientSinks } from '../../client-sinks.js';
 import { errorText } from '../../error-text.js';
-import { accountEnv, accountFolder, canContinue, defaultFolder, expandHome, isDefaultAccount, isKnownKind, transcriptFolder } from './accounts.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';
@@ -77,7 +77,7 @@ export class ProviderAccountsService {
     launches = new Map();
     states = new Map();
     stored = {};
-    accounts = wireAccounts({});
+    accounts;
     passes = Promise.resolve();
     timer = null;
     constructor(options) {
@@ -93,10 +93,11 @@ export class ProviderAccountsService {
         this.secrets = options.secrets === undefined ? platformSecrets(this.host, options.home) : options.secrets;
         this.now = options.now ?? Date.now;
         this.sleep = options.sleep ?? sleep;
+        this.accounts = wireAccounts({}, this.kinds());
     }
     async load() {
-        this.stored = await readAccounts(this.path, (kind) => this.providers.get(kind), this.env, this.host);
-        this.accounts = wireAccounts(this.stored);
+        this.stored = await readAccounts(this.path, this.accountProviders(), this.env, this.host);
+        this.accounts = wireAccounts(this.stored, this.kinds());
         await this.readSecrets();
     }
     subscribe(clientId, sink) {
@@ -104,17 +105,22 @@ export class ProviderAccountsService {
     }
     snapshot() {
         const loginCommands = {};
-        for (const kind of AgentKindSchema.options) {
-            const command = this.providers.get(kind).home?.loginCommand;
-            if (command !== undefined) {
-                loginCommands[kind] = command;
+        const chatLogins = [];
+        for (const kind of this.kinds()) {
+            const home = this.providers.get(kind).home;
+            if (home?.loginCommand !== undefined) {
+                loginCommands[kind] = home.loginCommand;
+            }
+            else if (home !== undefined) {
+                chatLogins.push(kind);
             }
         }
         return {
             accounts: this.accounts,
             statuses: Object.entries(this.accounts).map(([id, account]) => this.statusOf(id, account)),
             secretsAvailable: this.secrets !== null,
-            loginCommands
+            loginCommands,
+            ...(chatLogins.length > 0 ? { chatLogins } : {})
         };
     }
     /* The account under an id, for a launch; null for an id this machine does not have. */
@@ -145,7 +151,7 @@ export class ProviderAccountsService {
             throw refuse('no account on it has that id');
         }
         if (account.kind !== kind) {
-            throw refuse(`it is an account of ${isKnownKind(account.kind) ? this.providers.get(account.kind).name : account.kind}, not of ${provider.name}`);
+            throw refuse(`it is an account of ${isOfferedKind(account.kind, this.kinds()) ? this.providers.get(account.kind).name : account.kind}, not of ${provider.name}`);
         }
         if (account.enabled === false) {
             throw refuse('it is turned off');
@@ -177,7 +183,7 @@ export class ProviderAccountsService {
         if (fromAccount === undefined || toAccount === undefined || fromAccount.kind !== kind) {
             return false;
         }
-        return canContinue({ id: fromId, account: fromAccount }, { id: toId, account: toAccount }, (each) => this.providers.get(each), this.env);
+        return canContinue({ id: fromId, account: fromAccount }, { id: toId, account: toAccount }, this.accountProviders(), this.env);
     }
     labelOf(id) {
         return this.accounts[id]?.label ?? id;
@@ -278,6 +284,12 @@ export class ProviderAccountsService {
             }
         }
     }
+    kinds() {
+        return this.providers.kinds?.() ?? KNOWN_AGENT_KINDS;
+    }
+    accountProviders() {
+        return { kinds: this.kinds(), get: (kind) => this.providers.get(kind) };
+    }
     /* One change of the file at a time: a create and a save both read what the other just wrote. */
     serial(work) {
         const next = this.writes.then(work);
@@ -285,7 +297,7 @@ export class ProviderAccountsService {
         return next;
     }
     async commit(accounts, isDirectory) {
-        const stored = acceptAccounts(accounts, this.stored, (kind) => this.providers.get(kind), this.env, isDirectory, this.host);
+        const stored = acceptAccounts(accounts, this.stored, this.accountProviders(), this.env, isDirectory, this.host);
         const { writes, removals } = this.planSecrets(stored);
         for (const [key, value] of writes) {
             await this.requireSecrets().write(key, value);
@@ -293,7 +305,7 @@ export class ProviderAccountsService {
         }
         await writeAccounts(this.path, stored);
         this.stored = stored;
-        this.accounts = wireAccounts(stored);
+        this.accounts = wireAccounts(stored, this.kinds());
         for (const key of removals) {
             this.secretValues.delete(key);
             await this.secrets?.remove(key).catch((e) => console.error(`Could not remove ${key} from the keychain:`, errorText(e)));
@@ -318,7 +330,7 @@ export class ProviderAccountsService {
         const kept = new Set();
         for (const [id, entry] of Object.entries(stored)) {
             const kind = entry.kind;
-            if (!isKnownKind(kind)) {
+            if (!isOfferedKind(kind, this.kinds())) {
                 for (const name of sensitiveNames(entry)) {
                     kept.add(secretKey(id, name));
                 }
@@ -416,7 +428,7 @@ export class ProviderAccountsService {
         return this.status(id, account, 'checking', { checkedAt: 0 });
     }
     status(id, account, state, fields = {}) {
-        const provider = isKnownKind(account.kind) ? this.providers.get(account.kind) : null;
+        const provider = isOfferedKind(account.kind, this.kinds()) ? this.providers.get(account.kind) : null;
         const folder = provider === null ? '' : accountFolder(id, account, provider, this.env);
         return {
             id,
@@ -461,7 +473,7 @@ export class ProviderAccountsService {
     }
     async check(id, account, installed) {
         const kind = account.kind;
-        if (!isKnownKind(kind)) {
+        if (!isOfferedKind(kind, this.kinds())) {
             return this.status(id, account, 'unavailable', { message: `This version of ${this.host.name} does not know this CLI` });
         }
         const provider = this.providers.get(kind);
@@ -494,6 +506,10 @@ export class ProviderAccountsService {
             if (missing !== null) {
                 throw new Error(`The keychain does not give the value of ${missing}`);
             }
+            // A CLI that signs in from its chat has no command that says who is signed in; its chat asks when it must.
+            if (provider.home.loginCommand === undefined) {
+                return this.status(id, account, 'ready', { message });
+            }
             const reading = await this.ask(kind, provider.command, accountEnv(id, account, provider, this.env, values));
             return this.status(id, account, reading.signedIn ? 'ready' : 'signed-out', {
                 email: reading.email,

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

@@ -1,14 +1,13 @@
 import { type AgentKind, type ProviderAccountMap } from '@adecore/agent-contracts';
 import { CodedError } from '../../coded-error.ts';
-import type { ChatProvider } from '../provider.ts';
-import { type Env } from './accounts.ts';
+import { type AccountProviders, type Env } from './accounts.ts';
 import { type AccountsHost } from './variables.ts';
 export declare function accountsPath(home: string): string;
 export type StoredAccounts = Record<string, unknown>;
-export declare function readAccounts(path: string, providerOf: (kind: AgentKind) => ChatProvider, env: Env, host?: AccountsHost): Promise<StoredAccounts>;
+export declare function readAccounts(path: string, providers: AccountProviders, env: Env, host?: AccountsHost): Promise<StoredAccounts>;
 export declare function writeAccounts(path: string, stored: StoredAccounts): Promise<void>;
-export declare function wireAccounts(stored: StoredAccounts): ProviderAccountMap;
+export declare function wireAccounts(stored: StoredAccounts, kinds: readonly AgentKind[]): ProviderAccountMap;
 export declare class InvalidAccountError extends CodedError<'invalid-account'> {
     constructor(message: string);
 }
-export declare function acceptAccounts(saved: ProviderAccountMap, before: StoredAccounts, providerOf: (kind: AgentKind) => ChatProvider, env: Env, isDirectory: (path: string) => boolean, host?: AccountsHost): StoredAccounts;
+export declare function acceptAccounts(saved: ProviderAccountMap, before: StoredAccounts, providers: AccountProviders, env: Env, isDirectory: (path: string) => boolean, host?: AccountsHost): StoredAccounts;

package/dist/providers/accounts/store.js

@@ -3,14 +3,14 @@ import { join } from 'node:path';
 import { ProviderAccountIdSchema, ProviderAccountSchema } from '@adecore/agent-contracts';
 import { CodedError } from '../../coded-error.js';
 import { isNotFound, writeAtomic } from '../../fs.js';
-import { accountFolder, accountProblem, defaultFolder, expandHome, folderVariablesOf, isDefaultAccount, isKnownKind, readAccount, withDefaults } from './accounts.js';
+import { accountFolder, accountProblem, defaultFolder, expandHome, folderVariablesOf, isDefaultAccount, isOfferedKind, readAccount, withDefaults } from './accounts.js';
 import { DEFAULT_ACCOUNTS_HOST, redactVariables } from './variables.js';
 const FILE_VERSION = 1;
 export function accountsPath(home) {
     return join(home, 'providers.json');
 }
 /* Every entry that does not parse is dropped on its own; a file that is not JSON at all reads as none. */
-export async function readAccounts(path, providerOf, env, host = DEFAULT_ACCOUNTS_HOST) {
+export async function readAccounts(path, providers, env, host = DEFAULT_ACCOUNTS_HOST) {
     let parsed;
     try {
         parsed = JSON.parse(await readFile(path, 'utf8'));
@@ -30,7 +30,7 @@ export async function readAccounts(path, providerOf, env, host = DEFAULT_ACCOUNT
         if (!ProviderAccountIdSchema.safeParse(id).success) {
             continue;
         }
-        const account = readAccount(id, raw, providerOf, env, host);
+        const account = readAccount(id, raw, providers, env, host);
         if (account !== null) {
             stored[id] = account;
         }
@@ -48,8 +48,8 @@ function wireAccount(entry) {
     }
     return parsed.data.env === undefined ? parsed.data : { ...parsed.data, env: redactVariables(parsed.data.env) };
 }
-export function wireAccounts(stored) {
-    return withDefaults(Object.fromEntries(Object.entries(stored).map(([id, entry]) => [id, wireAccount(entry)])));
+export function wireAccounts(stored, kinds) {
+    return withDefaults(Object.fromEntries(Object.entries(stored).map(([id, entry]) => [id, wireAccount(entry)])), kinds);
 }
 export class InvalidAccountError extends CodedError {
     constructor(message) {
@@ -88,12 +88,12 @@ function linkProblem(id, account, before, provider, env, isDirectory) {
  * client that knows the kind no better than this host could only have cut short. Sensitive values
  * are still in it: the caller puts them in the keychain before the file is written.
  */
-export function acceptAccounts(saved, before, providerOf, env, isDirectory, host = DEFAULT_ACCOUNTS_HOST) {
+export function acceptAccounts(saved, before, providers, env, isDirectory, host = DEFAULT_ACCOUNTS_HOST) {
     const stored = {};
-    const reserved = { host, folderVariables: folderVariablesOf(providerOf) };
-    for (const [id, account] of Object.entries(withDefaults(saved))) {
-        if (!isKnownKind(account.kind)) {
-            if (isKnownKind(id)) {
+    const reserved = { host, folderVariables: folderVariablesOf(providers) };
+    for (const [id, account] of Object.entries(withDefaults(saved, providers.kinds))) {
+        if (!isOfferedKind(account.kind, providers.kinds)) {
+            if (isOfferedKind(id, providers.kinds)) {
                 throw new InvalidAccountError(`"${id}" is the id of the default ${id} account`);
             }
             const kept = before[id];
@@ -101,8 +101,8 @@ export function acceptAccounts(saved, before, providerOf, env, isDirectory, host
             stored[id] = keptKind === account.kind ? kept : account;
             continue;
         }
-        const provider = providerOf(account.kind);
-        const problem = accountProblem(id, account, provider, env, reserved) ?? linkProblem(id, account, before[id], provider, env, isDirectory);
+        const provider = providers.get(account.kind);
+        const problem = accountProblem(id, account, provider, env, reserved, providers.kinds) ?? linkProblem(id, account, before[id], provider, env, isDirectory);
         if (problem !== null) {
             throw new InvalidAccountError(`${id}: ${problem}`);
         }

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

@@ -0,0 +1,22 @@
+import type { AgentKind, ProviderCapabilities } from '@adecore/agent-contracts';
+import { type AcpAgentSpec } from '../chat/acp-backend.ts';
+import type { ModelCatalog } from './catalog.ts';
+import { type CliDetection } from './detect.ts';
+import type { ChatProvider, ProviderHome } from './provider.ts';
+export declare const ACP_CAPABILITIES: ProviderCapabilities;
+export interface AcpProviderSpec extends AcpAgentSpec {
+    kind: AgentKind;
+    command: string;
+    args?: readonly string[];
+    catalog: ModelCatalog;
+    capabilities?: Partial<ProviderCapabilities>;
+    resumeCommand?: string;
+    home?: ProviderHome;
+    ignoresProjectConfig?: boolean;
+    oneShotArgs?(prompt: string): string[];
+    oneShotStdinArgs?: readonly string[];
+    firstPromptArgs?(prompt: string): string[];
+    detect?(command: string, env: Record<string, string | undefined>): Promise<CliDetection>;
+    enabled?(): boolean;
+}
+export declare function createAcpProvider(spec: AcpProviderSpec): ChatProvider;

package/dist/providers/acp-provider.js

@@ -0,0 +1,45 @@
+import { createAcpBackend } from '../chat/acp-backend.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;
+ * a message names its mentions and attachments by path, as text the agent opens with its own tools.
+ */
+export const ACP_CAPABILITIES = {
+    chat: true,
+    terminal: false,
+    hooks: false,
+    streamsToolOutput: false,
+    diffs: 'before-after',
+    attachments: true,
+    mentions: true,
+    denyReason: false,
+    allowAlways: true,
+    asyncQuestions: false,
+    compaction: 'none',
+    reportsCost: false,
+    reportsContextWindow: false,
+    reportsThinking: true,
+    slashCommands: true
+};
+export function createAcpProvider(spec) {
+    const capabilities = { ...ACP_CAPABILITIES, ...spec.capabilities };
+    return {
+        kind: spec.kind,
+        name: spec.name,
+        catalog: spec.catalog,
+        capabilities,
+        command: [spec.command, ...(spec.args ?? [])],
+        resumeCommand: spec.resumeCommand ?? '',
+        ...(spec.ignoresProjectConfig === undefined ? {} : { ignoresProjectConfig: spec.ignoresProjectConfig }),
+        ...(spec.home ? { home: spec.home } : {}),
+        ...(spec.oneShotArgs ? { oneShotArgs: spec.oneShotArgs } : {}),
+        ...(spec.oneShotStdinArgs ? { oneShotStdinArgs: spec.oneShotStdinArgs } : {}),
+        ...(spec.enabled ? { enabled: spec.enabled } : {}),
+        firstPromptArgs: spec.firstPromptArgs ??
+            (() => {
+                throw new Error(`${spec.name} is only available as a chat.`);
+            }),
+        detect: spec.detect ?? ((command, env) => detectCli(command, env)),
+        createBackend: createAcpBackend(spec)
+    };
+}

package/dist/providers/catalog.js

@@ -31,6 +31,7 @@ export class ModelCatalog {
             slug: model.slug,
             name: model.name,
             badge: model.badge,
+            ...(model.vendor === undefined ? {} : { vendor: model.vendor }),
             legacy: model.legacy === true,
             isDefault: model.slug === this.data.defaultModel,
             options: this.profileOf(model.slug)?.options ?? [],

package/dist/providers/index.d.ts

@@ -1,3 +1,4 @@
+export { ACP_CAPABILITIES, type AcpProviderSpec, createAcpProvider } from './acp-provider.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';