@adecore/agents 0.39.0 → 0.40.1

package/src/providers/accounts/store.ts

@@ -34,28 +34,37 @@ export type StoredAccounts = Record<string, unknown>;
 /* 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: string, providers: AccountProviders, env: Env, host: AccountsHost = DEFAULT_ACCOUNTS_HOST): Promise<StoredAccounts> {
     let parsed: unknown;
+
     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 as { accounts?: unknown }).accounts : null;
+
     if (typeof entries !== 'object' || entries === null || Array.isArray(entries)) {
         return {};
     }
+
     const stored: StoredAccounts = {};
+
     for (const [id, raw] of Object.entries(entries)) {
         if (!ProviderAccountIdSchema.safeParse(id).success) {
             continue;
         }
+
         const account = readAccount(id, raw, providers, env, host);
+
         if (account !== null) {
             stored[id] = account;
         }
     }
+
     return stored;
 }
 
@@ -66,9 +75,11 @@ export async function writeAccounts(path: string, stored: StoredAccounts): Promi
 /* What a client reads of an entry of a kind it may not know either: the fields this version knows. */
 function wireAccount(entry: unknown): ProviderAccount {
     const parsed = ProviderAccountSchema.safeParse(entry);
+
     if (!parsed.success) {
         return { kind: String((entry as { kind?: unknown }).kind) };
     }
+
     return parsed.data.env === undefined ? parsed.data : { ...parsed.data, env: redactVariables(parsed.data.env) };
 }
 
@@ -84,6 +95,7 @@ export class InvalidAccountError extends CodedError<'invalid-account'> {
 
 function storedFolders(entry: unknown): Pick<ProviderAccount, 'home' | 'shadowHome'> {
     const parsed = ProviderAccountSchema.safeParse(entry);
+
     return parsed.success ? { home: parsed.data.home, shadowHome: parsed.data.shadowHome } : {};
 }
 
@@ -102,18 +114,23 @@ function linkProblem(
     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;
 }
 
@@ -133,23 +150,31 @@ export function acceptAccounts(
 ): StoredAccounts {
     const stored: StoredAccounts = {};
     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];
             const keptKind = typeof kept === 'object' && kept !== null ? (kept as { kind?: unknown }).kind : undefined;
             stored[id] = keptKind === account.kind ? kept : account;
+
             continue;
         }
+
         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}`);
         }
+
         stored[id] = account;
     }
+
     return stored;
 }

package/src/providers/accounts/variables.ts

@@ -15,7 +15,6 @@ export class SecretsUnavailableError extends CodedError<'secrets-unavailable'> {
     }
 }
 
-/* What keeps the sensitive values; a test keeps them in memory. */
 export interface SecretStore {
     /* Null for a key it has nothing under. */
     read(key: string): Promise<string | null>;
@@ -60,18 +59,23 @@ function isPrintableAscii(value: string): boolean {
 /* 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: readonly ProviderAccountVariable[], reserved: ReservedVariables): string | null {
     const seen = new Set<string>();
+
     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;
 }
 
@@ -90,6 +94,7 @@ const NOT_FOUND = 44;
 
 async function run(args: string[], stdin?: string): Promise<{ code: number; stdout: string; stderr: string }> {
     const { exitCode, stdout, stderr } = await runProcess(['security', ...args], { ...(stdin === undefined ? {} : { stdin }) });
+
     return { code: exitCode ?? 1, stdout, stderr };
 }
 
@@ -102,24 +107,29 @@ export function keychainSecrets(service: string): SecretStore {
     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()}`);
             }

package/src/providers/acp-agent-state.ts

@@ -32,6 +32,7 @@ function capitalized(option: ModelOptionDescriptor): ModelOptionDescriptor {
     if (option.type !== 'select') {
         return option;
     }
+
     return {
         ...option,
         choices: option.choices.map((choice) => ({ ...choice, label: choice.label.charAt(0).toLocaleUpperCase('en') + choice.label.slice(1) }))
@@ -41,9 +42,11 @@ function capitalized(option: ModelOptionDescriptor): ModelOptionDescriptor {
 /* The reasoning effort a session offers, as the `effort` option the composer draws for every provider. */
 function effortOption(info: AcpSessionInfo): ModelOptionDescriptor[] {
     const level = info.thoughtLevel;
+
     if (level === null || !level.choices.some((choice) => choice.id === level.current)) {
         return [];
     }
+
     return [
         {
             id: 'effort',
@@ -62,6 +65,7 @@ function effortOption(info: AcpSessionInfo): ModelOptionDescriptor[] {
 /* Parses one stored part on its own, so a part a later version wrote differently costs only that part. */
 function storedPart<T>(schema: z.ZodType<T>, value: unknown): T | null {
     const parsed = schema.safeParse(value);
+
     return parsed.success ? parsed.data : null;
 }
 
@@ -99,6 +103,7 @@ export class AcpAgentState {
 
     onChange(listener: () => void): () => void {
         this.listeners.add(listener);
+
         return () => {
             this.listeners.delete(listener);
         };
@@ -108,20 +113,22 @@ export class AcpAgentState {
         if (!this.options.adoptModels || info.models === null) {
             return;
         }
-        const adopted: Adopted = { defaultModel: info.models.current, models: adoptableModels(info), options: effortOption(info) };
-        const changed = this.adopt(adopted);
-        this.settle(changed);
+
+        this.settle(this.adopt({ defaultModel: info.models.current, models: adoptableModels(info), options: effortOption(info) }));
     }
 
     commandsListed(commands: readonly string[]): void {
         const names = [...new Set(commands)].sort();
+
         if (this.commands !== null && JSON.stringify(names) === JSON.stringify(this.commands)) {
             return;
         }
+
         this.commands = names;
         const changed = this.refresh();
         // The commands are saved even when the capabilities stay, so a restart knows them too.
         this.save();
+
         if (changed) {
             this.notify();
         }
@@ -131,25 +138,31 @@ export class AcpAgentState {
         if (this.reportsContext) {
             return;
         }
+
         this.reportsContext = true;
         this.settle(this.refresh());
     }
 
     private restore(): void {
         let stored: unknown;
+
         try {
             stored = this.options.store?.load();
         } catch {
             return;
         }
+
         if (typeof stored !== 'object' || stored === null) {
             return;
         }
+
         const record = stored as Record<string, unknown>;
         const adopted = storedPart(AdoptedSchema, record.models);
+
         if (adopted !== null && this.options.adoptModels) {
             this.adopt(adopted);
         }
+
         this.reportsContext = record.reportsContext === true;
         this.commands = storedPart(z.array(z.string()), record.commands);
         this.refresh();
@@ -158,6 +171,7 @@ export class AcpAgentState {
     /* What the agent showed it can do, under what the host set itself. */
     private learned(): Partial<ProviderCapabilities> {
         const commands = this.commands ?? [];
+
         return {
             ...(this.reportsContext ? { reportsContextWindow: true } : {}),
             ...(commands.includes('compact') ? { compaction: 'prompt' as const } : {}),
@@ -168,14 +182,19 @@ export class AcpAgentState {
     /* Lays what the agent showed over the capabilities, in place; answers whether they changed. */
     private refresh(): boolean {
         const next: ProviderCapabilities = { ...this.options.base, ...this.learned(), ...this.options.overrides };
+
         if (JSON.stringify(next) === JSON.stringify(this.capabilities)) {
             return false;
         }
+
         const capabilities = this.capabilities as Partial<ProviderCapabilities>;
+
         for (const key of Object.keys(capabilities) as Array<keyof ProviderCapabilities>) {
             delete capabilities[key];
         }
+
         Object.assign(capabilities, next);
+
         return true;
     }
 
@@ -184,7 +203,9 @@ export class AcpAgentState {
         if (!adopted.models.some((model) => model.slug === adopted.defaultModel)) {
             return false;
         }
+
         this.adopted = adopted;
+
         return this.options.catalog.adopt(adopted.models, adopted.defaultModel, adopted.options.map(capitalized));
     }
 

package/src/providers/acp-provider.ts

@@ -72,15 +72,19 @@ export function createAcpProvider(spec: AcpProviderSpec): ChatProvider {
         base: ACP_CAPABILITIES,
         overrides: spec.capabilities ?? {}
     });
+
     const onSession = (info: AcpSessionInfo): void => {
         state.session(info);
         spec.onSession?.(info);
     };
+
     const onCommands = (commands: string[]): void => {
         state.commandsListed(commands);
         spec.onCommands?.(commands);
     };
+
     const usageLog = spec.usageLog === undefined || OWN_USAGE_FILES.has(spec.kind) ? null : spec.usageLog;
+
     const onUsage =
         usageLog === null
             ? spec.onUsage
@@ -88,6 +92,7 @@ export function createAcpProvider(spec: AcpProviderSpec): ChatProvider {
                   writeAcpUsage(usageLog, report, Date.now());
                   spec.onUsage?.(report);
               };
+
     return {
         kind: spec.kind,
         name: spec.name,

package/src/providers/acp-usage-log.ts

@@ -10,8 +10,10 @@ import { hostUsageLine } from '../usage/readers/host-log.ts';
  */
 export function writeAcpUsage(folder: string, report: AcpUsageReport, at: number): void {
     const { sessionId, cwd, model, ...tokens } = report;
+
     try {
         mkdirSync(folder, { recursive: true, mode: 0o700 });
+
         appendFileSync(
             join(folder, `${encodeURIComponent(sessionId === '' ? 'session' : sessionId)}.jsonl`),
             hostUsageLine({ at, model, session: sessionId, cwd, ...tokens }),

package/src/providers/catalog.ts

@@ -35,9 +35,11 @@ export class ModelCatalog {
         if (timeOf(data) < this.shippedAt) {
             return false;
         }
+
         const changed = JSON.stringify(data) !== JSON.stringify(this.data);
         this.data = data;
         this.hostWindows = undefined;
+
         return changed;
     }
 
@@ -55,24 +57,31 @@ export class ModelCatalog {
         if (models.length === 0 || !models.some((model) => model.slug === defaultModel)) {
             return false;
         }
+
         const base = this.profileOf(this.data.defaultModel) ?? { options: [], contextWindowTokens: {} };
         const replaced = new Set(options.map((option) => option.id));
         this.hostWindows ??= base.contextWindowTokens;
         const profile = { ...base, contextWindowTokens: this.hostWindows, options: [...base.options.filter((option) => !replaced.has(option.id)), ...options] };
+
         const profileName = (window: number | undefined): string => (window === undefined ? ADOPTED_PROFILE : `${ADOPTED_PROFILE}-${window}`);
+
         const profiles: Record<string, ModelCatalogProfile> = {};
+
         for (const model of models) {
             profiles[profileName(model.contextWindow)] =
                 model.contextWindow === undefined ? profile : { ...profile, contextWindowTokens: { '*': model.contextWindow } };
         }
+
         const data: ModelCatalogInput = {
             ...(this.data.updatedAt === undefined ? {} : { updatedAt: this.data.updatedAt }),
             defaultModel,
             profiles,
             models: models.map((model) => ({ slug: model.slug, name: model.name, profile: profileName(model.contextWindow) }))
         };
+
         const changed = JSON.stringify(data) !== JSON.stringify(this.data);
         this.data = data;
+
         return changed;
     }
 
@@ -98,6 +107,7 @@ export class ModelCatalog {
     /* Accepts a slug or an alias; unknown models answer null so the caller can decide what to do. */
     resolveModel(name: string): string | null {
         const model = this.data.models.find((entry) => entry.slug === name || entry.aliases?.includes(name));
+
         return model?.slug ?? null;
     }
 
@@ -105,8 +115,10 @@ export class ModelCatalog {
     normalize(selection: Partial<ModelSelection> | undefined): ModelSelection {
         const model = (selection?.model && this.resolveModel(selection.model)) || this.defaultModel;
         const options: ModelSelection['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;
@@ -114,20 +126,25 @@ export class ModelCatalog {
                 options[descriptor.id] = typeof given === 'boolean' ? given : descriptor.defaultValue;
             }
         }
+
         return { model, options };
     }
 
     contextWindowFor(selection: ModelSelection): number | null {
         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;
     }
 
     private profileOf(slug: string): ModelCatalogProfile | undefined {
         const model = this.data.models.find((entry) => entry.slug === slug);
+
         return model ? this.data.profiles[model.profile] : undefined;
     }
 }

package/src/providers/claude.ts

@@ -35,6 +35,7 @@ export function claudeRuntimeMode(mode: string): RuntimeMode | undefined {
     if (mode === 'default') {
         return 'supervised';
     }
+
     return (Object.keys(PERMISSION_MODE) as RuntimeMode[]).find((key) => PERMISSION_MODE[key] === mode);
 }
 
@@ -55,12 +56,15 @@ export function claudeArgs(launch: ClaudeLaunch): string[] {
         ...(launch.folders ?? []).map((folder) => `--add-dir=${folder}`),
         ...(launch.projectConfig === false ? CLAUDE_WITHOUT_PROJECT_CONFIG_ARGS : [])
     ];
+
     const contextWindow = launch.selection.options.contextWindow;
     args.push('--model', `${launch.selection.model}${contextWindow === '1m' ? '[1m]' : ''}`);
     const effort = launch.selection.options.effort;
+
     if (typeof effort === 'string' && FLAG_EFFORTS.has(effort)) {
         args.push('--effort', effort);
     }
+
     /*
      * Fast mode has no flag of its own; the CLI reads it from the settings blob, which is also the
      * opt-in the init frame asks for (without it the frame answers `sdk_opt_in_required`). It only
@@ -72,19 +76,25 @@ export function claudeArgs(launch: ClaudeLaunch): string[] {
         ...(launch.selection.options.fastMode === true ? { fastMode: true } : {}),
         ...(launch.selection.options.contextWindow === '200k' ? { autoCompactEnabled: true } : {})
     };
+
     if (Object.keys(settings).length > 0) {
         args.push('--settings', JSON.stringify(settings));
     }
+
     const permissionMode = PERMISSION_MODE[launch.runtimeMode];
+
     if (permissionMode) {
         args.push('--permission-mode', permissionMode);
     }
+
     if (permissionMode === 'bypassPermissions') {
         args.push('--allow-dangerously-skip-permissions');
     }
+
     if (launch.resume) {
         args.push('--resume', launch.resume);
     }
+
     return args;
 }
 
@@ -98,7 +108,6 @@ export function claudeEnv(selection: ModelSelection): Record<string, string> {
     return selection.options.contextWindow === '200k' ? { CLAUDE_CODE_AUTO_COMPACT_WINDOW: '200000' } : {};
 }
 
-// What the CLI can do, as far as a client has to know.
 export const CLAUDE_CAPABILITIES: ProviderCapabilities = {
     chat: true,
     terminal: true,

package/src/providers/codex-models.json

@@ -1,5 +1,5 @@
 {
-  "updatedAt": "2026-09-29T17:26:43Z",
+  "updatedAt": "2026-10-26T22:10:00Z",
   "defaultModel": "gpt-6-astra",
   "profiles": {
     "ultra": {
@@ -124,10 +124,11 @@
   "models": [
     { "slug": "gpt-6-astra", "name": "GPT-6 Astra", "profile": "ultra", "aliases": ["astra", "gpt-6"] },
     { "slug": "gpt-6.1-sol", "name": "GPT-6.1 Sol", "badge": "new", "profile": "max", "aliases": ["sol"] },
+    { "slug": "gpt-6.1-terra", "name": "GPT-6.1 Terra", "badge": "new", "profile": "ultra-low", "aliases": ["terra"] },
     { "slug": "gpt-6-sol", "name": "GPT-6 Sol", "profile": "max" },
     { "slug": "gpt-6-luna", "name": "GPT-6 Luna", "badge": "new", "profile": "max", "aliases": ["luna"] },
     { "slug": "gpt-5.6-sol", "name": "GPT-5.6 Sol", "profile": "ultra-low", "legacy": true },
-    { "slug": "gpt-5.6-terra", "name": "GPT-5.6 Terra", "profile": "ultra", "aliases": ["terra"], "badge": "retiring", "legacy": true },
+    { "slug": "gpt-5.6-terra", "name": "GPT-5.6 Terra", "profile": "ultra", "badge": "retiring", "legacy": true },
     { "slug": "gpt-5.6-luna", "name": "GPT-5.6 Luna", "profile": "max", "legacy": true },
     { "slug": "gpt-5.5", "name": "GPT-5.5", "profile": "xhigh", "legacy": true },
     { "slug": "gpt-5.3-codex-spark", "name": "GPT-5.3 Codex Spark", "profile": "spark", "aliases": ["spark"], "legacy": true }

package/src/providers/codex-rules.ts

@@ -39,6 +39,7 @@ export function defaultCodexHome(env: Record<string, string | undefined> = proce
 /* Idempotent: a file that already says the same is left alone. */
 export async function installCodexRules(path: string, rules: CodexRules): Promise<CodexRulesResult> {
     const text = codexRulesText(rules);
+
     try {
         if ((await readFile(path, 'utf8')) === text) {
             return 'unchanged';
@@ -48,7 +49,9 @@ export async function installCodexRules(path: string, rules: CodexRules): Promis
             throw new Error(`Cannot read ${path}: ${errorText(e)}`);
         }
     }
+
     await mkdir(dirname(path), { recursive: true });
     await writeAtomic(path, text, 0o644);
+
     return 'written';
 }

package/src/providers/codex.ts

@@ -30,8 +30,10 @@ export function codexThreadOptions(runtimeMode: RuntimeMode): CodexThreadOptions
 
 export function codexRuntimeMode(approvalPolicy: string, sandbox: string): RuntimeMode | undefined {
     const names: Record<string, string> = { readOnly: 'read-only', workspaceWrite: 'workspace-write', dangerFullAccess: 'danger-full-access' };
+
     return (Object.keys(THREAD_OPTIONS) as RuntimeMode[]).find((mode) => {
         const options = THREAD_OPTIONS[mode];
+
         return options.approvalPolicy === approvalPolicy && options.sandbox === (names[sandbox] ?? sandbox);
     });
 }
@@ -44,7 +46,6 @@ export function codexServiceTier(selection: ModelSelection): string | null {
     return selection.options.serviceTier === true ? CODEX_PRIORITY_TIER : null;
 }
 
-// What the app-server can do, as far as a client has to know.
 export const CODEX_CAPABILITIES: ProviderCapabilities = {
     chat: true,
     terminal: true,

package/src/providers/detect.ts

@@ -18,16 +18,21 @@ export async function detectCli(
 ): Promise<CliDetection> {
     try {
         let exited: (code: number | null) => void = () => undefined;
+
         const code = new Promise<number | null>((resolve) => {
             exited = resolve;
         });
+
         const proc = spawn({ command: [command, ...flags, '--version'], cwd: process.cwd(), env: definedEnv(env), onExit: (exitCode) => exited(exitCode) });
         proc.stdin.end();
         const output = await new Response(proc.stdout).text();
+
         if ((await code) !== 0) {
             return { installed: false, version: null };
         }
-        const version = /\d+\.\d+\.\d+/.exec(output)?.[0] ?? output.trim() ?? null;
+
+        const version = /\d+\.\d+\.\d+/.exec(output)?.[0] ?? output.trim();
+
         return { installed: true, version };
     } catch {
         return { installed: false, version: null };

package/src/providers/provider.ts

@@ -26,7 +26,7 @@ export interface ChatProvider {
     readonly name: string;
     readonly catalog: ModelCatalog;
     readonly capabilities: ProviderCapabilities;
-    // The executable and its leading arguments; a test points this at a fake CLI.
+    // The executable and its leading arguments.
     readonly command: string[];
     // What a terminal runs to continue one of this CLI's sessions; `{id}` stands for the session id.
     readonly resumeCommand: string;