@adecore/agents 0.31.3 → 0.31.5

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

@@ -17,6 +17,8 @@ export interface AcpAgentSpec {
     model?(selection: ModelSelection): string | null;
     onSession?(info: AcpSessionInfo): void;
     onUsage?(usage: AcpUsageReport): void;
+    onContextReport?(): void;
+    onCommands?(commands: string[]): void;
     autoAllow?(request: AcpPermissionRequest): boolean;
 }
 export interface AcpUsageReport extends AcpTurnUsage {
@@ -37,6 +39,9 @@ export declare class AcpBackend implements ChatBackend {
     private contextPending;
     private prompt;
     private model;
+    private contextReported;
+    private commands;
+    private early;
     constructor(launch: BackendLaunch, host: BackendHost, spec: AcpAgentSpec);
     get running(): boolean;
     get pid(): number | null;
@@ -49,6 +54,7 @@ export declare class AcpBackend implements ChatBackend {
     private applyModel;
     private applyThoughtLevel;
     private promptBlocks;
+    private mentionBlocks;
     sendTurn(input: TurnInput): void;
     compact(): void;
     interrupt(): void;
@@ -60,6 +66,7 @@ export declare class AcpBackend implements ChatBackend {
     private respond;
     private fail;
     private handleFrame;
+    private holdEarly;
     private hostAllows;
     private handleExit;
     private report;

package/dist/chat/acp-backend.js

@@ -1,13 +1,22 @@
-import { readFileSync } from 'node:fs';
+import { readFileSync, realpathSync, statSync } from 'node:fs';
+import { isAbsolute, relative, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { attachmentImageMime } from '@adecore/agent-contracts';
 import { errorText } from '../error-text.js';
 import { MODE_ORDER } from '../modes.js';
-import { ACP_AUTH_REQUIRED, ACP_PROTOCOL_VERSION, AcpProtocol, acpStopWords, autoAllows, parseInitialize, parseSessionInfo, promptUsageOf, resolveAcpMode, runtimeModeOf, sessionIdOf } from './acp-protocol.js';
+import { ACP_AUTH_REQUIRED, ACP_PROTOCOL_VERSION, AcpProtocol, acpStopWords, autoAllows, parseInitialize, parseSessionInfo, promptUsageOf, resolveAcpMode, runtimeModeOf, sessionIdOf, sessionUpdateOf, thoughtLevelOf } from './acp-protocol.js';
 import { attachmentNote } from './input.js';
 import { JsonRpcError, JsonRpcTransport } from './json-rpc-transport.js';
 export const DEFAULT_ACP_CLIENT = { name: 'agents', title: 'Agents', version: '0.1.0' };
 // What `initialize` and a session request may take; a prompt and a login wait for as long as the agent runs.
 const REQUEST_TIMEOUT_MS = 60_000;
+// What a prompt carries of mentioned files; a larger file stays a path the agent opens with its own tools.
+const MAX_EMBEDDED_FILE_BYTES = 256 * 1024;
+const MAX_EMBEDDED_BYTES = 1024 * 1024;
+function inside(folder, path) {
+    const rest = relative(folder, path);
+    return rest === '' || (!rest.startsWith('..') && !isAbsolute(rest));
+}
 function nameOf(client) {
     return client.title ?? client.name;
 }
@@ -31,6 +40,10 @@ export class AcpBackend {
     contextPending = null;
     prompt = null;
     model = null;
+    contextReported = false;
+    commands = [];
+    // An agent may send updates for a new session before it answers with the session's id.
+    early = [];
     constructor(launch, host, spec) {
         this.launch = launch;
         this.host = host;
@@ -86,9 +99,9 @@ export class AcpBackend {
         this.capabilities = capabilities;
         const info = await this.openSession(transport, capabilities);
         const modeId = await this.applyMode(transport, info);
-        const model = await this.applyModel(transport, info);
+        const { model, thoughtLevel } = await this.applyModel(transport, info);
         this.model = model;
-        await this.applyThoughtLevel(transport, info);
+        await this.applyThoughtLevel(transport, thoughtLevel);
         this.spec.onSession?.(info);
         this.emit({
             type: 'session',
@@ -97,6 +110,9 @@ export class AcpBackend {
             effectiveRuntimeMode: this.launch.runtimeMode,
             ...(modeId === null ? {} : { permissionMode: modeId })
         });
+        for (const params of this.early.splice(0)) {
+            this.emitAll(this.protocol.update(this.sessionId, params));
+        }
     }
     sessionParams() {
         const folders = this.launch.folders ?? [];
@@ -191,25 +207,29 @@ export class AcpBackend {
         }
         return resolved.modeId;
     }
-    /* Switches to the selected model where the agent offers it; answers the model the session runs. */
+    /*
+     * Switches to the selected model where the agent offers it; answers the model the session runs and the
+     * reasoning effort it offers there, which may change with the model.
+     */
     async applyModel(transport, info) {
         const models = info.models;
+        const thoughtLevel = info.thoughtLevel;
         const wanted = this.spec.model ? this.spec.model(this.launch.selection) : this.launch.selection.model;
         if (models === null || wanted === null || wanted === models.current) {
-            return models?.current ?? wanted;
+            return { model: models?.current ?? wanted, thoughtLevel };
         }
         if (!models.models.some((model) => model.id === wanted)) {
             this.emit({ type: 'note', level: 'warning', text: `${this.spec.name} does not offer ${this.launch.modelName}. It runs ${models.current}.` });
-            return models.current;
+            return { model: models.current, thoughtLevel };
         }
         try {
             if (models.configId === null) {
                 await transport.request('session/set_model', { sessionId: this.sessionId, modelId: wanted });
+                return { model: wanted, thoughtLevel };
             }
-            else {
-                await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: models.configId, value: wanted });
-            }
-            return wanted;
+            const result = await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: models.configId, value: wanted });
+            const after = thoughtLevelOf(result);
+            return { model: wanted, thoughtLevel: after === undefined ? thoughtLevel : after };
         }
         catch (error) {
             if (!(error instanceof JsonRpcError)) {
@@ -220,20 +240,26 @@ export class AcpBackend {
                 level: 'warning',
                 text: `${this.spec.name} did not switch to ${this.launch.modelName} (${errorText(error)}). It runs ${models.current}.`
             });
-            return models.current;
+            return { model: models.current, thoughtLevel };
         }
     }
-    async applyThoughtLevel(transport, info) {
-        const level = info.thoughtLevel;
+    /* Sets the selected effort where the session offers it; a model without one runs as it is. */
+    async applyThoughtLevel(transport, level) {
         const effort = this.launch.selection.options.effort;
-        if (level === null || typeof effort !== 'string' || effort === level.current || !level.values.includes(effort)) {
+        const choice = level?.choices.find((entry) => entry.id === effort);
+        if (level === null || choice === undefined || effort === level.current) {
             return;
         }
-        await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: level.configId, value: effort }).catch((error) => {
+        try {
+            await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: level.configId, value: choice.id });
+        }
+        catch (error) {
             if (!(error instanceof JsonRpcError)) {
                 throw error;
             }
-        });
+            const current = level.choices.find((entry) => entry.id === level.current)?.name ?? level.current;
+            this.emit({ type: 'note', level: 'warning', text: `${this.spec.name} kept its reasoning at ${current} instead of ${choice.name}.` });
+        }
     }
     promptBlocks(input) {
         const sendsImages = this.capabilities?.images === true;
@@ -251,7 +277,51 @@ export class AcpBackend {
         const named = input.attachments.filter((attachment) => !images.includes(attachment));
         const parts = [this.contextPending, input.preamble, input.text, attachmentNote(named)].filter((part) => part !== null && part !== '');
         this.contextPending = null;
-        return [{ type: 'text', text: parts.join('\n\n') }, ...blocks];
+        return [{ type: 'text', text: parts.join('\n\n') }, ...blocks, ...this.mentionBlocks(input.mentions)];
+    }
+    /*
+     * The text of each mentioned file as a `resource` block, for an agent that takes embedded context. Only a text file
+     * inside the chat's folders goes along, since a mention is a path anyone who may send could name; the rest stays
+     * in the prompt as the path it is.
+     */
+    mentionBlocks(mentions) {
+        if (this.capabilities?.embeddedContext !== true || mentions.length === 0) {
+            return [];
+        }
+        const real = (path) => {
+            try {
+                return realpathSync(path);
+            }
+            catch {
+                return null;
+            }
+        };
+        const folders = [this.launch.cwd, ...(this.launch.folders ?? [])].flatMap((folder) => real(folder) ?? []);
+        const blocks = [];
+        let budget = MAX_EMBEDDED_BYTES;
+        for (const mention of new Set(mentions)) {
+            const path = real(resolve(this.launch.cwd, mention));
+            if (path === null || !folders.some((folder) => inside(folder, path))) {
+                continue;
+            }
+            let text;
+            try {
+                const stat = statSync(path);
+                if (!stat.isFile() || stat.size > MAX_EMBEDDED_FILE_BYTES || stat.size > budget) {
+                    continue;
+                }
+                text = readFileSync(path, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            if (text.includes('\u0000')) {
+                continue;
+            }
+            budget -= Buffer.byteLength(text);
+            blocks.push({ type: 'resource', resource: { uri: pathToFileURL(path).href, text } });
+        }
+        return blocks;
     }
     sendTurn(input) {
         const transport = this.transport;
@@ -279,8 +349,12 @@ export class AcpBackend {
             }
         });
     }
-    /* ACP has no call to fold the context; a host that offers it sends the agent's own command as a prompt. */
+    /* ACP has no call to fold the context, so an agent that lists a `compact` command gets it as a prompt. */
     compact() {
+        if (this.commands.includes('compact')) {
+            this.sendTurn({ text: '/compact', preamble: null, attachments: [], mentions: [], skills: [] });
+            return;
+        }
         this.emit({ type: 'note', level: 'warning', text: `${this.spec.name} cannot fold its context on request.` });
         this.emit({ type: 'turn.done', state: 'done', costUsd: 0 });
     }
@@ -351,9 +425,11 @@ export class AcpBackend {
         }
         const id = typeof frame.id === 'number' || typeof frame.id === 'string' ? frame.id : null;
         if (frame.method === 'session/update' && id === null) {
-            if (!this.replaying) {
-                this.emitAll(this.protocol.update(this.sessionId, frame.params));
+            if (this.sessionId === '' || this.replaying) {
+                this.holdEarly(frame.params);
+                return;
             }
+            this.emitAll(this.protocol.update(this.sessionId, frame.params));
             return;
         }
         if (id === null) {
@@ -386,6 +462,13 @@ export class AcpBackend {
         }
         this.emitAll(permission.events);
     }
+    /* Holds an update until the session is known; of a history a load replays, only the commands, since the thread has the rest. */
+    holdEarly(params) {
+        const update = sessionUpdateOf(params);
+        if (update !== null && (!this.replaying || update.commands !== null)) {
+            this.early.push(params);
+        }
+    }
     hostAllows(request) {
         try {
             return this.spec.autoAllow?.(request) === true;
@@ -420,6 +503,14 @@ export class AcpBackend {
         if (event.type === 'model') {
             this.model = event.model;
         }
+        if (event.type === 'session' && event.slashCommands !== undefined) {
+            this.commands = event.slashCommands;
+            this.spec.onCommands?.(event.slashCommands);
+        }
+        if (event.type === 'usage' && event.contextWindow !== undefined && !this.contextReported) {
+            this.contextReported = true;
+            this.spec.onContextReport?.();
+        }
         this.host.onEvent(event);
     }
 }

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

@@ -29,6 +29,7 @@ export interface AcpAgentCapabilities {
     additionalDirectories: boolean;
     closeSession: boolean;
     images: boolean;
+    embeddedContext: boolean;
     authMethods: string[];
     agent: AcpAgentInfo | null;
 }
@@ -37,6 +38,7 @@ export interface AcpModel {
     id: string;
     name: string;
     description: string | null;
+    contextWindow: number | null;
 }
 export interface AcpModelState {
     current: string;
@@ -52,18 +54,29 @@ export interface AcpModeState {
     modes: AcpMode[];
     configId: string | null;
 }
+export interface AcpChoice {
+    id: string;
+    name: string;
+    description: string | null;
+}
+export interface AcpThoughtLevel {
+    configId: string;
+    current: string;
+    choices: AcpChoice[];
+}
 export interface AcpSessionInfo {
     sessionId: string;
     agent: AcpAgentInfo | null;
     models: AcpModelState | null;
     modes: AcpModeState | null;
-    thoughtLevel: {
-        configId: string;
-        current: string;
-        values: string[];
-    } | null;
+    thoughtLevel: AcpThoughtLevel | null;
 }
+export declare function thoughtLevelOf(result: unknown): AcpThoughtLevel | null | undefined;
 export declare function parseSessionInfo(result: unknown, sessionId: string, agent: AcpAgentInfo | null): AcpSessionInfo;
+export declare function sessionUpdateOf(params: unknown): {
+    sessionId: string;
+    commands: string[] | null;
+} | null;
 export declare function sessionIdOf(result: unknown): string | null;
 export type AcpModeMap = Partial<Record<RuntimeMode, readonly string[]>>;
 export declare function resolveAcpMode(requested: RuntimeMode, map: AcpModeMap, offered: readonly string[]): {

package/dist/chat/acp-protocol.js

@@ -75,7 +75,7 @@ const ModeStateSchema = z.looseObject({
     availableModes: z.array(z.unknown())
 });
 const ModeSchema = z.looseObject({ id: z.string(), name: z.string() });
-const SelectValueSchema = z.looseObject({ value: z.string(), name: z.string() });
+const SelectValueSchema = z.looseObject({ value: z.string(), name: z.string(), description: z.string().nullish(), _meta: z.unknown().optional() });
 const ConfigOptionSchema = z.looseObject({
     id: z.string(),
     name: z.string(),
@@ -89,14 +89,19 @@ const ModelStateSchema = z.looseObject({
     currentModelId: z.string(),
     availableModels: z.array(z.unknown())
 });
-const ModelEntrySchema = z.looseObject({ modelId: z.string(), name: z.string(), description: z.string().nullish() });
+const ModelEntrySchema = z.looseObject({ modelId: z.string(), name: z.string(), description: z.string().nullish(), _meta: z.unknown().optional() });
+/* The context window an agent names for a model in the model's `_meta` (`totalContextTokens`, not part of the protocol); null where it names none. */
+function contextWindowOf(meta) {
+    const tokens = isRecord(meta) ? meta.totalContextTokens : undefined;
+    return typeof tokens === 'number' && Number.isSafeInteger(tokens) && tokens > 0 ? tokens : null;
+}
 const AuthMethodSchema = z.looseObject({ id: z.string(), name: z.string() });
 const InitializeResponseSchema = z.looseObject({
     protocolVersion: z.number(),
     agentCapabilities: z
         .looseObject({
         loadSession: z.boolean().optional(),
-        promptCapabilities: z.looseObject({ image: z.boolean().optional() }).optional(),
+        promptCapabilities: z.looseObject({ image: z.boolean().optional(), embeddedContext: z.boolean().optional() }).optional(),
         sessionCapabilities: z
             .looseObject({
             resume: z.unknown().optional(),
@@ -132,6 +137,7 @@ export function parseInitialize(result) {
         additionalDirectories: sessions?.additionalDirectories !== undefined && sessions.additionalDirectories !== null,
         closeSession: sessions?.close !== undefined && sessions.close !== null,
         images: capabilities?.promptCapabilities?.image === true,
+        embeddedContext: capabilities?.promptCapabilities?.embeddedContext === true,
         authMethods: validItems(AuthMethodSchema, parsed.data.authMethods).map((method) => method.id),
         agent: agent ? { name: agent.name, title: agent.title ?? null, version: agent.version } : null
     };
@@ -144,6 +150,18 @@ function selectValues(option) {
 function selectOption(options, category) {
     return options.find((option) => option.type === 'select' && option.category === category && typeof option.currentValue === 'string') ?? null;
 }
+function thoughtOption(options) {
+    return (selectOption(options, 'thought_level') ??
+        options.find((option) => option.type === 'select' && option.id === 'reasoning_effort' && typeof option.currentValue === 'string') ??
+        null);
+}
+/* The reasoning effort in a response that carries the session's config options; undefined when it carries none. */
+export function thoughtLevelOf(result) {
+    if (!isRecord(result) || !Array.isArray(result.configOptions)) {
+        return undefined;
+    }
+    return sessionState(validItems(ConfigOptionSchema, result.configOptions), null, null).thoughtLevel;
+}
 export function parseSessionInfo(result, sessionId, agent) {
     const record = isRecord(result) ? result : {};
     const options = validItems(ConfigOptionSchema, Array.isArray(record.configOptions) ? record.configOptions : []);
@@ -152,14 +170,19 @@ export function parseSessionInfo(result, sessionId, agent) {
 function sessionState(options, modes, models) {
     const modelOption = selectOption(options, 'model');
     const modeOption = selectOption(options, 'mode');
-    const thoughtOption = selectOption(options, 'thought_level');
+    const thought = thoughtOption(options);
     const modeState = ModeStateSchema.safeParse(modes);
     const modelState = ModelStateSchema.safeParse(models);
     return {
         models: modelOption
             ? {
                 current: modelOption.currentValue,
-                models: selectValues(modelOption).map((value) => ({ id: value.value, name: value.name, description: null })),
+                models: selectValues(modelOption).map((value) => ({
+                    id: value.value,
+                    name: value.name,
+                    description: null,
+                    contextWindow: contextWindowOf(value._meta)
+                })),
                 configId: modelOption.id
             }
             : modelState.success
@@ -168,7 +191,8 @@ function sessionState(options, modes, models) {
                     models: validItems(ModelEntrySchema, modelState.data.availableModels).map((model) => ({
                         id: model.modelId,
                         name: model.name,
-                        description: model.description ?? null
+                        description: model.description ?? null,
+                        contextWindow: contextWindowOf(model._meta)
                     })),
                     configId: null
                 }
@@ -186,11 +210,30 @@ function sessionState(options, modes, models) {
                     configId: null
                 }
                 : null,
-        thoughtLevel: thoughtOption
-            ? { configId: thoughtOption.id, current: thoughtOption.currentValue, values: selectValues(thoughtOption).map((value) => value.value) }
+        thoughtLevel: thought
+            ? {
+                configId: thought.id,
+                current: thought.currentValue,
+                choices: selectValues(thought).map((value) => ({ id: value.value, name: value.name, description: value.description ?? null }))
+            }
             : null
     };
 }
+function commandNames(commands) {
+    return validItems(CommandSchema, Array.isArray(commands) ? commands : []).map((command) => command.name);
+}
+/* The session a `session/update` notification is for, and the commands it lists when it is an `available_commands_update`; null when it does not parse. */
+export function sessionUpdateOf(params) {
+    const notification = SessionNotificationSchema.safeParse(params);
+    if (!notification.success) {
+        return null;
+    }
+    const update = notification.data.update;
+    return {
+        sessionId: notification.data.sessionId,
+        commands: update.sessionUpdate === 'available_commands_update' ? commandNames(update.availableCommands) : null
+    };
+}
 export function sessionIdOf(result) {
     const parsed = SessionResponseSchema.safeParse(result);
     return parsed.success ? (parsed.data.sessionId ?? null) : null;
@@ -390,10 +433,8 @@ export class AcpProtocol {
             }
             case 'plan':
                 return this.plan(update);
-            case 'available_commands_update': {
-                const commands = validItems(CommandSchema, Array.isArray(update.availableCommands) ? update.availableCommands : []);
-                return [{ type: 'session', agentSessionId: null, model: null, slashCommands: commands.map((command) => command.name) }];
-            }
+            case 'available_commands_update':
+                return [{ type: 'session', agentSessionId: null, model: null, slashCommands: commandNames(update.availableCommands) }];
             case 'current_mode_update':
                 return typeof update.currentModeId === 'string' ? [this.modeEvent(update.currentModeId)] : [];
             case 'config_option_update': {

package/dist/chat/index.d.ts

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

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

@@ -15,5 +15,6 @@ export interface AcpAccountProbe {
     timeoutMs?: number;
     timer?: ProbeTimer;
     onSession?(info: AcpSessionInfo): void;
+    onCommands?(commands: string[]): void;
 }
 export declare function askAcpAccount(probe: AcpAccountProbe): Promise<AccountReading>;

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

@@ -2,7 +2,7 @@ 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 { ACP_AUTH_REQUIRED, ACP_PROTOCOL_VERSION, parseInitialize, parseSessionInfo, sessionIdOf, sessionUpdateOf } 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 };
@@ -35,6 +35,21 @@ export async function askAcpAccount(probe) {
     const folder = await mkdtemp(join(tmpdir(), 'acp-account-'));
     const client = probe.client ?? DEFAULT_ACP_CLIENT;
     let transport = null;
+    // An agent may list its commands before it answers with the session's id.
+    const listed = new Map();
+    let sessionId = null;
+    const noteCommands = (frame) => {
+        const update = frame.method === 'session/update' && (frame.id === undefined || frame.id === null) ? sessionUpdateOf(frame.params) : null;
+        if (update === null || update.commands === null) {
+            return;
+        }
+        if (sessionId === null) {
+            listed.set(update.sessionId, update.commands);
+        }
+        else if (update.sessionId === sessionId) {
+            probe.onCommands?.(update.commands);
+        }
+    };
     try {
         const started = new JsonRpcTransport({
             command: [...probe.command],
@@ -46,7 +61,10 @@ export async function askAcpAccount(probe) {
             // The probe's own deadline covers every request.
             requestTimeoutMs: null,
             versionField: true,
-            onFrame: (frame) => refuseRequest(started, frame),
+            onFrame: (frame) => {
+                noteCommands(frame);
+                refuseRequest(started, frame);
+            },
             onExit: () => undefined
         });
         transport = started;
@@ -69,11 +87,15 @@ export async function askAcpAccount(probe) {
                 }
                 throw error;
             }
-            const sessionId = sessionIdOf(result);
+            sessionId = sessionIdOf(result);
             if (sessionId === null) {
                 throw new Error(`${probe.name} opened a session without an id`);
             }
             probe.onSession?.(parseSessionInfo(result, sessionId, capabilities.agent));
+            const commands = listed.get(sessionId);
+            if (commands !== undefined) {
+                probe.onCommands?.(commands);
+            }
             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);

package/dist/providers/acp-agent-state.d.ts

@@ -0,0 +1,35 @@
+import { type ProviderCapabilities } from '@adecore/agent-contracts';
+import type { AcpSessionInfo } from '../chat/acp-protocol.ts';
+import type { ModelCatalog } from './catalog.ts';
+export interface AcpCatalogStore {
+    load(): unknown;
+    save(value: unknown): void;
+}
+export interface AcpAgentStateOptions {
+    catalog: ModelCatalog;
+    adoptModels: boolean;
+    store: AcpCatalogStore | null;
+    base: ProviderCapabilities;
+    overrides: Partial<ProviderCapabilities>;
+}
+export declare class AcpAgentState {
+    readonly capabilities: ProviderCapabilities;
+    private readonly options;
+    private readonly listeners;
+    private adopted;
+    private reportsContext;
+    private commands;
+    constructor(options: AcpAgentStateOptions);
+    onChange(listener: () => void): () => void;
+    session(info: AcpSessionInfo): void;
+    commandsListed(commands: readonly string[]): void;
+    contextReported(): void;
+    private restore;
+    private learned;
+    private refresh;
+    private adopt;
+    private settle;
+    private save;
+    private notify;
+    private stored;
+}