@armadra/agent 0.6.8 → 0.7.0

package/dist/cli/subcommands/auth.js

@@ -3,15 +3,19 @@
  * `ama auth login|logout|status chatgpt`（docs/wave6-plan.md §4.2）。[W6-O] 实现在 auth/chatgpt/cli.ts。
  *
  * - set：key 从 stdin 读取（TTY 下不回显），不经命令行参数，避免进 shell 历史；写 auth.json 0600。
+ *   [ACP-A] 不给 provider 且 stdin 是 TTY 时先用方向键选内置的需 key 供应商（ACP 终端登录方法
+ *   `ama auth set` 就这样跑）；非 TTY 仍是用法错误。
  * - list：只列供应商与 key 形态（字面量 / `!command` / `$ENV` 引用 / oauth 的 flavor 与计划），从不输出 key 或 token。
  * - `--auth-file <path>` 改变目标文件（缺省 `<configDir>/auth.json`）。
  */
 import { resolve } from "node:path";
+import { BUILTIN_PROVIDERS } from "../../ai/providers/builtin.js";
 import { runLogin, runLogout, runStatus } from "../../auth/chatgpt/cli.js";
 import { PROVIDER_ID_PATTERN, defaultAuthFilePath, describeAuthFile, readAuthFile, removeAuthKey, setAuthKey, } from "../../config/auth-file.js";
 import { resolveConfigDir } from "../../config/paths.js";
 import { msg } from "../../i18n/index.js";
 import { parseSubArgs, UsageError } from "../args.js";
+import { canPromptChoice, promptChoice } from "../choice-prompt.js";
 import { ExitCode } from "../exit-codes.js";
 /** 用法文本（按当前语言）。 */
 export function authUsage() {
@@ -43,6 +47,25 @@ function providerArg(positionals, action) {
         throw new UsageError(m.badProvider(provider));
     return provider;
 }
+/** `auth set` 选择器列的供应商：内置、需要 API key、有 key 环境变量（不含 OAuth 的 chatgpt）。 */
+export function keyProviders() {
+    return BUILTIN_PROVIDERS.filter((p) => p.requiresApiKey && (p.envKeys ?? []).length > 0).map((p) => ({ id: p.id, name: p.name }));
+}
+/** `auth set` 的 provider：给了就校验；没给且 stdin 是 TTY → 选择器（取消返回 undefined）。 */
+async function setProvider(positionals, io, deps) {
+    if (positionals.length > 1)
+        return providerArg(positionals, "set");
+    const m = msg().auth;
+    const choose = deps.chooseProvider ??
+        (canPromptChoice()
+            ? (question, options) => promptChoice({ question, options, env: io.env })
+            : undefined);
+    if (!io.stdinIsTTY || choose === undefined)
+        throw new UsageError(m.needProvider("set"));
+    const providers = keyProviders();
+    const index = await choose(m.pickProvider, providers.map((p) => ({ label: `${p.name} (${p.id})` })));
+    return index === undefined ? undefined : providers[index]?.id;
+}
 /** 取第一行并去掉首尾空白；stdin 为空返回 ""。 */
 export function extractKey(raw) {
     const line = raw.split(/\r?\n/).find((l) => l.trim() !== "") ?? "";
@@ -73,7 +96,11 @@ export async function runAuth(argv, io, deps = {}) {
         case "status":
             return runStatus(cli, io, deps);
         case "set": {
-            const provider = providerArg(positionals, "set");
+            const provider = await setProvider(positionals, io, deps);
+            if (provider === undefined) {
+                io.stderr(msg().subcommands.common.cancelled);
+                return ExitCode.Ok;
+            }
             if (io.stdinIsTTY)
                 io.stderr(m.setPrompt(provider));
             const key = extractKey(await io.readStdin());

package/dist/drivers/acp/client.d.ts

@@ -14,9 +14,12 @@
  *   没给时线路与旧版相同（不声明，Agent 发来的请求回 method not found）。`cancel(sessionId)`、连接关闭时
  *   挂起的 elicitation 一律回 `{ action: "cancel" }`；ama 从不替人填表。
  * - `setConfigOption(sessionId, configId, value)` 发 `session/set_config_option`；开会话答的 `configOptions`
- *   原样交回。
+ *   原样交回。`initialize` 声明 `clientCapabilities.session.configOptions: {}`（只认 select，不声明 boolean）；
+ *   不声明 `auth.terminal`（ama 作客户端没有可借给 Agent 的交互终端）。[ACP-D]
+ * - 线路两侧开 `$/cancel_request`：本端请求的 `signal` abort 时通知 Agent；Agent 撤回挂起的
+ *   `session/request_permission` / `elicitation/create` 时处理器的 `signal` abort，回 cancelled / cancel。[ACP-D]
  */
-import { type AcpAgentCapabilities, type AcpContentBlock, type AcpElicitationParams, type AcpElicitationResult, type AcpImplementationInfo, type AcpInitializeResult, type AcpListSessionsResult, type AcpLoadSessionResult, type AcpNewSessionResult, type AcpPromptResult, type AcpRequestPermissionParams, type AcpRequestPermissionResult, type AcpSessionNotification, type AcpSessionOptions, type AcpSetConfigOptionResult } from "./types.js";
+import { type AcpAgentCapabilities, type AcpAuthMethod, type AcpContentBlock, type AcpElicitationParams, type AcpElicitationResult, type AcpImplementationInfo, type AcpInitializeResult, type AcpListSessionsResult, type AcpLoadSessionResult, type AcpNewSessionResult, type AcpPromptResult, type AcpRequestPermissionParams, type AcpRequestPermissionResult, type AcpSessionNotification, type AcpSessionOptions, type AcpSetConfigOptionResult } from "./types.js";
 export interface AcpClientHandlers {
     onUpdate?(notification: AcpSessionNotification): void;
     /** `signal`：该会话被 cancel、连接关闭时 abort（此时应尽快回 cancelled）。 */
@@ -60,6 +63,8 @@ export declare class AcpClient {
     get isOpen(): boolean;
     get agentCapabilities(): AcpAgentCapabilities;
     get agentInfo(): AcpImplementationInfo | undefined;
+    /** `initialize` 答的认证方法（开会话回 -32000 时给人看）。 */
+    get authMethods(): readonly AcpAuthMethod[];
     initialize(signal?: AbortSignal): Promise<AcpInitializeResult>;
     supportsResume(): boolean;
     supportsLoad(): boolean;

package/dist/drivers/acp/client.js

@@ -14,7 +14,10 @@
  *   没给时线路与旧版相同（不声明，Agent 发来的请求回 method not found）。`cancel(sessionId)`、连接关闭时
  *   挂起的 elicitation 一律回 `{ action: "cancel" }`；ama 从不替人填表。
  * - `setConfigOption(sessionId, configId, value)` 发 `session/set_config_option`；开会话答的 `configOptions`
- *   原样交回。
+ *   原样交回。`initialize` 声明 `clientCapabilities.session.configOptions: {}`（只认 select，不声明 boolean）；
+ *   不声明 `auth.terminal`（ama 作客户端没有可借给 Agent 的交互终端）。[ACP-D]
+ * - 线路两侧开 `$/cancel_request`：本端请求的 `signal` abort 时通知 Agent；Agent 撤回挂起的
+ *   `session/request_permission` / `elicitation/create` 时处理器的 `signal` abort，回 cancelled / cancel。[ACP-D]
  */
 import { JsonRpcPeer, RpcError } from "../jsonrpc.js";
 import { ACP_METHODS, ACP_PROTOCOL_VERSION, RPC_ERRORS, } from "./types.js";
@@ -61,6 +64,7 @@ export class AcpClient {
         this.peer = new JsonRpcPeer({
             input: options.input,
             output: options.output,
+            cancelRequests: true,
             onRequest: (method, params, ctx) => this.onRequest(method, params, ctx.signal),
             onNotification: (method, params) => {
                 if (method === ACP_METHODS.sessionUpdate)
@@ -92,12 +96,17 @@ export class AcpClient {
     get agentInfo() {
         return this.initResult?.agentInfo;
     }
+    /** `initialize` 答的认证方法（开会话回 -32000 时给人看）。 */
+    get authMethods() {
+        return this.initResult?.authMethods ?? [];
+    }
     async initialize(signal) {
         const result = await this.peer.request(ACP_METHODS.initialize, {
             protocolVersion: ACP_PROTOCOL_VERSION,
             clientCapabilities: {
                 fs: { readTextFile: false, writeTextFile: false },
                 terminal: false,
+                session: { configOptions: {} },
                 ...(this.options.onElicitation !== undefined ? { elicitation: {} } : {}),
             },
             ...(this.options.clientInfo !== undefined ? { clientInfo: this.options.clientInfo } : {}),

package/dist/drivers/acp/driver.d.ts

@@ -4,22 +4,33 @@
  * open：起进程 → `initialize` → 续聊优先 `session/resume`（不回放），其次 `session/load`
  * （回放的历史通知在 open 期间丢弃），都不支持则新开并发 notice「已新开」→ 按 ama 模式
  * `session/set_mode`（只读模式没有映射时拒绝启动，避免以 Agent 缺省模式跑写操作）。
- * prompt：`session/update` → DriverEvent；`session/request_permission` → hooks.onPermission
- * （只交给人）；回合以 `session/prompt` 的 stopReason 结束。
- * cancel：`session/cancel`，挂起的权限请求回 cancelled，15 s 内无回合结束 → 关 stdin → 杀进程树。
+ * Agent 不给 `modes` 时退到 `configOptions` 里 category `mode` 的选择项，经 `session/set_config_option` 设置；
+ * 开会话回 -32000（需要登录）时报 `agent_auth_required`，文案列出 Agent 的认证方法（terminal 型附命令）。
+ * prompt：`session/update` → DriverEvent（diff 内容的路径计入 filesTouched）；`session/request_permission`
+ * → hooks.onPermission（只交给人；Agent 以 `$/cancel_request` 撤回时 signal abort）；回合以
+ * `session/prompt` 的 stopReason 结束。
+ * cancel：`session/cancel`，挂起的权限请求回 cancelled，15 s 内无回合结束 → 关 stdin → 杀进程树；
+ * 取消后 `session/prompt` 回 -32800（请求被撤回）也当作 cancelled。
  */
+import { AmaError } from "../../errors.js";
 import type { ContentBlock } from "../../ai/types.js";
 import type { PermissionMode } from "../../permissions/types.js";
 import { type DriverDeps } from "../base.js";
 import type { CatalogCandidate } from "../catalog.js";
 import { TurnCollector } from "../turn.js";
 import type { AgentDriver, DriverOpenOptions, DriverProbe, DriverSession } from "../types.js";
-import type { AcpContentBlock, AcpSessionModeState, AcpSessionUpdate } from "./types.js";
+import { type AcpAuthMethod, type AcpContentBlock, type AcpSessionConfigOption, type AcpSessionModeState, type AcpSessionUpdate } from "./types.js";
 export declare function toAcpContent(blocks: readonly ContentBlock[], images: boolean): AcpContentBlock[];
 /** session/update → DriverEvent（用户消息回放、命令表等忽略）。 */
 export declare function pushAcpUpdate(update: AcpSessionUpdate, turn: TurnCollector): void;
 /** ama 模式 → 该 Agent 的模式 id（显式映射 > 同名）。 */
 export declare function pickModeId(mode: PermissionMode, candidate: CatalogCandidate, state: AcpSessionModeState | null | undefined): string | undefined;
+/** `configOptions` 里 category `mode` 的选择项（没有 `modes` 的 Agent 用它表达模式）。 */
+export declare function modeConfigOption(options: readonly AcpSessionConfigOption[] | null | undefined): AcpSessionConfigOption | undefined;
+/** 与 {@link pickModeId} 同一映射，在 mode 类配置项的可选值里找（分组的展开）。 */
+export declare function pickConfigModeValue(mode: PermissionMode, candidate: CatalogCandidate, option: AcpSessionConfigOption | undefined): string | undefined;
+/** 开会话回 -32000 → `agent_auth_required`，列出 `initialize` 给的认证方法。 */
+export declare function authRequiredError(agentId: string, methods: readonly AcpAuthMethod[], command: readonly string[], cause: unknown): AmaError;
 export declare class AcpDriver implements AgentDriver {
     readonly agentId: string;
     private readonly candidate;

package/dist/drivers/acp/driver.js

@@ -4,15 +4,21 @@
  * open：起进程 → `initialize` → 续聊优先 `session/resume`（不回放），其次 `session/load`
  * （回放的历史通知在 open 期间丢弃），都不支持则新开并发 notice「已新开」→ 按 ama 模式
  * `session/set_mode`（只读模式没有映射时拒绝启动，避免以 Agent 缺省模式跑写操作）。
- * prompt：`session/update` → DriverEvent；`session/request_permission` → hooks.onPermission
- * （只交给人）；回合以 `session/prompt` 的 stopReason 结束。
- * cancel：`session/cancel`，挂起的权限请求回 cancelled，15 s 内无回合结束 → 关 stdin → 杀进程树。
+ * Agent 不给 `modes` 时退到 `configOptions` 里 category `mode` 的选择项，经 `session/set_config_option` 设置；
+ * 开会话回 -32000（需要登录）时报 `agent_auth_required`，文案列出 Agent 的认证方法（terminal 型附命令）。
+ * prompt：`session/update` → DriverEvent（diff 内容的路径计入 filesTouched）；`session/request_permission`
+ * → hooks.onPermission（只交给人；Agent 以 `$/cancel_request` 撤回时 signal abort）；回合以
+ * `session/prompt` 的 stopReason 结束。
+ * cancel：`session/cancel`，挂起的权限请求回 cancelled，15 s 内无回合结束 → 关 stdin → 杀进程树；
+ * 取消后 `session/prompt` 回 -32800（请求被撤回）也当作 cancelled。
  */
 import { AmaError } from "../../errors.js";
 import { armCancelWatchdog, isReadOnlyMode, probeCandidate, spawnOf, } from "../base.js";
 import { stderrHint } from "../process.js";
 import { TurnCollector, oneLine } from "../turn.js";
+import { RpcError } from "../jsonrpc.js";
 import { AcpClient } from "./client.js";
+import { RPC_ERRORS, } from "./types.js";
 import { AMA_VERSION } from "../../version.js";
 import { msg } from "../../i18n/index.js";
 export function toAcpContent(blocks, images) {
@@ -28,6 +34,14 @@ export function toAcpContent(blocks, images) {
 function locationsOf(locations) {
     return locations === undefined ? undefined : locations.map((l) => l.path);
 }
+/** 工具内容里 diff 的路径。 */
+function diffPathsOf(content) {
+    const paths = [];
+    for (const item of content ?? [])
+        if (item.type === "diff" && typeof item.path === "string" && !paths.includes(item.path))
+            paths.push(item.path);
+    return paths;
+}
 /** session/update → DriverEvent（用户消息回放、命令表等忽略）。 */
 export function pushAcpUpdate(update, turn) {
     switch (update.sessionUpdate) {
@@ -42,7 +56,11 @@ export function pushAcpUpdate(update, turn) {
         case "tool_call":
         case "tool_call_update": {
             const known = turn.tool(update.toolCallId);
-            const locations = locationsOf(update.locations);
+            const diffs = diffPathsOf(update.content);
+            let locations = locationsOf(update.locations);
+            // diff 的路径并入 locations（没给 locations 时并入已知的）
+            if (diffs.length > 0)
+                locations = [...new Set([...(locations ?? known?.locations ?? []), ...diffs])];
             turn.push({
                 type: "tool_call",
                 id: update.toolCallId,
@@ -51,6 +69,7 @@ export function pushAcpUpdate(update, turn) {
                 status: update.status ?? known?.status ?? "pending",
                 ...(locations !== undefined ? { locations } : {}),
             });
+            turn.noteDiff(update.toolCallId, diffs);
             return;
         }
         case "plan":
@@ -71,13 +90,43 @@ export function pushAcpUpdate(update, turn) {
             return;
     }
 }
-/** ama 模式 → 该 Agent 的模式 id（显式映射 > 同名）。 */
-export function pickModeId(mode, candidate, state) {
+/** ama 模式在 Agent 那边想要的模式 id，按优先级（显式映射 > 同名）。 */
+function wantedModeIds(mode, candidate) {
     const wanted = [candidate.modes?.[mode] ?? mode];
     // allowlist 在外部 Agent 那边没有等价物：退到只读的 plan
     if (mode === "allowlist")
         wanted.push(candidate.modes?.plan ?? "plan");
-    return wanted.find((id) => state?.availableModes.some((m) => m.id === id) === true);
+    return wanted;
+}
+/** ama 模式 → 该 Agent 的模式 id（显式映射 > 同名）。 */
+export function pickModeId(mode, candidate, state) {
+    return wantedModeIds(mode, candidate).find((id) => state?.availableModes.some((m) => m.id === id) === true);
+}
+/** `configOptions` 里 category `mode` 的选择项（没有 `modes` 的 Agent 用它表达模式）。 */
+export function modeConfigOption(options) {
+    return options?.find((o) => o.category === "mode" && o.type === "select");
+}
+/** 与 {@link pickModeId} 同一映射，在 mode 类配置项的可选值里找（分组的展开）。 */
+export function pickConfigModeValue(mode, candidate, option) {
+    if (option === undefined)
+        return undefined;
+    const values = option.options.flatMap((o) => "options" in o ? o.options.map((x) => x.value) : [o.value]);
+    return wantedModeIds(mode, candidate).find((id) => values.includes(id));
+}
+/** 一条认证方法给人看的样子：terminal 型附上要在终端里跑的命令。 */
+function authMethodText(method, command) {
+    if (method.type !== "terminal")
+        return method.name;
+    const words = [...command, ...(method.args ?? [])].map((w) => /[\s"']/.test(w) ? JSON.stringify(w) : w);
+    return msg().acp.client.authTerminal(method.name, words.join(" "));
+}
+/** 开会话回 -32000 → `agent_auth_required`，列出 `initialize` 给的认证方法。 */
+export function authRequiredError(agentId, methods, command, cause) {
+    const m = msg().acp.client;
+    const text = methods.length === 0
+        ? m.authNoMethods(agentId)
+        : m.authRequired(agentId, methods.map((method) => authMethodText(method, command)));
+    return new AmaError("agent_auth_required", text, { cause });
 }
 export class AcpDriver {
     agentId;
@@ -104,8 +153,9 @@ export class AcpDriver {
             env: options.env,
         });
         const session = new AcpDriverSession(this.agentId, transport, this.deps);
+        const command = [probed.path ?? this.candidate.program, ...this.candidate.args];
         try {
-            await session.start(options, this.candidate);
+            await session.start(options, this.candidate, command);
         }
         catch (error) {
             await session.close();
@@ -129,6 +179,8 @@ class AcpDriverSession {
     running;
     closed = false;
     notices = [];
+    /** 本回合已发过 cancel。 */
+    cancelling = false;
     constructor(agentId, transport, deps) {
         this.agentId = agentId;
         this.transport = transport;
@@ -137,7 +189,8 @@ class AcpDriverSession {
     get sessionId() {
         return this.id;
     }
-    async start(options, candidate) {
+    /** `command`：启动 Agent 的程序与参数（terminal 型认证方法的提示用）。 */
+    async start(options, candidate, command) {
         this.client = new AcpClient({
             input: this.transport.stdout,
             output: this.transport.stdin,
@@ -148,43 +201,60 @@ class AcpDriverSession {
         });
         const signal = options.signal;
         await this.client.initialize(signal);
-        let modes;
-        if (options.resume !== undefined) {
-            if (this.client.supportsResume()) {
-                modes = (await this.client.resumeSession(options.resume, options.cwd, signal)).modes;
-                this.id = options.resume;
-            }
-            else if (this.client.supportsLoad()) {
-                this.replaying = true;
-                try {
-                    modes = (await this.client.loadSession(options.resume, options.cwd, signal)).modes;
-                }
-                finally {
-                    this.replaying = false;
-                }
-                this.id = options.resume;
-            }
-            else {
-                this.notices.push(msg().drivers.agent.resumeUnsupported(this.agentId));
-            }
+        let opened;
+        try {
+            opened = await this.openSession(options);
         }
-        if (this.id === "") {
-            const created = await this.client.newSession(options.cwd, signal);
-            this.id = created.sessionId;
-            modes = created.modes;
+        catch (error) {
+            if (error instanceof RpcError && error.code === RPC_ERRORS.authRequired)
+                throw authRequiredError(this.agentId, this.client.authMethods, command, error);
+            throw error;
         }
+        const modes = opened.modes;
         const modeId = pickModeId(options.mode, candidate, modes);
+        const modeOption = modeId === undefined ? modeConfigOption(opened.configOptions) : undefined;
+        const configMode = pickConfigModeValue(options.mode, candidate, modeOption);
         if (modeId !== undefined) {
             if (modes?.currentModeId !== modeId)
                 await this.client.setMode(this.id, modeId);
         }
+        else if (modeOption !== undefined && configMode !== undefined) {
+            if (modeOption.currentValue !== configMode)
+                await this.client.setConfigOption(this.id, modeOption.id, configMode);
+        }
         else if (isReadOnlyMode(options.mode)) {
             throw new AmaError("agent_mode_unsupported", `${this.agentId} has no read-only mode matching ama's "${options.mode}"; its default mode cannot stand in for it`);
         }
-        else if (modes != null) {
+        else if (modes != null || modeOption !== undefined) {
             this.notices.push(msg().drivers.agent.noMatchingMode(this.agentId, options.mode));
         }
     }
+    /** 续聊优先 resume（不回放），其次 load（回放丢弃），都不行就新开；设好 `this.id`。 */
+    async openSession(options) {
+        const signal = options.signal;
+        if (options.resume !== undefined) {
+            if (this.client.supportsResume()) {
+                const resumed = await this.client.resumeSession(options.resume, options.cwd, signal);
+                this.id = options.resume;
+                return resumed;
+            }
+            if (this.client.supportsLoad()) {
+                this.replaying = true;
+                try {
+                    const loaded = await this.client.loadSession(options.resume, options.cwd, signal);
+                    this.id = options.resume;
+                    return loaded;
+                }
+                finally {
+                    this.replaying = false;
+                }
+            }
+            this.notices.push(msg().drivers.agent.resumeUnsupported(this.agentId));
+        }
+        const created = await this.client.newSession(options.cwd, signal);
+        this.id = created.sessionId;
+        return created;
+    }
     async prompt(content, hooks) {
         if (this.closed)
             throw new AmaError("agent_closed", `${this.agentId} session is closed`);
@@ -195,6 +265,7 @@ class AcpDriverSession {
             turn.push({ type: "notice", level: "info", text });
         this.hooks = hooks;
         this.turn = turn;
+        this.cancelling = false;
         const images = this.client.supportsImages();
         if (!images && content.some((b) => b.type === "image"))
             turn.push({
@@ -206,6 +277,11 @@ class AcpDriverSession {
         this.running = request;
         try {
             const result = await request.catch((error) => {
+                // 取消后 Agent 以 -32800（请求被撤回）答 session/prompt：与 stopReason cancelled 同义
+                if (this.cancelling &&
+                    error instanceof RpcError &&
+                    error.code === RPC_ERRORS.requestCancelled)
+                    return { stopReason: "cancelled" };
                 if (this.client.isOpen)
                     throw error;
                 const hint = stderrHint(this.transport);
@@ -233,6 +309,7 @@ class AcpDriverSession {
         const running = this.running;
         if (running === undefined || this.closed)
             return;
+        this.cancelling = true;
         await this.client.cancel(this.id).catch(() => undefined);
         armCancelWatchdog(this.transport, running.catch(() => undefined), this.deps);
     }

package/dist/drivers/acp/testing/fake-agent-main.d.ts

@@ -1,5 +1,5 @@
 /**
- * 假 ACP Agent 的进程入口：`node dist/drivers/acp/testing/fake-agent-main.js [--minimal] [--config-options]`。[W5-E]
+ * 假 ACP Agent 的进程入口：`node dist/drivers/acp/testing/fake-agent-main.js [--minimal] [--config-options] [--config-only] [--auth-required]`。[W5-E]
  * 行为见 fake-agent.ts；stdin 结束即退出。
  */
 export {};

package/dist/drivers/acp/testing/fake-agent-main.js

@@ -1,8 +1,15 @@
 /**
- * 假 ACP Agent 的进程入口：`node dist/drivers/acp/testing/fake-agent-main.js [--minimal] [--config-options]`。[W5-E]
+ * 假 ACP Agent 的进程入口：`node dist/drivers/acp/testing/fake-agent-main.js [--minimal] [--config-options] [--config-only] [--auth-required]`。[W5-E]
  * 行为见 fake-agent.ts；stdin 结束即退出。
  */
 import { runFakeAcpAgent } from "./fake-agent.js";
 const minimal = process.argv.includes("--minimal");
 const configOptions = process.argv.includes("--config-options");
-void runFakeAcpAgent(process.stdin, process.stdout, { minimal, configOptions }).then(() => process.exit(0));
+const configOnly = process.argv.includes("--config-only");
+const authRequired = process.argv.includes("--auth-required");
+void runFakeAcpAgent(process.stdin, process.stdout, {
+    minimal,
+    configOptions,
+    configOnly,
+    authRequired,
+}).then(() => process.exit(0));

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

@@ -17,13 +17,20 @@
  * |                  | 没声明 `elicitation` 能力时回 `elicit: unsupported`；`cancel` 时本回合 `cancelled` |
  * | `[model]`        | 回 `model <当前模型>`（`configOptions` 关着时是 `model none`）                     |
  * | `[env NAME]`     | 回 `env NAME <值的 sha256 | absent>`（测环境变量到没到，不回显值）                  |
+ * | `[cancel-request]` | 同 `[permission]` 发权限请求，挂起 `cancelRequestMs`（缺省 2 s）后自己发            |
+ * |                  | `$/cancel_request` 撤回；`tool_call_update` failed，回 `permission withdrawn`、`end_turn` |
  *
- * `configOptions: true`（可执行入口 `--config-options`）：开会话答一个 `model` 配置项（`small`，分组
- * `big` 里有 `large`），`session/set_config_option` 可改；缺省不答，线路与之前相同。
+ * `configOptions: true`（可执行入口 `--config-options`）：开会话答一个 `model` 配置项（分组 `fast` 里有
+ * `small`、`big` 里有 `large`，当前 `small`），`session/set_config_option` 可改；缺省不答，线路与之前相同。
+ * `configOnly: true`（`--config-only`）：开会话不答 `modes`，改在 `configOptions` 里给 category `mode` 的
+ * 选择项（id `mode`），经 `session/set_config_option` 切换；可与 `configOptions` 同开（两项都给）。
+ * `authRequired: true`（`--auth-required`）：`initialize` 给一条 terminal 型认证方法，开会话
+ * （new / load / resume）一律回 -32000。
  *
  * 会话：`session/new` 发 `fake-<n>`；`session/resume` / `session/load` 接受任何 `fake-` 开头的 id
  * （load 先回放一条用户消息与一条回复）；`session/list` 列本进程建过的会话。
  */
+import { type AcpAuthMethod } from "../types.js";
 export interface FakeAcpAgentOptions {
     /** `initialize` 回的 agentInfo.name，缺省 `fake-acp-agent`。 */
     name?: string;
@@ -31,6 +38,14 @@ export interface FakeAcpAgentOptions {
     minimal?: boolean;
     /** 开会话答 `configOptions`（一个 `model` 选择项）并接 `session/set_config_option`。 */
     configOptions?: boolean;
+    /** 不答 `modes`，模式改由 `configOptions` 里 category `mode` 的选择项给出。 */
+    configOnly?: boolean;
+    /** `initialize` 给 terminal 型认证方法，开会话回 -32000。 */
+    authRequired?: boolean;
+    /** `[cancel-request]` 撤回权限请求前等多久（毫秒，缺省 2000）。 */
+    cancelRequestMs?: number;
 }
+/** `authRequired` 时 `initialize` 给的认证方法。 */
+export declare const FAKE_AUTH_METHOD: AcpAuthMethod;
 /** 在给定流上跑假 Agent；输入流结束时 resolve。 */
 export declare function runFakeAcpAgent(input: NodeJS.ReadableStream, output: NodeJS.WritableStream, options?: FakeAcpAgentOptions): Promise<void>;