@adecore/agents 0.31.4 → 0.31.5

package/dist/providers/acp-provider.js

@@ -1,10 +1,11 @@
 import { createAcpBackend } from '../chat/acp-backend.js';
 import { askAcpAccount } from './accounts/acp-account.js';
+import { AcpAgentState } from './acp-agent-state.js';
 import { writeAcpUsage } from './acp-usage-log.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.
+ * What every ACP agent can do through this backend, before what it shows of itself. A file change comes as the text
+ * before and after; a message names its mentions and attachments by path, and carries the files themselves where the agent takes them.
  */
 export const ACP_CAPABILITIES = {
     chat: true,
@@ -25,38 +26,22 @@ export const ACP_CAPABILITIES = {
 };
 /* Agents whose own usage files the scanner reads; a log of their turns would count every one twice. */
 const OWN_USAGE_FILES = new Set(['grok']);
-/* An agent's model id may reach a command line, so one that reads as a flag is left out. */
-function adoptableModels(info) {
-    return (info.models?.models ?? []).filter((model) => model.id !== '' && !model.id.startsWith('-')).map((model) => ({ slug: model.id, name: model.name }));
-}
-/* The reasoning effort a session offers, as the `effort` option the composer draws for every provider. */
-function effortOption(info) {
-    const level = info.thoughtLevel;
-    if (level === null || !level.choices.some((choice) => choice.id === level.current)) {
-        return [];
-    }
-    return [
-        {
-            id: 'effort',
-            label: 'Reasoning',
-            type: 'select',
-            defaultChoice: level.current,
-            choices: level.choices.map((choice) => ({
-                id: choice.id,
-                label: choice.name,
-                ...(choice.description === null ? {} : { description: choice.description })
-            }))
-        }
-    ];
-}
 export function createAcpProvider(spec) {
-    const capabilities = { ...ACP_CAPABILITIES, ...spec.capabilities };
+    const state = new AcpAgentState({
+        catalog: spec.catalog,
+        adoptModels: spec.adoptModels !== false,
+        store: spec.catalogStore ?? null,
+        base: ACP_CAPABILITIES,
+        overrides: spec.capabilities ?? {}
+    });
     const onSession = (info) => {
-        if (spec.adoptModels !== false && info.models !== null) {
-            spec.catalog.adopt(adoptableModels(info), info.models.current, effortOption(info));
-        }
+        state.session(info);
         spec.onSession?.(info);
     };
+    const onCommands = (commands) => {
+        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
@@ -68,7 +53,8 @@ export function createAcpProvider(spec) {
         kind: spec.kind,
         name: spec.name,
         catalog: spec.catalog,
-        capabilities,
+        capabilities: state.capabilities,
+        onChange: (listener) => state.onChange(listener),
         command: [spec.command, ...(spec.args ?? [])],
         resumeCommand: spec.resumeCommand ?? '',
         ...(spec.ignoresProjectConfig === undefined ? {} : { ignoresProjectConfig: spec.ignoresProjectConfig }),
@@ -90,9 +76,19 @@ export function createAcpProvider(spec) {
                     command,
                     env: { ...env, ...spec.env },
                     ...(spec.client ? { client: spec.client } : {}),
-                    onSession
+                    onSession,
+                    onCommands
                 })
             }),
-        createBackend: createAcpBackend({ ...spec, onSession, ...(onUsage === undefined ? {} : { onUsage }) })
+        createBackend: createAcpBackend({
+            ...spec,
+            onSession,
+            onCommands,
+            onContextReport: () => {
+                state.contextReported();
+                spec.onContextReport?.();
+            },
+            ...(onUsage === undefined ? {} : { onUsage })
+        })
     };
 }

package/dist/providers/catalog.d.ts

@@ -5,12 +5,14 @@ export type ModelCatalogInput = Omit<ModelCatalogData, 'updatedAt'> & {
 export declare class ModelCatalog {
     private readonly shippedAt;
     private data;
+    private hostWindows;
     constructor(data?: ModelCatalogInput);
     get defaultModel(): string;
     replace(data: ModelCatalogData): boolean;
     adopt(models: ReadonlyArray<{
         slug: string;
         name: string;
+        contextWindow?: number;
     }>, defaultModel: string, options?: readonly ModelOptionDescriptor[]): boolean;
     list(): ModelInfo[];
     nameOf(slug: string): string;

package/dist/providers/catalog.js

@@ -11,6 +11,8 @@ function timeOf(data) {
 export class ModelCatalog {
     shippedAt;
     data;
+    // The sizes the host's own default had before an agent's models replaced it, for an adopted model that names none.
+    hostWindows;
     constructor(data = manifest) {
         this.shippedAt = timeOf(data);
         this.data = data;
@@ -25,13 +27,14 @@ export class ModelCatalog {
         }
         const changed = JSON.stringify(data) !== JSON.stringify(this.data);
         this.data = data;
+        this.hostWindows = undefined;
         return changed;
     }
     /*
      * Takes the models an agent reported for itself in place of the list, the agent's current model as the
      * default and its order kept; answers whether the models changed. Every model gets the profile the
      * default has now, as an agent names its models but not what each can be asked for, with `options`
-     * in place of the profile's options of the same id.
+     * in place of the profile's options of the same id, and the context window in tokens a model names as its only size.
      */
     adopt(models, defaultModel, options = []) {
         if (models.length === 0 || !models.some((model) => model.slug === defaultModel)) {
@@ -39,12 +42,19 @@ export class ModelCatalog {
         }
         const base = this.profileOf(this.data.defaultModel) ?? { options: [], contextWindowTokens: {} };
         const replaced = new Set(options.map((option) => option.id));
-        const profile = { ...base, options: [...base.options.filter((option) => !replaced.has(option.id)), ...options] };
+        this.hostWindows ??= base.contextWindowTokens;
+        const profile = { ...base, contextWindowTokens: this.hostWindows, options: [...base.options.filter((option) => !replaced.has(option.id)), ...options] };
+        const profileName = (window) => (window === undefined ? ADOPTED_PROFILE : `${ADOPTED_PROFILE}-${window}`);
+        const profiles = {};
+        for (const model of models) {
+            profiles[profileName(model.contextWindow)] =
+                model.contextWindow === undefined ? profile : { ...profile, contextWindowTokens: { '*': model.contextWindow } };
+        }
         const data = {
             ...(this.data.updatedAt === undefined ? {} : { updatedAt: this.data.updatedAt }),
             defaultModel,
-            profiles: { [ADOPTED_PROFILE]: profile },
-            models: models.map((model) => ({ slug: model.slug, name: model.name, profile: ADOPTED_PROFILE }))
+            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;

package/dist/providers/index.d.ts

@@ -1,3 +1,4 @@
+export { type AcpCatalogStore } from './acp-agent-state.ts';
 export { ACP_CAPABILITIES, type AcpProviderSpec, createAcpProvider } from './acp-provider.ts';
 export { type AcpAccountProbe, askAcpAccount, type ProbeTimer } from './accounts/acp-account.ts';
 export { AccountError, type AccountLaunches, storedAccount, launchEnv } from './accounts/launch.ts';

package/dist/providers/index.js

@@ -1,4 +1,5 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
+export {} from './acp-agent-state.js';
 export { ACP_CAPABILITIES, createAcpProvider } from './acp-provider.js';
 export { askAcpAccount } from './accounts/acp-account.js';
 export { AccountError, storedAccount, launchEnv } from './accounts/launch.js';

package/dist/providers/provider.d.ts

@@ -25,5 +25,6 @@ export interface ChatProvider {
     detect(command: string, env: Record<string, string | undefined>): Promise<CliDetection>;
     enabled?(): boolean;
     askAccount?(command: readonly string[], env: Record<string, string | undefined>): Promise<AccountReading>;
+    onChange?(listener: () => void): () => void;
     createBackend(launch: BackendLaunch, host: BackendHost): ChatBackend;
 }

package/dist/providers/registry.d.ts

@@ -23,6 +23,7 @@ export declare class ProviderRegistry {
     oneShotProvider(preferred?: AgentKind): Promise<ChatProvider | null>;
     catalogFor(kind: AgentKind): ModelCatalog;
     enabled(kind: AgentKind): boolean;
+    onChange(listener: (kind: AgentKind) => void): () => void;
     invalidate(kind: AgentKind): void;
     protected fallback(kind: AgentKind): ChatProvider;
     private detection;

package/dist/providers/registry.js

@@ -97,6 +97,15 @@ export class ProviderRegistry {
     enabled(kind) {
         return this.get(kind).enabled?.() !== false;
     }
+    /* Calls the listener with the kind of every provider whose models or capabilities changed, so a host can list them again; answers how to stop. */
+    onChange(listener) {
+        const stops = this.providers.flatMap((provider) => (provider.onChange ? [provider.onChange(() => listener(provider.kind))] : []));
+        return () => {
+            for (const stop of stops) {
+                stop();
+            }
+        };
+    }
     invalidate(kind) {
         this.cache.delete(kind);
     }

package/dist/testing/fake-acp.d.ts

@@ -8,6 +8,9 @@ export interface FakeAcpOptions {
     closeSession?: boolean;
     turnUsage?: Record<string, number>;
     reasoningEffort?: 'accept' | 'reject';
+    contextWindows?: boolean;
+    commands?: readonly string[];
+    embeddedContext?: boolean;
 }
 export declare function fakeAcpWith(options: FakeAcpOptions): FakeCli;
 export declare const fakeAcp: FakeCli;

package/dist/testing/fake-acp.js

@@ -38,9 +38,10 @@ export function fakeAcpWith(options) {
             prompt = null;
         };
         const sessionState = () => {
+            const meta = (totalContextTokens) => (options.contextWindows ? { _meta: { totalContextTokens } } : {});
             const modelChoices = [
-                { value: 'fake-small', name: 'Fake small' },
-                { value: 'fake-large', name: 'Fake large' }
+                { value: 'fake-small', name: 'Fake small', ...meta(128000) },
+                { value: 'fake-large', name: 'Fake large', ...meta(1000000) }
             ];
             const effortChoices = [
                 { value: 'low', name: 'Low', description: 'Answers quickly' },
@@ -53,7 +54,7 @@ export function fakeAcpWith(options) {
             return {
                 ...(modes.length === 0 ? {} : { modes: { currentModeId: mode, availableModes: modes.map((id) => ({ id, name: id })) } }),
                 ...(options.legacyModels
-                    ? { models: { currentModelId: model, availableModels: modelChoices.map((choice) => ({ modelId: choice.value, name: choice.name })) } }
+                    ? { models: { currentModelId: model, availableModels: modelChoices.map(({ value, ...choice }) => ({ modelId: value, ...choice })) } }
                     : {
                         configOptions: [
                             { id: 'model', name: 'Model', type: 'select', category: 'model', currentValue: model, options: modelChoices },
@@ -193,7 +194,7 @@ export function fakeAcpWith(options) {
                         protocolVersion: 1,
                         agentCapabilities: {
                             loadSession: options.loadSession ?? true,
-                            promptCapabilities: { image: true, audio: false, embeddedContext: false },
+                            promptCapabilities: { image: true, audio: false, embeddedContext: options.embeddedContext === true },
                             sessionCapabilities: { ...(options.resumeSession ? { resume: {} } : {}), ...(options.closeSession ? { close: {} } : {}) }
                         },
                         authMethods: options.authMethod === undefined ? [] : [{ id: options.authMethod, name: 'Sign in' }],
@@ -211,6 +212,12 @@ export function fakeAcpWith(options) {
                     }
                     sessionId = `fake-session-${Math.random().toString(36).slice(2, 8)}`;
                     sessionHistory.set(sessionId, []);
+                    if (options.commands !== undefined) {
+                        update({
+                            sessionUpdate: 'available_commands_update',
+                            availableCommands: options.commands.map((name) => ({ name, description: name }))
+                        });
+                    }
                     respond(id, { sessionId, ...sessionState() });
                     return;
                 case 'session/load':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.31.4",
+  "version": "0.31.5",
   "description": "Node-compatible agent chat hosts, providers, accounts, usage and durable task coordination.",
   "type": "module",
   "exports": {
@@ -81,8 +81,8 @@
     "test": "bun --conditions=source test"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.31.4",
-    "@adecore/intelligent-ui": "0.31.4",
+    "@adecore/agent-contracts": "0.31.5",
+    "@adecore/intelligent-ui": "0.31.5",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/chat/acp-backend.ts

@@ -1,4 +1,6 @@
-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, type ChatAttachment, type ModelSelection } from '@adecore/agent-contracts';
 import { errorText } from '../error-text.ts';
 import { MODE_ORDER } from '../modes.ts';
@@ -14,6 +16,7 @@ import {
     resolveAcpMode,
     runtimeModeOf,
     sessionIdOf,
+    sessionUpdateOf,
     thoughtLevelOf,
     type AcpAgentCapabilities,
     type AcpModeMap,
@@ -56,6 +59,10 @@ export interface AcpAgentSpec {
     onSession?(info: AcpSessionInfo): void;
     // The tokens of every turn whose `session/prompt` response reports them, for a host that keeps a usage log.
     onUsage?(usage: AcpUsageReport): void;
+    // Called once per process, at the first `usage_update` that names the context window.
+    onContextReport?(): void;
+    // The slash commands a session offers (without the slash), each time the agent lists them.
+    onCommands?(commands: string[]): void;
     // A permission request the host answers itself, in any runtime mode: true allows it once without asking the
     // person, for a call the host already guards. A throw counts as false.
     autoAllow?(request: AcpPermissionRequest): boolean;
@@ -71,6 +78,15 @@ export interface AcpUsageReport extends AcpTurnUsage {
 // 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: string, path: string): boolean {
+    const rest = relative(folder, path);
+    return rest === '' || (!rest.startsWith('..') && !isAbsolute(rest));
+}
+
 function nameOf(client: AcpClientInfo): string {
     return client.title ?? client.name;
 }
@@ -95,6 +111,10 @@ export class AcpBackend implements ChatBackend {
     private contextPending: string | null = null;
     private prompt: { promptId: string | undefined; cancelled: boolean } | null = null;
     private model: string | null = null;
+    private contextReported = false;
+    private commands: string[] = [];
+    // An agent may send updates for a new session before it answers with the session's id.
+    private early: unknown[] = [];
 
     constructor(launch: BackendLaunch, host: BackendHost, spec: AcpAgentSpec) {
         this.launch = launch;
@@ -167,6 +187,9 @@ export class AcpBackend implements ChatBackend {
             effectiveRuntimeMode: this.launch.runtimeMode,
             ...(modeId === null ? {} : { permissionMode: modeId })
         });
+        for (const params of this.early.splice(0)) {
+            this.emitAll(this.protocol.update(this.sessionId, params));
+        }
     }
 
     private sessionParams(): Record<string, unknown> {
@@ -334,7 +357,50 @@ export class AcpBackend implements ChatBackend {
         const named: ChatAttachment[] = input.attachments.filter((attachment) => !images.includes(attachment));
         const parts = [this.contextPending, input.preamble, input.text, attachmentNote(named)].filter((part): part is string => 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.
+     */
+    private mentionBlocks(mentions: readonly string[]): unknown[] {
+        if (this.capabilities?.embeddedContext !== true || mentions.length === 0) {
+            return [];
+        }
+        const real = (path: string): string | null => {
+            try {
+                return realpathSync(path);
+            } catch {
+                return null;
+            }
+        };
+        const folders = [this.launch.cwd, ...(this.launch.folders ?? [])].flatMap((folder) => real(folder) ?? []);
+        const blocks: unknown[] = [];
+        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: string;
+            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: TurnInput): void {
@@ -364,8 +430,12 @@ export class AcpBackend implements ChatBackend {
             });
     }
 
-    /* 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(): void {
+        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 });
     }
@@ -443,9 +513,11 @@ export class AcpBackend implements ChatBackend {
         }
         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) {
@@ -479,6 +551,14 @@ export class AcpBackend implements ChatBackend {
         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. */
+    private holdEarly(params: unknown): void {
+        const update = sessionUpdateOf(params);
+        if (update !== null && (!this.replaying || update.commands !== null)) {
+            this.early.push(params);
+        }
+    }
+
     private hostAllows(request: AcpPermissionRequest): boolean {
         try {
             return this.spec.autoAllow?.(request) === true;
@@ -516,6 +596,14 @@ export class AcpBackend implements ChatBackend {
         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/src/chat/acp-protocol.ts

@@ -107,7 +107,7 @@ const ModeStateSchema = z.looseObject({
 
 const ModeSchema = z.looseObject({ id: z.string(), name: z.string() });
 
-const SelectValueSchema = z.looseObject({ value: z.string(), name: z.string(), description: z.string().nullish() });
+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(),
@@ -124,7 +124,13 @@ const ModelStateSchema = z.looseObject({
     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: unknown): number | null {
+    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() });
 
@@ -133,7 +139,7 @@ const InitializeResponseSchema = z.looseObject({
     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(),
@@ -172,6 +178,8 @@ export interface AcpAgentCapabilities {
     // Whether the agent takes `session/close`, which ends a session it would otherwise keep.
     closeSession: boolean;
     images: boolean;
+    // Whether a prompt may carry a file's text as a `resource` block.
+    embeddedContext: boolean;
     authMethods: string[];
     agent: AcpAgentInfo | null;
 }
@@ -191,6 +199,7 @@ export function parseInitialize(result: unknown): AcpAgentCapabilities {
         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
     };
@@ -200,6 +209,8 @@ export interface AcpModel {
     id: string;
     name: string;
     description: string | null;
+    // In tokens, where the agent names it.
+    contextWindow: number | null;
 }
 
 /* The models a session offers. `configId` is the config option that picks one, or null where the agent takes `session/set_model`. */
@@ -288,7 +299,12 @@ function sessionState(options: ConfigOption[], modes: unknown, models: unknown):
         models: modelOption
             ? {
                   current: modelOption.currentValue as string,
-                  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
@@ -297,7 +313,8 @@ function sessionState(options: ConfigOption[], modes: unknown, models: unknown):
                     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
                 }
@@ -325,6 +342,23 @@ function sessionState(options: ConfigOption[], modes: unknown, models: unknown):
     };
 }
 
+function commandNames(commands: unknown): string[] {
+    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: unknown): { sessionId: string; commands: string[] | null } | null {
+    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: unknown): string | null {
     const parsed = SessionResponseSchema.safeParse(result);
     return parsed.success ? (parsed.data.sessionId ?? null) : null;
@@ -590,10 +624,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/src/providers/accounts/acp-account.ts

@@ -2,7 +2,15 @@ import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { DEFAULT_ACP_CLIENT, type AcpClientInfo } from '../../chat/acp-backend.ts';
-import { ACP_AUTH_REQUIRED, ACP_PROTOCOL_VERSION, parseInitialize, parseSessionInfo, sessionIdOf, type AcpSessionInfo } from '../../chat/acp-protocol.ts';
+import {
+    ACP_AUTH_REQUIRED,
+    ACP_PROTOCOL_VERSION,
+    parseInitialize,
+    parseSessionInfo,
+    sessionIdOf,
+    sessionUpdateOf,
+    type AcpSessionInfo
+} from '../../chat/acp-protocol.ts';
 import type { SpawnChatProcess } from '../../chat/chat-process.ts';
 import { JsonRpcError, JsonRpcTransport, type JsonRpcFrame } from '../../chat/json-rpc-transport.ts';
 import { ASK_TIMEOUT_MS, type AccountReading } from './status.ts';
@@ -24,6 +32,8 @@ export interface AcpAccountProbe {
     timer?: ProbeTimer;
     // What the probe's session offered, for a host that fills its model catalog from the agent.
     onSession?(info: AcpSessionInfo): void;
+    // The slash commands the probe's session offered, when the agent listed them before the session closed.
+    onCommands?(commands: string[]): void;
 }
 
 const SIGNED_OUT: AccountReading = { signedIn: false, email: null, plan: null, organization: null };
@@ -63,6 +73,20 @@ export async function askAcpAccount(probe: AcpAccountProbe): Promise<AccountRead
     const folder = await mkdtemp(join(tmpdir(), 'acp-account-'));
     const client = probe.client ?? DEFAULT_ACP_CLIENT;
     let transport: JsonRpcTransport | null = null;
+    // An agent may list its commands before it answers with the session's id.
+    const listed = new Map<string, string[]>();
+    let sessionId: string | null = null;
+    const noteCommands = (frame: JsonRpcFrame): void => {
+        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],
@@ -74,7 +98,10 @@ export async function askAcpAccount(probe: AcpAccountProbe): Promise<AccountRead
             // 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;
@@ -98,11 +125,15 @@ export async function askAcpAccount(probe: AcpAccountProbe): Promise<AccountRead
                 }
                 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);