@adecore/agents 0.31.11 → 0.32.0

package/dist/providers/registry.js

@@ -51,12 +51,45 @@ export class ProviderRegistry {
     detect;
     env;
     cache = new Map();
+    listeners = new Set();
+    // What the registry listens to on each provider, so one taken away is let go.
+    stops = new Map();
     constructor(options = {}) {
-        this.providers = options.providers ?? [...BUILT_IN_PROVIDERS];
+        this.providers = [...(options.providers ?? BUILT_IN_PROVIDERS)];
         this.commands = options.commands ?? {};
         this.detect = options.detect ?? null;
         this.env = options.env ?? process.env;
     }
+    /*
+     * Offers one more provider after the host started, such as a CLI a person installed since, or puts it in the
+     * place of the one of its kind. The `onChange` listeners hear its kind, so a host hands its clients the new list.
+     */
+    add(provider) {
+        const index = this.providers.findIndex((entry) => entry.kind === provider.kind);
+        if (index === -1) {
+            this.providers.push(provider);
+        }
+        else {
+            this.unfollow(this.providers[index]);
+            this.providers[index] = provider;
+        }
+        this.cache.delete(provider.kind);
+        if (this.listeners.size > 0) {
+            this.follow(provider);
+        }
+        this.changed(provider.kind);
+    }
+    /* Stops offering a kind; a record that names it gets the stand-in `get` answers for a kind the host does not offer. */
+    remove(kind) {
+        const index = this.providers.findIndex((entry) => entry.kind === kind);
+        if (index === -1) {
+            return;
+        }
+        this.unfollow(this.providers[index]);
+        this.providers.splice(index, 1);
+        this.cache.delete(kind);
+        this.changed(kind);
+    }
     async list() {
         return await Promise.all(this.providers.map(async (provider) => ({
             kind: provider.kind,
@@ -97,12 +130,24 @@ 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. */
+    /*
+     * Calls the listener with the kind of every provider whose models or capabilities changed, and of every one
+     * added or removed, 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))] : []));
+        if (this.listeners.size === 0) {
+            for (const provider of this.providers) {
+                this.follow(provider);
+            }
+        }
+        this.listeners.add(listener);
         return () => {
-            for (const stop of stops) {
-                stop();
+            this.listeners.delete(listener);
+            if (this.listeners.size === 0) {
+                for (const stop of this.stops.values()) {
+                    stop();
+                }
+                this.stops.clear();
             }
         };
     }
@@ -112,6 +157,20 @@ export class ProviderRegistry {
     fallback(kind) {
         return unofferedProvider(kind);
     }
+    follow(provider) {
+        if (provider.onChange && !this.stops.has(provider)) {
+            this.stops.set(provider, provider.onChange(() => this.changed(provider.kind)));
+        }
+    }
+    unfollow(provider) {
+        this.stops.get(provider)?.();
+        this.stops.delete(provider);
+    }
+    changed(kind) {
+        for (const listener of [...this.listeners]) {
+            listener(kind);
+        }
+    }
     async detection(provider) {
         if (provider.enabled?.() === false) {
             return DISABLED;

package/dist/skills.d.ts

@@ -3,6 +3,12 @@ export interface SkillRoot {
     dir: string;
     source: ChatSkillSource;
     prefix?: string;
+    depth?: number;
+}
+export interface SkillScanLimits {
+    directories: number;
+    skills: number;
+    entries?: number;
 }
 export interface SkillRootOptions {
     home?: string;
@@ -11,7 +17,9 @@ export interface SkillRootOptions {
 export declare function parseFrontmatter(text: string): Record<string, string>;
 export declare function pluginSkillRoots(configDir: string): Promise<SkillRoot[]>;
 export declare function skillRootsFor(kind: AgentKind, cwd: string, options?: SkillRootOptions): Promise<SkillRoot[]>;
-export declare function scanSkillRoots(roots: SkillRoot[]): Promise<ChatSkill[]>;
+export declare function whileBusy<T>(operation: () => Promise<T>, wait?: (ms: number) => Promise<void>): Promise<T>;
+export declare function mapLimited<T, R>(items: readonly T[], limit: number, work: (item: T) => Promise<R>): Promise<R[]>;
+export declare function scanSkillRoots(roots: SkillRoot[], limits?: SkillScanLimits): Promise<ChatSkill[]>;
 export declare function discoverSkills(kind: AgentKind, cwd: string, options?: SkillRootOptions): Promise<ChatSkill[]>;
 export declare class SkillIndex {
     private readonly options;

package/dist/skills.js

@@ -1,8 +1,38 @@
 import { existsSync } from 'node:fs';
-import { readdir, readFile } from 'node:fs/promises';
+import { open, readdir, readFile, realpath, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, join, parse } from 'node:path';
 import { isNotFound } from './fs.js';
+const SCAN_LIMITS = { directories: 2000, skills: 1000 };
+const ENTRIES_PER_FOLDER = 1000;
+// Paths one folder resolves or reads at once, so a large folder never runs the process out of file handles.
+const SCAN_CONCURRENCY = 16;
+// A process short of file handles gets them back as other work closes its files, so a few short waits cover it.
+const BUSY_RETRIES = 3;
+const BUSY_RETRY_MS = 50;
+// Codex finds skills up to five folders below a root (`MAX_SCAN_DEPTH` of 6 in its skill loader counts the root itself).
+const CODEX_SKILL_DEPTH = 5;
+// Folders a package manager or a build fills. One may hold a SKILL.md of its own, but nothing under it is listed.
+const DEPENDENCY_FOLDERS = new Set([
+    'node_modules',
+    'bower_components',
+    'jspm_packages',
+    'vendor',
+    'Pods',
+    'Carthage',
+    'DerivedData',
+    '__pycache__',
+    'venv',
+    'site-packages',
+    'target',
+    'dist',
+    'build',
+    'out',
+    'coverage'
+]);
+// What a scan reads of a SKILL.md; the front matter sits at its top.
+const HEAD_BYTES = 64 * 1024;
+const MAX_DESCRIPTION = 1024;
 const NAME = /^[A-Za-z][A-Za-z0-9_:-]*$/;
 function unquote(value) {
     const quoted = /^(['"])([\s\S]*)\1$/.exec(value);
@@ -99,9 +129,9 @@ export async function skillRootsFor(kind, cwd, options = {}) {
     const home = options.home ?? homedir();
     if (kind === 'codex') {
         return [
-            { dir: join(home, '.agents', 'skills'), source: 'user' },
-            { dir: join(home, '.codex', 'skills'), source: 'user' },
-            ...projectDirs(cwd, home).map((dir) => ({ dir: join(dir, '.agents', 'skills'), source: 'project' }))
+            { dir: join(home, '.agents', 'skills'), source: 'user', depth: CODEX_SKILL_DEPTH },
+            { dir: join(home, '.codex', 'skills'), source: 'user', depth: CODEX_SKILL_DEPTH },
+            ...projectDirs(cwd, home).map((dir) => ({ dir: join(dir, '.agents', 'skills'), source: 'project', depth: CODEX_SKILL_DEPTH }))
         ];
     }
     const configDir = options.claudeConfigDir ?? join(home, '.claude');
@@ -111,38 +141,166 @@ export async function skillRootsFor(kind, cwd, options = {}) {
         ...(await pluginSkillRoots(configDir))
     ];
 }
-async function readSkill(root, folder) {
-    let text;
+/* Too many files open, in this process or on the system: it says nothing about the path that was asked for. */
+function isBusy(e) {
+    return typeof e === 'object' && e !== null && 'code' in e && (e.code === 'EMFILE' || e.code === 'ENFILE');
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/* Runs `operation` again a few times while the process is short of file handles, and throws if it still is. */
+export async function whileBusy(operation, wait = sleep) {
+    for (let attempt = 1;; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (e) {
+            if (!isBusy(e) || attempt > BUSY_RETRIES) {
+                throw e;
+            }
+            await wait(BUSY_RETRY_MS * attempt);
+        }
+    }
+}
+/* `work` over every item with at most `limit` running at once, answered in the order of `items`. */
+export async function mapLimited(items, limit, work) {
+    const results = new Array(items.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await work(items[index]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+    return results;
+}
+/* The top of a folder's SKILL.md, or null when it has none. A process short of file handles throws instead of finding none. */
+async function skillHead(folder) {
+    let handle;
     try {
-        text = await readFile(join(root.dir, folder, 'SKILL.md'), 'utf8');
+        handle = await whileBusy(() => open(join(folder, 'SKILL.md'), 'r'));
+    }
+    catch (e) {
+        if (isBusy(e)) {
+            throw e;
+        }
+        return null;
+    }
+    try {
+        if (!(await handle.stat()).isFile()) {
+            return null;
+        }
+        const buffer = Buffer.alloc(HEAD_BYTES);
+        const { bytesRead } = await handle.read(buffer, 0, HEAD_BYTES, 0);
+        return buffer.subarray(0, bytesRead).toString('utf8');
     }
     catch {
         return null;
     }
+    finally {
+        await handle.close();
+    }
+}
+function skillOf(root, folder, text) {
     const fields = parseFrontmatter(text);
     const own = fields.name && NAME.test(fields.name) ? fields.name : folder;
     const name = root.prefix ? `${root.prefix}:${own}` : own;
     if (!NAME.test(name)) {
         return null;
     }
-    return { name, description: fields.description ?? '', source: root.source };
+    return { name, description: (fields.description ?? '').slice(0, MAX_DESCRIPTION), source: root.source };
+}
+/* The folder a path leads to after every link, or null when it leads to no folder. */
+async function realFolder(path) {
+    try {
+        const real = await whileBusy(() => realpath(path));
+        return (await whileBusy(() => stat(real))).isDirectory() ? real : null;
+    }
+    catch (e) {
+        if (isBusy(e)) {
+            throw e;
+        }
+        return null;
+    }
+}
+/*
+ * The skills under one root, nearest first, down to the root's depth. A folder with a SKILL.md is a skill and is not
+ * searched further. Each root keeps its own record of the folders it read or went into, by real path, so a link back
+ * up ends there, while a skill two plugins link in shows under each of them.
+ */
+async function scanRoot(root, limits) {
+    const start = await realFolder(root.dir);
+    if (start === null) {
+        return [];
+    }
+    const visited = new Set([start]);
+    const depth = root.depth ?? 1;
+    const entriesPerFolder = limits.entries ?? ENTRIES_PER_FOLDER;
+    const skills = [];
+    let level = [root.dir];
+    let listed = 0;
+    for (let below = 1; below <= depth && level.length > 0; below++) {
+        const next = [];
+        for (const folder of level) {
+            if (listed >= limits.directories || skills.length >= limits.skills) {
+                return skills;
+            }
+            listed++;
+            let entries;
+            try {
+                entries = await whileBusy(() => readdir(folder, { withFileTypes: true }));
+            }
+            catch (e) {
+                if (isBusy(e)) {
+                    throw e;
+                }
+                continue;
+            }
+            // A skill manager links each skill in from a shared folder, so a link counts as much as a folder.
+            const candidates = entries
+                .filter((entry) => (entry.isDirectory() || entry.isSymbolicLink()) && !entry.name.startsWith('.'))
+                .map((entry) => ({ name: entry.name, path: join(folder, entry.name) }))
+                .sort((a, b) => a.name.localeCompare(b.name))
+                .slice(0, entriesPerFolder);
+            const reals = await mapLimited(candidates, SCAN_CONCURRENCY, (candidate) => realFolder(candidate.path));
+            const fresh = candidates.flatMap((candidate, index) => {
+                const real = reals[index];
+                return real === null || real === undefined || visited.has(real) ? [] : [{ ...candidate, real }];
+            });
+            const heads = await mapLimited(fresh, SCAN_CONCURRENCY, (candidate) => skillHead(candidate.path));
+            for (const [index, candidate] of fresh.entries()) {
+                // Two links in one folder can lead to the same place; the first one read it.
+                if (visited.has(candidate.real)) {
+                    continue;
+                }
+                const head = heads[index];
+                if (head !== null && head !== undefined) {
+                    visited.add(candidate.real);
+                    const skill = skillOf(root, candidate.name, head);
+                    if (skill !== null && skills.length < limits.skills) {
+                        skills.push(skill);
+                    }
+                }
+                else if (below < depth && !DEPENDENCY_FOLDERS.has(candidate.name)) {
+                    visited.add(candidate.real);
+                    next.push(candidate.path);
+                }
+            }
+        }
+        level = next;
+    }
+    return skills;
 }
 /* Every skill under these roots, sorted by name; the first root that carries a name wins. */
-export async function scanSkillRoots(roots) {
+export async function scanSkillRoots(roots, limits = SCAN_LIMITS) {
     const found = new Map();
     for (const root of roots) {
-        let entries;
-        try {
-            entries = await readdir(root.dir, { withFileTypes: true });
-        }
-        catch {
-            continue;
+        if (found.size >= limits.skills) {
+            break;
         }
-        // A skill manager links each skill in from a shared folder; a link to anything but a skill folder reads as no skill.
-        const folders = entries.filter((entry) => entry.isDirectory() || entry.isSymbolicLink());
-        const skills = await Promise.all(folders.map((entry) => readSkill(root, entry.name)));
-        for (const skill of skills) {
-            if (skill && !found.has(skill.name)) {
+        for (const skill of await scanRoot(root, limits)) {
+            if (!found.has(skill.name) && found.size < limits.skills) {
                 found.set(skill.name, skill);
             }
         }

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

@@ -7,6 +7,7 @@ export interface AcpCapture {
     setConfigOption: unknown;
     promptUpdates: unknown[];
     promptResponse: unknown;
+    promptError?: unknown;
     titleFromPrompt?: boolean;
 }
 export declare function fakeAcpCapture(capture: AcpCapture, answers?: unknown[]): FakeCli;

package/dist/testing/fake-acp-capture.js

@@ -13,16 +13,17 @@ export function fakeAcpCapture(capture, answers = []) {
         const play = (updates, promptId, text) => {
             for (const [index, fields] of updates.entries()) {
                 const permission = fields.permission;
-                if (permission !== undefined) {
+                const request = fields.request;
+                if (permission !== undefined || request !== undefined) {
                     const rpcId = nextRpcId++;
                     waiting = { rpcId, rest: updates.slice(index + 1), promptId, text };
-                    send({ id: rpcId, method: 'session/request_permission', params: permission });
+                    send({ id: rpcId, method: request?.method ?? 'session/request_permission', params: request?.params ?? permission });
                     return;
                 }
                 const named = capture.titleFromPrompt === true && fields.sessionUpdate === 'session_info_update';
                 update(named ? { ...fields, title: text } : fields);
             }
-            send({ id: promptId, result: capture.promptResponse });
+            send(capture.promptError === undefined ? { id: promptId, result: capture.promptResponse } : { id: promptId, error: capture.promptError });
         };
         return {
             onLine: (line) => {

package/dist/usage/accounts.js

@@ -1,5 +1,5 @@
 import { USAGE_PROVIDERS } from '@adecore/agent-contracts';
-import { definedEnv } from '../providers/accounts/launch.js';
+import { definedEnv, storedAccount } from '../providers/accounts/launch.js';
 import { accountRoots } from './roots.js';
 function isUsageProvider(kind) {
     return USAGE_PROVIDERS.includes(kind);
@@ -48,7 +48,8 @@ export function limitAccountsOf(service, nameOf, baseEnv) {
         list: () => machineAccounts(service.snapshot(), nameOf)
             .filter((account) => account.isDefault || (account.enabled && account.signedIn))
             .map((account) => ({ ...usageAccount(account), isDefault: account.isDefault })),
-        envFor: (kind, id) => definedEnv(service.envFor(kind, id, baseEnv)),
+        // A plan read is no start: the default account goes unnamed, so turning it off does not fail its read.
+        envFor: (kind, id) => definedEnv(service.envFor(kind, storedAccount(kind, id), baseEnv)),
         lastUsedAt: (id) => service.lastLaunchAt(id)
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.31.11",
+  "version": "0.32.0",
   "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.11",
-    "@adecore/intelligent-ui": "0.31.11",
+    "@adecore/agent-contracts": "0.32.0",
+    "@adecore/intelligent-ui": "0.32.0",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/chat/acp-backend.ts

@@ -1,15 +1,17 @@
 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 { attachmentImageMime, type AgentKind, type ChatAttachment, type ModelSelection } from '@adecore/agent-contracts';
 import { errorText } from '../error-text.ts';
 import { MODE_ORDER } from '../modes.ts';
 import {
     ACP_AUTH_REQUIRED,
     ACP_PROTOCOL_VERSION,
     AcpProtocol,
+    acpErrorLimit,
     acpStopWords,
     autoAllows,
+    GROK_QUESTION_METHODS,
     parseInitialize,
     parseSessionInfo,
     promptUsageOf,
@@ -21,6 +23,7 @@ import {
     type AcpAgentCapabilities,
     type AcpModeMap,
     type AcpPermissionRequest,
+    type AcpQuestion,
     type AcpSessionInfo,
     type AcpThoughtLevel,
     type AcpTurnUsage
@@ -42,6 +45,8 @@ export const DEFAULT_ACP_CLIENT: AcpClientInfo = { name: 'agents', title: 'Agent
 export interface AcpAgentSpec {
     // The agent as a person reads it, in the notes and errors the backend writes.
     name: string;
+    // Which agent this is, for an error code only that agent gives a meaning; absent reads none of them.
+    kind?: AgentKind;
     // Variables set over the launch's environment.
     env?: Record<string, string>;
     // The agent's own mode ids per runtime mode, best first. A runtime mode the agent has no id for runs in
@@ -124,7 +129,7 @@ export class AcpBackend implements ChatBackend {
         this.host = host;
         this.spec = spec;
         this.client = spec.client ?? DEFAULT_ACP_CLIENT;
-        this.protocol = new AcpProtocol(launch.generation, spec.modes ?? {}, acpStopWords(spec.name), spec.adoptTitles === true);
+        this.protocol = new AcpProtocol(launch.generation, spec.modes ?? {}, acpStopWords(spec.name), spec.adoptTitles === true, launch.now);
     }
 
     get running(): boolean {
@@ -411,7 +416,7 @@ export class AcpBackend implements ChatBackend {
     sendTurn(input: TurnInput): void {
         const transport = this.transport;
         if (!transport) {
-            this.emit({ type: 'failed', message: `session/prompt failed: ${this.spec.name} is not running` });
+            this.emit({ type: 'failed', message: `${this.spec.name} is not running` });
             return;
         }
         const prompt = this.promptBlocks(input);
@@ -430,7 +435,8 @@ export class AcpBackend implements ChatBackend {
                 // A process that went has its exit tell the thread; anything else ends this turn alone.
                 if (this.transport === transport && transport.alive && this.prompt === turn) {
                     this.prompt = null;
-                    this.emitAll(this.protocol.abort(turn.promptId, turn.cancelled ? null : errorText(error)));
+                    const limit = error instanceof JsonRpcError ? acpErrorLimit(error.code, error.data, this.spec.kind ?? null) : null;
+                    this.emitAll(this.protocol.abort(turn.promptId, turn.cancelled ? null : errorText(error), limit));
                 }
             });
     }
@@ -441,7 +447,7 @@ export class AcpBackend implements ChatBackend {
             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: 'note', level: 'warning', text: `${this.spec.name} cannot compact its context.` });
         this.emit({ type: 'turn.done', state: 'done', costUsd: 0 });
     }
 
@@ -457,7 +463,7 @@ export class AcpBackend implements ChatBackend {
         }
         this.prompt.cancelled = true;
         try {
-            for (const cancelled of this.protocol.cancelPermissions()) {
+            for (const cancelled of this.protocol.cancelRequests()) {
                 transport.respond(cancelled.rpcId, cancelled.result);
                 this.emit({ type: 'request.withdrawn', requestId: cancelled.requestId });
             }
@@ -479,12 +485,23 @@ export class AcpBackend implements ChatBackend {
         return true;
     }
 
-    /* ACP asks no questions of its own; an agent asks in its message and the next prompt answers. */
-    respondQuestion(): boolean {
-        return false;
+    respondQuestion(requestId: string, answers: Record<string, string>): boolean {
+        const answer = this.protocol.answerQuestion(requestId, answers);
+        if (!answer) {
+            return false;
+        }
+        if (!this.respond(requestId, answer.rpcId, answer.result)) {
+            return false;
+        }
+        this.emitAll(answer.events);
+        return true;
     }
 
     declineRequest(requestId: string): boolean {
+        if (this.protocol.hasQuestion(requestId)) {
+            const cancelled = this.protocol.cancelQuestion(requestId);
+            return cancelled !== null && this.respond(requestId, cancelled.rpcId, cancelled.result);
+        }
         return this.protocol.hasPermission(requestId) && this.respondApproval(requestId, 'deny');
     }
 
@@ -532,10 +549,25 @@ export class AcpBackend implements ChatBackend {
         if (id === null) {
             return;
         }
+        if (typeof frame.method === 'string' && GROK_QUESTION_METHODS.includes(frame.method)) {
+            const question = this.protocol.question(id, this.sessionId, frame.params);
+            if (question === null) {
+                transport.respondError(id, -32602, 'Not a question of this session');
+                return;
+            }
+            this.ask(transport, question);
+            return;
+        }
         if (frame.method !== 'session/request_permission') {
             transport.respondError(id, -32601, `${nameOf(this.client)} does not handle ${String(frame.method)}`);
             return;
         }
+        // Before any runtime mode answers it: a question is never the agent's to allow.
+        const interaction = this.protocol.interaction(id, this.sessionId, frame.params);
+        if (interaction !== null) {
+            this.ask(transport, interaction);
+            return;
+        }
         const permission = this.protocol.permission(id, this.sessionId, frame.params);
         if (permission === null) {
             transport.respondError(id, -32602, 'Not a permission request of this session');
@@ -543,7 +575,7 @@ export class AcpBackend implements ChatBackend {
         }
         if (this.prompt?.cancelled) {
             this.emitAll(permission.events.filter((event) => event.type !== 'approval.requested'));
-            const answer = this.protocol.cancelPermissions().find((cancelled) => cancelled.requestId === permission.requestId);
+            const answer = this.protocol.cancelRequests().find((cancelled) => cancelled.requestId === permission.requestId);
             if (answer) {
                 transport.respond(answer.rpcId, answer.result);
             }
@@ -560,6 +592,19 @@ export class AcpBackend implements ChatBackend {
         this.emitAll(permission.events);
     }
 
+    /* Puts a question to the person, or turns it down at once when the turn is being cancelled. */
+    private ask(transport: JsonRpcTransport, question: AcpQuestion): void {
+        if (this.prompt?.cancelled) {
+            this.emitAll(question.events.filter((event) => event.type !== 'question.requested'));
+            const cancelled = this.protocol.cancelQuestion(question.requestId);
+            if (cancelled) {
+                transport.respond(cancelled.rpcId, cancelled.result);
+            }
+            return;
+        }
+        this.emitAll(question.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);
@@ -582,7 +627,7 @@ export class AcpBackend implements ChatBackend {
         }
         this.transport = null;
         this.prompt = null;
-        this.protocol.cancelPermissions();
+        this.protocol.cancelRequests();
         this.emit({ type: 'exit', exitCode, ...(stderr === null ? {} : { stderr }) });
     }