@adecore/agents 0.0.1 → 0.17.0-beta.1

package/dist/providers/accounts/status.js

@@ -0,0 +1,85 @@
+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;
+function text(value) {
+    return typeof value === 'string' && value !== '' ? value : null;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/* `claude auth status --json`, as Claude Code 2.1.282 prints it: `loggedIn`, `email`, `orgName`, `subscriptionType`. */
+export function readClaudeAuthStatus(output) {
+    let status;
+    try {
+        status = JSON.parse(output);
+    }
+    catch {
+        throw new Error('Claude Code did not say who is signed in');
+    }
+    if (!isRecord(status) || typeof status.loggedIn !== 'boolean') {
+        throw new Error('Claude Code did not say who is signed in');
+    }
+    return {
+        signedIn: status.loggedIn,
+        email: text(status.email),
+        plan: text(status.subscriptionType),
+        organization: text(status.orgName)
+    };
+}
+/*
+ * The app-server's `account/read`, as Codex 0.157 answers it: `account` is null while nobody signed in,
+ * `{ type: 'chatgpt', email, planType }` for a plan and `{ type: 'apiKey' }` for a key. A model
+ * provider without OpenAI's login needs no account at all, which `requiresOpenaiAuth` says.
+ */
+export function readCodexAccount(answer) {
+    if (!isRecord(answer)) {
+        throw new Error('Codex did not say who is signed in');
+    }
+    const account = answer.account;
+    if (!isRecord(account)) {
+        return { signedIn: answer.requiresOpenaiAuth === false, email: null, plan: null, organization: null };
+    }
+    return { signedIn: true, email: text(account.email), plan: text(account.planType), organization: null };
+}
+async function askClaude(command, env) {
+    const { stdout } = await runProcess([...command, 'auth', 'status', '--json'], {
+        env,
+        timeoutMs: ASK_TIMEOUT_MS,
+        timeoutMessage: 'Claude Code did not answer in time'
+    });
+    // Signed out exits 1 and still prints the status, so the output decides and the exit code does not.
+    return readClaudeAuthStatus(stdout);
+}
+async function askCodex(command, env, client) {
+    const transport = new CodexTransport({
+        command: [...command],
+        cwd: process.cwd(),
+        env: env,
+        onFrame: () => undefined,
+        onExit: () => undefined
+    });
+    try {
+        await withTimeout(transport.request('initialize', { clientInfo: client, capabilities: { experimentalApi: true } }), ASK_TIMEOUT_MS, 'Codex did not answer in time');
+        transport.notify('initialized', {});
+        const answer = await withTimeout(transport.request('account/read', { refreshToken: false }), ASK_TIMEOUT_MS, 'Codex did not answer in time');
+        return readCodexAccount(answer);
+    }
+    finally {
+        transport.end();
+        transport.kill();
+    }
+}
+/* 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) => {
+        if (kind === 'claude') {
+            return askClaude(command, env);
+        }
+        if (kind === 'codex') {
+            return askCodex(command, env, client);
+        }
+        return Promise.reject(new Error(`${kind} cannot say who is signed in`));
+    };
+}

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

@@ -0,0 +1,14 @@
+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 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 writeAccounts(path: string, stored: StoredAccounts): Promise<void>;
+export declare function wireAccounts(stored: StoredAccounts): 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;

package/dist/providers/accounts/store.js

@@ -0,0 +1,112 @@
+import { readFile } from 'node:fs/promises';
+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 { 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) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch (e) {
+        if (isNotFound(e) || e instanceof SyntaxError) {
+            return {};
+        }
+        throw e;
+    }
+    const entries = typeof parsed === 'object' && parsed !== null ? parsed.accounts : null;
+    if (typeof entries !== 'object' || entries === null || Array.isArray(entries)) {
+        return {};
+    }
+    const stored = {};
+    for (const [id, raw] of Object.entries(entries)) {
+        if (!ProviderAccountIdSchema.safeParse(id).success) {
+            continue;
+        }
+        const account = readAccount(id, raw, providerOf, env, host);
+        if (account !== null) {
+            stored[id] = account;
+        }
+    }
+    return stored;
+}
+export async function writeAccounts(path, stored) {
+    await writeAtomic(path, `${JSON.stringify({ version: FILE_VERSION, accounts: stored }, null, 2)}\n`, 0o600);
+}
+/* What a client reads of an entry of a kind it may not know either: the fields this version knows. */
+function wireAccount(entry) {
+    const parsed = ProviderAccountSchema.safeParse(entry);
+    if (!parsed.success) {
+        return { kind: String(entry.kind) };
+    }
+    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 class InvalidAccountError extends CodedError {
+    constructor(message) {
+        super('invalid-account', message);
+    }
+}
+function storedFolders(entry) {
+    const parsed = ProviderAccountSchema.safeParse(entry);
+    return parsed.success ? { home: parsed.data.home, shadowHome: parsed.data.shadowHome } : {};
+}
+/*
+ * What is wrong with the folders of an account a person points somewhere new, or null. An account
+ * whose folders did not change is left alone, so one whose folder went missing can still be renamed.
+ */
+function linkProblem(id, account, before, provider, env, isDirectory) {
+    if (isDefaultAccount(id, account) || provider.home === undefined || account.home === undefined) {
+        return null;
+    }
+    const was = storedFolders(before);
+    if (was.home === account.home && was.shadowHome === account.shadowHome) {
+        return null;
+    }
+    for (const folder of [account.home, account.shadowHome]) {
+        if (folder !== undefined && !isDirectory(expandHome(folder, env))) {
+            return `${folder} is not a folder on this machine`;
+        }
+    }
+    if (accountFolder(id, account, provider, env) === defaultFolder(provider, env)) {
+        return `${defaultFolder(provider, env)} is the folder of the default ${provider.name} account`;
+    }
+    return null;
+}
+/*
+ * The whole map a person saved, as the file will hold it. A mistake in an account of a known kind
+ * refuses the save; an account of an unknown kind keeps the entry the file had under its id, which a
+ * 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) {
+    const stored = {};
+    const reserved = { host, folderVariables: folderVariablesOf(providerOf) };
+    for (const [id, account] of Object.entries(withDefaults(saved))) {
+        if (!isKnownKind(account.kind)) {
+            if (isKnownKind(id)) {
+                throw new InvalidAccountError(`"${id}" is the id of the default ${id} account`);
+            }
+            const kept = before[id];
+            const keptKind = typeof kept === 'object' && kept !== null ? kept.kind : undefined;
+            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);
+        if (problem !== null) {
+            throw new InvalidAccountError(`${id}: ${problem}`);
+        }
+        stored[id] = account;
+    }
+    return stored;
+}

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

@@ -0,0 +1,12 @@
+import type { ProviderAccountMap } from '@adecore/agent-contracts';
+import { ProviderAccountsService } from './service.ts';
+import type { SecretStore } from './variables.ts';
+export declare function memorySecrets(values?: Map<string, string>): SecretStore & {
+    values: Map<string, string>;
+};
+export declare function testAccounts(options: {
+    home: string;
+    env: Record<string, string | undefined>;
+    accounts: ProviderAccountMap;
+    folders: Set<string>;
+}): Promise<ProviderAccountsService>;

package/dist/providers/accounts/test-accounts.js

@@ -0,0 +1,38 @@
+import { providerFor } from '../registry.js';
+import { ProviderAccountsService } from './service.js';
+import { accountsPath, writeAccounts } from './store.js';
+/* A keychain in memory; `values` is what it holds, by key. */
+export function memorySecrets(values = new Map()) {
+    return {
+        values,
+        read: async (key) => values.get(key) ?? null,
+        write: async (key, value) => {
+            values.set(key, value);
+        },
+        remove: async (key) => {
+            values.delete(key);
+        }
+    };
+}
+/*
+ * The accounts of a machine as a test wants them: written to `providers.json` under `home` as
+ * they are, with only the folders in `folders` on disk, and every CLI signed in without being asked.
+ */
+export async function testAccounts(options) {
+    const service = new ProviderAccountsService({
+        home: options.home,
+        providers: {
+            list: async () => ['claude', 'codex'].map((kind) => ({ kind, installed: true })),
+            get: (kind) => providerFor(kind)
+        },
+        env: options.env,
+        ask: async () => ({ signedIn: true, email: null, plan: null, organization: null }),
+        folderExists: (path) => options.folders.has(path),
+        prepareShadow: async () => ({ linked: [], unshared: [], sharedLogin: false }),
+        secrets: memorySecrets()
+    });
+    // Written and not saved, so an account whose folder is already gone is there the way a person left it.
+    await writeAccounts(accountsPath(options.home), options.accounts);
+    await service.load();
+    return service;
+}

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

@@ -0,0 +1,27 @@
+import type { ProviderAccountVariable } from '@adecore/agent-contracts';
+import { CodedError } from '../../coded-error.ts';
+export declare class SecretsUnavailableError extends CodedError<'secrets-unavailable'> {
+    constructor();
+}
+export interface SecretStore {
+    read(key: string): Promise<string | null>;
+    write(key: string, value: string): Promise<void>;
+    remove(key: string): Promise<void>;
+}
+export declare function secretKey(accountId: string, name: string): string;
+export interface AccountsHost {
+    name: string;
+    variablePrefixes: readonly string[];
+    keychainPrefix: string;
+}
+export declare const DEFAULT_ACCOUNTS_HOST: AccountsHost;
+export interface ReservedVariables {
+    host: AccountsHost;
+    folderVariables: readonly string[];
+}
+export declare function isReservedName(name: string, reserved: ReservedVariables): boolean;
+export declare function variablesProblem(variables: readonly ProviderAccountVariable[], reserved: ReservedVariables): string | null;
+export declare function redactVariables(variables: readonly ProviderAccountVariable[]): ProviderAccountVariable[];
+export declare function keychainService(host: AccountsHost, home: string): string;
+export declare function keychainSecrets(service: string): SecretStore;
+export declare function platformSecrets(host: AccountsHost, home: string): SecretStore | null;

package/dist/providers/accounts/variables.js

@@ -0,0 +1,94 @@
+import { createHash } from 'node:crypto';
+import { resolve } from 'node:path';
+import { CodedError } from '../../coded-error.js';
+import { runProcess } from '../../run-process.js';
+/*
+ * The variables of an account, and where a sensitive value is kept: the keychain of this machine,
+ * never `providers.json` and never the wire.
+ */
+export class SecretsUnavailableError extends CodedError {
+    constructor() {
+        super('secrets-unavailable', 'This machine has no keychain to keep a sensitive value in.');
+    }
+}
+export function secretKey(accountId, name) {
+    return `${accountId}/${name}`;
+}
+/* The names that decide which folder and which executable a CLI talks to. */
+const RESERVED = new Set(['HOME', 'PATH']);
+export const DEFAULT_ACCOUNTS_HOST = { name: 'the app', variablePrefixes: [], keychainPrefix: 'agents' };
+export function isReservedName(name, reserved) {
+    return RESERVED.has(name) || reserved.host.variablePrefixes.some((prefix) => name.startsWith(prefix)) || reserved.folderVariables.includes(name);
+}
+/* `security` prints anything else as hex, so a read could not tell such a value from its own encoding. */
+function isPrintableAscii(value) {
+    return /^[\x20-\x7e]*$/.test(value);
+}
+/* What is wrong with the variables of an account, or null when nothing is. A secret that is only redacted is judged by the service. */
+export function variablesProblem(variables, reserved) {
+    const seen = new Set();
+    for (const variable of variables) {
+        if (seen.has(variable.name)) {
+            return `${variable.name} is set twice`;
+        }
+        seen.add(variable.name);
+        if (isReservedName(variable.name, reserved)) {
+            return `${variable.name} is set by ${reserved.host.name} itself`;
+        }
+        if (variable.sensitive && !isPrintableAscii(variable.value)) {
+            return `The value of ${variable.name} can only hold printable ASCII characters`;
+        }
+    }
+    return null;
+}
+/* The variables as a client may read them: a sensitive value never leaves the machine. */
+export function redactVariables(variables) {
+    return variables.map((variable) => (variable.sensitive ? { name: variable.name, value: '', sensitive: true, valueRedacted: true } : variable));
+}
+/* A data folder of its own (a development one beside an installed one) keeps its values apart from the other's. */
+export function keychainService(host, home) {
+    return `${host.keychainPrefix}-provider-env-${createHash('sha256').update(resolve(home)).digest('hex').slice(0, 12)}`;
+}
+// `security` exits with this when no item matches.
+const NOT_FOUND = 44;
+async function run(args, stdin) {
+    const { exitCode, stdout, stderr } = await runProcess(['security', ...args], { ...(stdin === undefined ? {} : { stdin }) });
+    return { code: exitCode ?? 1, stdout, stderr };
+}
+/*
+ * Generic passwords in the login keychain, through the `security` CLI. A value goes in over stdin as
+ * hex in its interactive mode: on the command line any process could read it, and the password
+ * prompt cuts it at 128 characters.
+ */
+export function keychainSecrets(service) {
+    return {
+        read: async (key) => {
+            const { code, stdout, stderr } = await run(['find-generic-password', '-s', service, '-a', key, '-w']);
+            if (code === NOT_FOUND) {
+                return null;
+            }
+            if (code !== 0) {
+                throw new Error(`The keychain did not give ${key}: ${stderr.trim()}`);
+            }
+            return stdout.endsWith('\n') ? stdout.slice(0, -1) : stdout;
+        },
+        write: async (key, value) => {
+            const hex = Buffer.from(value, 'utf8').toString('hex');
+            const quoted = `"${key.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+            const { code, stderr } = await run(['-i'], `add-generic-password -U -s ${service} -a ${quoted} -X ${hex}\n`);
+            if (code !== 0) {
+                throw new Error(`The keychain did not take ${key}: ${stderr.trim()}`);
+            }
+        },
+        remove: async (key) => {
+            const { code, stderr } = await run(['delete-generic-password', '-s', service, '-a', key]);
+            if (code !== 0 && code !== NOT_FOUND) {
+                throw new Error(`The keychain did not remove ${key}: ${stderr.trim()}`);
+            }
+        }
+    };
+}
+/* The keychain on macOS; elsewhere none, so a sensitive variable is refused. */
+export function platformSecrets(host, home) {
+    return process.platform === 'darwin' ? keychainSecrets(keychainService(host, home)) : null;
+}

package/dist/providers/catalog.d.ts

@@ -0,0 +1,17 @@
+import type { ModelCatalogData, ModelInfo, ModelSelection } from '@adecore/agent-contracts';
+export type ModelCatalogInput = Omit<ModelCatalogData, 'updatedAt'> & {
+    updatedAt?: string;
+};
+export declare class ModelCatalog {
+    private readonly shippedAt;
+    private data;
+    constructor(data?: ModelCatalogInput);
+    get defaultModel(): string;
+    replace(data: ModelCatalogData): boolean;
+    list(): ModelInfo[];
+    nameOf(slug: string): string;
+    resolveModel(name: string): string | null;
+    normalize(selection: Partial<ModelSelection> | undefined): ModelSelection;
+    contextWindowFor(selection: ModelSelection): number | null;
+    private profileOf;
+}

package/dist/providers/catalog.js

@@ -0,0 +1,76 @@
+import manifest from './claude-models.json' with { type: 'json' };
+function timeOf(data) {
+    return data.updatedAt === undefined ? 0 : Date.parse(data.updatedAt);
+}
+/*
+ * The models a provider offers and what each one can be asked for. Bundled as JSON so a new
+ * model is a data change; a profile is only needed for a new combination of options. A host may
+ * swap in a newer copy while it runs, never one older than the copy it was built with.
+ */
+export class ModelCatalog {
+    shippedAt;
+    data;
+    constructor(data = manifest) {
+        this.shippedAt = timeOf(data);
+        this.data = data;
+    }
+    get defaultModel() {
+        return this.data.defaultModel;
+    }
+    /* Takes a validated copy unless it is older than the shipped one; answers whether the models changed. */
+    replace(data) {
+        if (timeOf(data) < this.shippedAt) {
+            return false;
+        }
+        const changed = JSON.stringify(data) !== JSON.stringify(this.data);
+        this.data = data;
+        return changed;
+    }
+    list() {
+        return this.data.models.map((model) => ({
+            slug: model.slug,
+            name: model.name,
+            badge: model.badge,
+            legacy: model.legacy === true,
+            isDefault: model.slug === this.data.defaultModel,
+            options: this.profileOf(model.slug)?.options ?? []
+        }));
+    }
+    /* What a person reads for a model, so an error in a thread names it the way the picker does. */
+    nameOf(slug) {
+        return this.data.models.find((entry) => entry.slug === slug)?.name ?? slug;
+    }
+    /* Accepts a slug or an alias; unknown models answer null so the caller can decide what to do. */
+    resolveModel(name) {
+        const model = this.data.models.find((entry) => entry.slug === name || entry.aliases?.includes(name));
+        return model?.slug ?? null;
+    }
+    /* Fills in defaults and drops options the model does not have, so a selection is always complete. */
+    normalize(selection) {
+        const model = (selection?.model && this.resolveModel(selection.model)) || this.defaultModel;
+        const options = {};
+        for (const descriptor of this.profileOf(model)?.options ?? []) {
+            const given = selection?.options?.[descriptor.id];
+            if (descriptor.type === 'select') {
+                options[descriptor.id] =
+                    typeof given === 'string' && descriptor.choices.some((choice) => choice.id === given) ? given : descriptor.defaultChoice;
+            }
+            else {
+                options[descriptor.id] = typeof given === 'boolean' ? given : descriptor.defaultValue;
+            }
+        }
+        return { model, options };
+    }
+    contextWindowFor(selection) {
+        const profile = this.profileOf(selection.model);
+        if (!profile) {
+            return null;
+        }
+        const chosen = selection.options.contextWindow;
+        return (typeof chosen === 'string' ? profile.contextWindowTokens[chosen] : undefined) ?? profile.contextWindowTokens['*'] ?? null;
+    }
+    profileOf(slug) {
+        const model = this.data.models.find((entry) => entry.slug === slug);
+        return model ? this.data.profiles[model.profile] : undefined;
+    }
+}

package/dist/providers/claude-models.json

@@ -0,0 +1,114 @@
+{
+  "updatedAt": "2026-09-28T19:00:00Z",
+  "defaultModel": "claude-sonnet-5-5",
+  "profiles": {
+    "frontier": {
+      "options": [
+        {
+          "id": "effort",
+          "label": "Reasoning",
+          "type": "select",
+          "defaultChoice": "high",
+          "choices": [
+            { "id": "low", "label": "Low" },
+            { "id": "medium", "label": "Medium" },
+            { "id": "high", "label": "High" },
+            { "id": "xhigh", "label": "Extra high" },
+            { "id": "max", "label": "Max" },
+            { "id": "ultrathink", "label": "Ultrathink", "description": "Asks for the longest thinking in the prompt itself" }
+          ]
+        },
+        {
+          "id": "contextWindow",
+          "label": "Context window",
+          "type": "select",
+          "defaultChoice": "1m",
+          "choices": [
+            { "id": "200k", "label": "200k" },
+            { "id": "1m", "label": "1M" }
+          ]
+        }
+      ],
+      "contextWindowTokens": { "200k": 200000, "1m": 1000000 }
+    },
+    "opus": {
+      "options": [
+        {
+          "id": "effort",
+          "label": "Reasoning",
+          "type": "select",
+          "defaultChoice": "high",
+          "choices": [
+            { "id": "low", "label": "Low" },
+            { "id": "medium", "label": "Medium" },
+            { "id": "high", "label": "High" },
+            { "id": "xhigh", "label": "Extra high" },
+            { "id": "max", "label": "Max" },
+            { "id": "ultrathink", "label": "Ultrathink", "description": "Asks for the longest thinking in the prompt itself" }
+          ]
+        },
+        {
+          "id": "contextWindow",
+          "label": "Context window",
+          "type": "select",
+          "defaultChoice": "1m",
+          "choices": [
+            { "id": "200k", "label": "200k" },
+            { "id": "1m", "label": "1M" }
+          ]
+        },
+        {
+          "id": "fastMode",
+          "label": "Fast mode",
+          "type": "boolean",
+          "defaultValue": false,
+          "description": "Answers sooner and spends usage faster"
+        }
+      ],
+      "contextWindowTokens": { "200k": 200000, "1m": 1000000 }
+    },
+    "sonnet": {
+      "options": [
+        {
+          "id": "effort",
+          "label": "Reasoning",
+          "type": "select",
+          "defaultChoice": "high",
+          "choices": [
+            { "id": "low", "label": "Low" },
+            { "id": "medium", "label": "Medium" },
+            { "id": "high", "label": "High" },
+            { "id": "xhigh", "label": "Extra high" },
+            { "id": "max", "label": "Max" },
+            { "id": "ultrathink", "label": "Ultrathink", "description": "Asks for the longest thinking in the prompt itself" }
+          ]
+        },
+        {
+          "id": "contextWindow",
+          "label": "Context window",
+          "type": "select",
+          "defaultChoice": "200k",
+          "choices": [
+            { "id": "200k", "label": "200k" },
+            { "id": "1m", "label": "1M" }
+          ]
+        }
+      ],
+      "contextWindowTokens": { "200k": 200000, "1m": 1000000 }
+    },
+    "haiku": {
+      "options": [{ "id": "thinking", "label": "Thinking", "type": "boolean", "defaultValue": true }],
+      "contextWindowTokens": { "*": 200000 }
+    }
+  },
+  "models": [
+    { "slug": "claude-fable-5-1", "name": "Claude Fable 5.1", "profile": "frontier", "aliases": ["fable"] },
+    { "slug": "claude-opus-5-5", "name": "Claude Opus 5.5", "badge": "new", "profile": "opus", "aliases": ["opus"] },
+    { "slug": "claude-opus-5", "name": "Claude Opus 5", "profile": "opus" },
+    { "slug": "claude-sonnet-5-5", "name": "Claude Sonnet 5.5", "badge": "new", "profile": "sonnet", "aliases": ["sonnet"] },
+    { "slug": "claude-sonnet-5", "name": "Claude Sonnet 5", "profile": "sonnet" },
+    { "slug": "claude-haiku-4-5", "name": "Claude Haiku 4.5", "profile": "haiku", "aliases": ["haiku"] },
+    { "slug": "claude-opus-4-6", "name": "Claude Opus 4.6", "profile": "frontier", "legacy": true },
+    { "slug": "claude-sonnet-4-6", "name": "Claude Sonnet 4.6", "profile": "sonnet", "legacy": true }
+  ]
+}

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

@@ -0,0 +1,4 @@
+import { type ClaudeBackendOptions } from '../chat/claude-backend.ts';
+import type { ChatProvider } from './provider.ts';
+export declare function createClaudeProvider(options?: ClaudeBackendOptions): ChatProvider;
+export declare const claudeProvider: ChatProvider;

package/dist/providers/claude-provider.js

@@ -0,0 +1,29 @@
+import { ClaudeBackend } from '../chat/claude-backend.js';
+import { ModelCatalog } from './catalog.js';
+import { CLAUDE_CAPABILITIES, CLAUDE_RESUME_COMMAND } from './claude.js';
+import { detectCli } from './detect.js';
+export function createClaudeProvider(options = {}) {
+    return {
+        kind: 'claude',
+        name: 'Claude Code',
+        catalog: new ModelCatalog(),
+        capabilities: CLAUDE_CAPABILITIES,
+        command: ['claude'],
+        resumeCommand: CLAUDE_RESUME_COMMAND,
+        // Read from the strings of Claude Code 2.1.282; never HOME, which moves the keychain lookup along with it.
+        home: {
+            env: 'CLAUDE_CONFIG_DIR',
+            fallback: '.claude',
+            loginEnv: ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'CLAUDE_CODE_OAUTH_TOKEN'],
+            loginCommand: 'claude auth login'
+        },
+        detect: detectCli,
+        oneShotArgs: (prompt) => ['-p', prompt, '--output-format', 'text'],
+        // `-p` without a prompt argument reads the prompt from stdin.
+        oneShotStdinArgs: ['-p', '--output-format', 'text'],
+        // `claude [options] [prompt]`: the prompt is the positional, and without -p the session stays.
+        firstPromptArgs: (prompt) => [prompt],
+        createBackend: (launch, host) => new ClaudeBackend(launch, host, options)
+    };
+}
+export const claudeProvider = createClaudeProvider();

package/dist/providers/claude.d.ts

@@ -0,0 +1,15 @@
+import type { ModelSelection, ProviderCapabilities, RuntimeMode } from '@adecore/agent-contracts';
+export declare function claudeRuntimeMode(mode: string): RuntimeMode | undefined;
+interface ClaudeLaunch {
+    selection: ModelSelection;
+    runtimeMode: RuntimeMode;
+    resume: string | null;
+    allowedTools?: readonly string[];
+    folders?: readonly string[];
+}
+export declare function claudeArgs(launch: ClaudeLaunch): string[];
+export declare function claudeEnv(selection: ModelSelection): Record<string, string>;
+export declare const CLAUDE_CAPABILITIES: ProviderCapabilities;
+export declare const CLAUDE_RESUME_COMMAND = "claude {flags} --resume {id}";
+export declare function promptPrefix(selection: ModelSelection): string;
+export {};