@agentclientprotocol/claude-agent-acp 0.85.2-preview.9 → 0.86.1-preview.1

package/dist/tool-calls/renderer.js

@@ -118,8 +118,9 @@ export class AcpToolCallRenderer {
     permissionToolCall(toolUse, options = {}) {
         const facts = this.facts(toolUse, options.cwd);
         if (!this.capabilities.air.client) {
-            // The upstream shape: the whole tool call again.
-            const content = this.toolUseContent(toolUse.id, facts);
+            // The upstream shape: the whole tool call again. A v2 client also gets
+            // the exact preview patch, which the tool call does not show.
+            const content = options.previewContent ?? this.toolUseContent(toolUse.id, facts);
             const locations = [...(facts.locations ?? []), ...(options.extraLocations ?? [])];
             return {
                 toolCallId: toolUse.id,
@@ -191,7 +192,17 @@ export class AcpToolCallRenderer {
                     ...(this.capabilities.terminalOutputDelta
                         ? { terminal_output_delta: output }
                         : { terminal_output: output }),
-                    terminal_exit: { terminal_id: terminalId, exit_code: command.exitCode, signal: null },
+                    terminal_exit: {
+                        terminal_id: terminalId,
+                        // AIR keeps the numbers it always got: 1 for a failed or
+                        // interrupted command, else the exit code, or 0 when unknown.
+                        exit_code: this.capabilities.air.client
+                            ? result.is_error === true || command.interrupted
+                                ? 1
+                                : (command.exitCode ?? 0)
+                            : (command.exitCode ?? null),
+                        signal: null,
+                    },
                 },
             };
         }

package/dist/tool-calls/reporters/bash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../../src/tool-calls/reporters/bash.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAElG,gFAAgF;AAChF,qBAAa,YAAa,YAAW,YAAY;IAC/C,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY;IAUrC,iFAAiF;IACjF,WAAW,CAAC,OAAO,EAAE,iBAAiB,GAAG,eAAe,GAAG,SAAS;IAIpE,UAAU,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,EAAE,iBAAiB,GAAG,eAAe;CAuEvE"}
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../../src/tool-calls/reporters/bash.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAElG,gFAAgF;AAChF,qBAAa,YAAa,YAAW,YAAY;IAC/C,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY;IAUrC,iFAAiF;IACjF,WAAW,CAAC,OAAO,EAAE,iBAAiB,GAAG,eAAe,GAAG,SAAS;IAIpE,UAAU,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,EAAE,iBAAiB,GAAG,eAAe;CAsFvE"}

package/dist/tool-calls/reporters/bash.js

@@ -30,7 +30,11 @@ export class BashReporter {
         // 4. Array content: text blocks for stdout, or image blocks when the
         //    command produces an image.
         let output = "";
-        let exitCode = isError ? 1 : 0;
+        // Claude Code accepts a non-zero code as a success only with a
+        // `returnCodeInterpretation` (grep's "No matches found"), so a success
+        // without one exited with 0.
+        let exitCode = isError ? undefined : 0;
+        let interrupted = false;
         const structuredBash = structuredResult(structured);
         if (structuredBash &&
             typeof structuredBash.stdout === "string" &&
@@ -38,12 +42,15 @@ export class BashReporter {
             !structuredBash.isImage &&
             structuredBash.backgroundTaskId === undefined) {
             output = [structuredBash.stdout, structuredBash.stderr].filter(Boolean).join("\n");
-            // The CLI appends its abort marker only to the model-facing text, and an
-            // aborted command is not a success.
+            // The CLI appends its abort marker only to the model-facing text. The
+            // result does not carry the code of the aborted command.
             if (structuredBash.interrupted) {
                 output = [output, "[Command was aborted before completion]"].filter(Boolean).join("\n");
-                exitCode = 1;
+                exitCode = undefined;
+                interrupted = true;
             }
+            if (structuredBash.returnCodeInterpretation !== undefined)
+                exitCode = undefined;
             // Structured stdout is clipped when the full output was persisted to
             // disk. Without this note the clip is silent.
             if (typeof structuredBash.persistedOutputPath === "string") {
@@ -78,6 +85,26 @@ export class BashReporter {
             }
             output = content.map((c) => c.text).join("\n");
         }
-        return { command: { output, exitCode } };
+        if (isError && exitCode === undefined)
+            exitCode = failureExitCode(output);
+        // A backgrounded command is still running: the result only announces it.
+        if (structuredBash?.backgroundTaskId !== undefined)
+            exitCode = undefined;
+        return {
+            command: {
+                output,
+                ...(exitCode !== undefined ? { exitCode } : {}),
+                ...(interrupted ? { interrupted } : {}),
+            },
+        };
     }
 }
+/**
+ * The exit code that the text of a failed command names. Claude Code starts the
+ * text of a command that exited with a failing code with `Exit code N`. Other
+ * failures, such as a denial or a command that could not start, name none.
+ */
+function failureExitCode(text) {
+    const match = /^Exit code (\d+)(?:\n|$)/.exec(text);
+    return match ? Number(match[1]) : undefined;
+}

package/dist/tool-calls/reporters/file-edit.d.ts

@@ -22,7 +22,7 @@ type NormalizedWriteInput = Partial<FileWriteInput> & {
 export declare function normalizeWriteInput(input: unknown): NormalizedWriteInput | undefined;
 /** Edit: the diff holds the old and the new text. */
 export declare class EditReporter implements ToolReporter {
-    toolUse(input: unknown, { cwd }: ToolUseContext): ToolUseFacts;
+    toolUse(input: unknown, { cwd, capabilities }: ToolUseContext): ToolUseFacts;
     toolResult(): ToolResultFacts;
     hookResult(toolResponse: unknown, context: ToolUseContext): Promise<ToolResultFacts>;
 }

package/dist/tool-calls/reporters/file-edit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-edit.d.ts","sourceRoot":"","sources":["../../../src/tool-calls/reporters/file-edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,cAAc,EAEf,MAAM,6CAA6C,CAAC;AAIrD,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,YAAY,EACb,MAAM,aAAa,CAAC;AAErB;;;GAGG;AACH,qBAAa,aAAc,YAAW,YAAY;IAChD,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,EAAE,cAAc,GAAG,YAAY;IAiCpF,UAAU,IAAI,eAAe;IAI7B,UAAU,CAAC,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;CAGrF;AAED,yFAAyF;AACzF,KAAK,oBAAoB,GAAG,OAAO,CAAC,cAAc,CAAC,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAI9E;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,GAAG,SAAS,CAYpF;AAED,qDAAqD;AACrD,qBAAa,YAAa,YAAW,YAAY;IAC/C,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,EAAE,cAAc,GAAG,YAAY;IAyB9D,UAAU,IAAI,eAAe;IAI7B,UAAU,CAAC,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;CAGrF;AAwCD;;;;;;;GAOG;AACH,qBAAa,oBAAqB,YAAW,YAAY;IACvD,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE,EAAE,cAAc,GAAG,YAAY;IAsB5E;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,eAAe;CAMxD"}
+{"version":3,"file":"file-edit.d.ts","sourceRoot":"","sources":["../../../src/tool-calls/reporters/file-edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,cAAc,EAEf,MAAM,6CAA6C,CAAC;AAQrD,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,YAAY,EACb,MAAM,aAAa,CAAC;AAErB;;;GAGG;AACH,qBAAa,aAAc,YAAW,YAAY;IAChD,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,EAAE,cAAc,GAAG,YAAY;IAoCpF,UAAU,IAAI,eAAe;IAI7B,UAAU,CAAC,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;CAGrF;AAED,yFAAyF;AACzF,KAAK,oBAAoB,GAAG,OAAO,CAAC,cAAc,CAAC,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAI9E;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,GAAG,SAAS,CAYpF;AAED,qDAAqD;AACrD,qBAAa,YAAa,YAAW,YAAY;IAC/C,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE,EAAE,cAAc,GAAG,YAAY;IA0B5E,UAAU,IAAI,eAAe;IAI7B,UAAU,CAAC,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;CAGrF;AAyCD;;;;;;;GAOG;AACH,qBAAa,oBAAqB,YAAW,YAAY;IACvD,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE,EAAE,cAAc,GAAG,YAAY;IAsB5E;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,eAAe;CAMxD"}

package/dist/tool-calls/reporters/file-edit.js

@@ -1,4 +1,4 @@
-import { patchUpdateFromDiffToolResponse, toolUpdateFromDiffToolResponse } from "../../diff.js";
+import { patchUpdateFromDiffToolResponse, toolUpdateFromDiffToolResponse, v2UpdateFromDiffToolResponse, } from "../../diff.js";
 import { markdownEscape, resultText, textContent, toDisplayPath } from "../content.js";
 /**
  * Write: the diff holds the file text. The PostToolUse hook sends the final
@@ -14,12 +14,15 @@ export class WriteReporter {
             locations: write?.file_path ? [{ path: write.file_path }] : [],
         };
         if (write?.file_path) {
-            // A negotiated client gets the exact patch from the approval preview or
-            // from the PostToolUse hook. The input does not tell whether the file
-            // exists, so the live tool call shows no diff: a diff without the old
-            // text would claim a creation. The adapter reads the file only for the
-            // preview. A replay has no preview and no hook, so it keeps the diff.
-            if (!capabilities.diffPatch || replay) {
+            // A negotiated client and a v2 client get the exact patch from the
+            // approval preview or from the PostToolUse hook. The input does not tell
+            // whether the file exists, so the live tool call shows no diff: a diff
+            // without the old text would claim a creation. The adapter reads the
+            // file only for the preview. A replay has no preview and no hook, so it
+            // keeps the diff, except for a v2 client: a v2 diff names the operation,
+            // which the input does not tell.
+            const inputDiff = capabilities.v2 ? false : !capabilities.diffPatch || replay;
+            if (inputDiff) {
                 facts.change = [
                     {
                         type: "diff",
@@ -68,7 +71,7 @@ export function normalizeWriteInput(input) {
 }
 /** Edit: the diff holds the old and the new text. */
 export class EditReporter {
-    toolUse(input, { cwd }) {
+    toolUse(input, { cwd, capabilities }) {
         const edit = input;
         const displayPath = edit?.file_path ? toDisplayPath(edit.file_path, cwd) : undefined;
         const facts = {
@@ -76,10 +79,11 @@ export class EditReporter {
             kind: "edit",
             locations: edit?.file_path ? [{ path: edit.file_path }] : [],
         };
-        if (edit?.file_path && (edit.old_string || edit.new_string)) {
-            // The standard diff, also for a client that negotiated patches: the
-            // input holds a snippet, not the file, so a patch would need line
-            // numbers that the adapter does not know here.
+        // The standard diff, also for a client that negotiated patches: the input
+        // holds a snippet, not the file, so a patch would need line numbers that
+        // the adapter does not know here. A v2 diff cannot hold a snippet, so a v2
+        // client gets the patch from the PostToolUse hook alone.
+        if (edit?.file_path && (edit.old_string || edit.new_string) && !capabilities.v2) {
             facts.change = [
                 {
                     type: "diff",
@@ -104,12 +108,14 @@ export class EditReporter {
  * PostToolUse `tool_response`. For Write it replaces the optimistic creation
  * diff with the real diff of an updated file. A negotiated client gets an
  * exact git patch built from the written file, or the standard diff when none
- * can be built.
+ * can be built. A v2 client gets a v2 diff.
  */
 async function finalChange(toolResponse, { capabilities }) {
+    if (capabilities.v2)
+        return v2UpdateFromDiffToolResponse(toolResponse);
     if (!capabilities.diffPatch)
         return toolUpdateFromDiffToolResponse(toolResponse);
-    const patch = await patchUpdateFromDiffToolResponse(toolResponse);
+    const patch = await patchUpdateFromDiffToolResponse(toolResponse, "air");
     if (patch)
         return patch;
     const created = createdFileDiff(toolResponse);

package/dist/v2/agent.d.ts

@@ -6,6 +6,8 @@ import { ClaudeAcpAgent, type Logger } from "../acp-agent.js";
  * As in `v1AgentApp`, the agent of the connection is created when the
  * connection opens, before the connection processes any inbound message.
  * `onAgent` receives it for the owner of the process (shutdown).
+ *
+ * The provider methods pass through: their types are the same in v1 and v2.
  */
 export declare function v2AgentApp(logger: Logger | undefined, onAgent: (agent: ClaudeAcpAgent) => void): v2.AgentApp;
 //# sourceMappingURL=agent.d.ts.map

package/dist/v2/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/v2/agent.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAkB,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAc9E;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GACvC,EAAE,CAAC,QAAQ,CAoCb"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/v2/agent.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAkB,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAkB9E;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GACvC,EAAE,CAAC,QAAQ,CA4Db"}

package/dist/v2/agent.js

@@ -1,15 +1,19 @@
 import * as v2 from "@agentclientprotocol/sdk/experimental/v2";
 import { ClaudeAcpAgent } from "../acp-agent.js";
 import { v1InitializeRequest, v2InitializeResponse } from "./initialize.js";
+import { v1PermissionResponse, v2PermissionRequest } from "./permission.js";
 import { v2Prompt } from "./prompt.js";
-import { v1NewSessionRequest, v1ResumeSessionRequest, v1SetSessionConfigOptionRequest, v2ConfigOptions, v2NewSessionResponse, v2ResumeSessionResponse, } from "./session.js";
+import { v1ForkSessionRequests, v1NewSessionRequest, v1RestoreSessionRequest, v1SetSessionConfigOptionRequest, v2ConfigOptions, v2NewSessionResponse, v2ResumeSessionResponse, } from "./session.js";
 import { v2SessionUpdate } from "./session-update.js";
+import { V2Terminals } from "./terminal.js";
 /**
  * The ACP v2 surface, for one connection.
  *
  * As in `v1AgentApp`, the agent of the connection is created when the
  * connection opens, before the connection processes any inbound message.
  * `onAgent` receives it for the owner of the process (shutdown).
+ *
+ * The provider methods pass through: their types are the same in v1 and v2.
  */
 export function v2AgentApp(logger, onAgent) {
     let agent;
@@ -18,16 +22,36 @@ export function v2AgentApp(logger, onAgent) {
         .agent({ name: "claude-code-acp" })
         .onConnect((connection) => {
         client = new V2ClientConnection(connection.client, logger ?? console);
-        agent = new ClaudeAcpAgent(client, logger);
+        agent = new ClaudeAcpAgent(client, logger, { v2: true });
         onAgent(agent);
     })
         .onRequest(v2.methods.agent.initialize, async ({ params }) => v2InitializeResponse(await agent.initialize(v1InitializeRequest(params))))
         .onRequest(v2.methods.agent.auth.login, ({ params }) => agent.authenticate(params))
         .onRequest(v2.methods.agent.auth.logout, ({ params }) => agent.logout(params))
+        .onRequest(v2.methods.agent.providers.list, ({ params }) => agent.unstable_listProviders(params))
+        .onRequest(v2.methods.agent.providers.set, ({ params }) => agent.unstable_setProvider(params))
+        .onRequest(v2.methods.agent.providers.disable, ({ params }) => agent.unstable_disableProvider(params))
         .onRequest(v2.methods.agent.session.new, async ({ params }) => v2NewSessionResponse(await agent.newSession(v1NewSessionRequest(params))))
         .onRequest(v2.methods.agent.session.list, ({ params }) => agent.listSessions(params))
-        .onRequest(v2.methods.agent.session.resume, async ({ params }) => v2ResumeSessionResponse(await agent.resumeSession(v1ResumeSessionRequest(params))))
-        .onRequest(v2.methods.agent.session.close, ({ params }) => agent.closeSession(params))
+        .onRequest(v2.methods.agent.session.resume, async ({ params }) => {
+        const restore = v1RestoreSessionRequest(params);
+        return v2ResumeSessionResponse(restore.method === "resume"
+            ? await agent.resumeSession(restore.request)
+            : await client.replaying(params.sessionId, () => agent.loadSession(restore.request)));
+    })
+        .onRequest(v2.methods.agent.session.fork, async ({ params }) => {
+        const requests = v1ForkSessionRequests(params);
+        const { sessionId } = await agent.unstable_forkSession(requests.fork);
+        return {
+            sessionId,
+            ...v2ResumeSessionResponse(await agent.resumeSession(requests.resume(sessionId))),
+        };
+    })
+        .onRequest(v2.methods.agent.session.close, async ({ params }) => {
+        const response = await agent.closeSession(params);
+        client.terminals.forget(params.sessionId);
+        return response;
+    })
         .onRequest(v2.methods.agent.session.delete, ({ params }) => agent.deleteSession(params))
         .onRequest(v2.methods.agent.session.setConfigOption, async ({ params }) => {
         const { configOptions, ...response } = await agent.setSessionConfigOption(v1SetSessionConfigOptionRequest(params));
@@ -41,16 +65,38 @@ export function v2AgentApp(logger, onAgent) {
 /**
  * The {@link AcpClient} of an ACP v2 connection: it sends the v1 messages of
  * the agent as v2 messages.
- *
- * Permission requests still reject until the v2 surface translates them.
  */
 class V2ClientConnection {
     ctx;
     logger;
+    /**
+     * The sessions whose history replays, each with the messages that the
+     * replay has cleared so far.
+     */
+    replays = new Map();
+    /** The display terminals of the commands that the agent runs. */
+    terminals = new V2Terminals();
     constructor(ctx, logger) {
         this.ctx = ctx;
         this.logger = logger;
     }
+    /**
+     * Runs `restore`, which replays the history of `sessionId`.
+     *
+     * The agent replays messages as chunks. A v2 client may still hold a
+     * replayed message, and chunks append, so before the first replayed chunk of
+     * each message the client gets the message with no content, which clears it,
+     * as v2 requires of a message replayed as chunks.
+     */
+    async replaying(sessionId, restore) {
+        this.replays.set(sessionId, new Set());
+        try {
+            return await restore();
+        }
+        finally {
+            this.replays.delete(sessionId);
+        }
+    }
     /**
      * Sends a v2 session update, and logs rather than rejects when that fails.
      * It and {@link sessionUpdate} hand updates to the connection synchronously,
@@ -72,16 +118,48 @@ class V2ClientConnection {
         return this.ctx.notify(method, params);
     }
     async sessionUpdate({ update, ...notification }) {
-        const v2Update = v2SessionUpdate(update);
-        if (v2Update) {
-            await this.ctx.notify(v2.methods.client.session.update, {
-                ...notification,
-                update: v2Update,
-            });
+        const updates = this.v2Updates(notification.sessionId, update).flatMap((v2Update) => {
+            const clear = this.replayClear(notification.sessionId, v2Update);
+            return clear ? [clear, v2Update] : [v2Update];
+        });
+        // Every update goes to the connection before any is awaited, so an update
+        // that another call sends meanwhile cannot come between them.
+        await Promise.all(updates.map((v2Update) => this.ctx.notify(v2.methods.client.session.update, { ...notification, update: v2Update })));
+    }
+    /**
+     * The v2 updates of a v1 update: for a tool call report, the updates of its
+     * terminal first, then the report itself (see {@link V2Terminals}).
+     */
+    v2Updates(sessionId, update) {
+        if (update.sessionUpdate !== "tool_call" && update.sessionUpdate !== "tool_call_update") {
+            const v2Update = v2SessionUpdate(update);
+            return v2Update ? [v2Update] : [];
         }
+        const { terminal, report } = this.terminals.split(sessionId, update);
+        const reportUpdate = report && v2SessionUpdate(report);
+        return [...terminal, ...(reportUpdate ? [reportUpdate] : [])];
     }
-    requestPermission() {
-        return Promise.reject(new Error("The ACP v2 surface does not serve session/request_permission yet"));
+    /**
+     * The update that clears the message of a replayed chunk, when it is the
+     * first replayed chunk of that message (see {@link replaying}).
+     */
+    replayClear(sessionId, update) {
+        const cleared = this.replays.get(sessionId);
+        if (!cleared)
+            return undefined;
+        const kind = MESSAGE_OF_CHUNK.get(update.sessionUpdate);
+        if (!kind)
+            return undefined;
+        const { messageId } = update;
+        const key = `${kind} ${messageId}`;
+        if (cleared.has(key))
+            return undefined;
+        cleared.add(key);
+        return emptyMessage(kind, messageId);
+    }
+    async requestPermission(params, signal) {
+        const response = await this.ctx.request(v2.methods.client.session.requestPermission, v2PermissionRequest(params), { cancellationSignal: signal });
+        return v1PermissionResponse(response);
     }
     // Elicitation is the same in v1 and v2.
     createElicitation(params, signal) {
@@ -103,6 +181,23 @@ class V2ClientConnection {
         return Promise.reject(new Error("ACP v2 has no client file system"));
     }
 }
+/** The message update of each message chunk. */
+const MESSAGE_OF_CHUNK = new Map([
+    ["user_message_chunk", "user_message"],
+    ["agent_message_chunk", "agent_message"],
+    ["agent_thought_chunk", "agent_thought"],
+]);
+function emptyMessage(kind, messageId) {
+    const message = { messageId, content: [] };
+    switch (kind) {
+        case "user_message":
+            return { ...message, sessionUpdate: kind };
+        case "agent_message":
+            return { ...message, sessionUpdate: kind };
+        default:
+            return { ...message, sessionUpdate: kind };
+    }
+}
 function isExtensionMethod(method) {
     return method.startsWith("_");
 }

package/dist/v2/initialize.d.ts

@@ -14,11 +14,8 @@ export declare function v1InitializeRequest(request: v2.InitializeRequest): Init
 /**
  * The v2 `initialize` response for the v1 response of the agent.
  *
- * It advertises no `session` capability yet. A v2 agent that advertises
- * `session` must serve the whole session baseline (`session/new`, `list`,
- * `resume`, `close`, `prompt`, `cancel`, and `update`), and the v2 surface of
- * the adapter does not serve it yet. Nor does it advertise the unstable
- * `providers` methods, which the v2 surface does not serve yet either.
+ * It does not advertise what the v2 surface does not serve yet: the
+ * extensions of {@link UNSERVED_EXTENSION_KEYS}.
  */
 export declare function v2InitializeResponse(response: InitializeResponse): v2.InitializeResponse;
 //# sourceMappingURL=initialize.d.ts.map

package/dist/v2/initialize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../src/v2/initialize.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAE/D,0DAA0D;AAC1D,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,EAAE,CAAC,iBAAiB,GAAG,iBAAiB,CAwBpF;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,EAAE,CAAC,kBAAkB,CAcxF"}
+{"version":3,"file":"initialize.d.ts","sourceRoot":"","sources":["../../src/v2/initialize.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAE/D,0DAA0D;AAC1D,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,EAAE,CAAC,iBAAiB,GAAG,iBAAiB,CA0BpF;AASD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,EAAE,CAAC,kBAAkB,CAuBxF"}

package/dist/v2/initialize.js

@@ -20,10 +20,12 @@ export function v1InitializeRequest(request) {
             // reads, writes, and runs commands itself.
             fs: { readTextFile: false, writeTextFile: false },
             terminal: false,
-            // Every v2 client handles boolean config options and notices; v1 asks
-            // for a marker. With notices, the agent reports advisories as notices
-            // rather than as transcript messages.
-            session: { configOptions: { boolean: {} }, notices: {} },
+            // Every v2 client handles boolean config options, notices, and
+            // compaction updates; v1 asks for a marker. With them, the agent reports
+            // advisories as notices rather than as transcript messages, and a
+            // compaction as a compaction entity rather than as a "Compact
+            // conversation" tool call, also on replay.
+            session: { configOptions: { boolean: {} }, notices: {}, compaction: {} },
             // v1 marks terminal auth support with a boolean, v2 with an object.
             auth: {
                 terminal: capabilities?.auth?.terminal != null,
@@ -35,30 +37,59 @@ export function v1InitializeRequest(request) {
         ...(request._meta != null ? { _meta: request._meta } : {}),
     };
 }
+/**
+ * The top-level `_meta` keys of the agent's v1 `initialize` response that
+ * advertise an extension the v2 surface does not serve yet: `steering`, for
+ * `_session/steering`.
+ */
+const UNSERVED_EXTENSION_KEYS = ["steering"];
 /**
  * The v2 `initialize` response for the v1 response of the agent.
  *
- * It advertises no `session` capability yet. A v2 agent that advertises
- * `session` must serve the whole session baseline (`session/new`, `list`,
- * `resume`, `close`, `prompt`, `cancel`, and `update`), and the v2 surface of
- * the adapter does not serve it yet. Nor does it advertise the unstable
- * `providers` methods, which the v2 surface does not serve yet either.
+ * It does not advertise what the v2 surface does not serve yet: the
+ * extensions of {@link UNSERVED_EXTENSION_KEYS}.
  */
 export function v2InitializeResponse(response) {
     if (!response.agentInfo) {
         throw new Error("ACP v2 requires agentInfo, and the agent reported none");
     }
     const meta = response.agentCapabilities?._meta;
+    const topMeta = Object.fromEntries(Object.entries(response._meta ?? {}).filter(([key]) => !UNSERVED_EXTENSION_KEYS.includes(key)));
     return {
         protocolVersion: v2.PROTOCOL_VERSION,
         info: response.agentInfo,
         // v1 `auth.logout` has no v2 counterpart: a v2 agent that advertises auth
         // methods must serve `auth/logout`.
-        capabilities: meta != null ? { _meta: meta } : {},
+        capabilities: {
+            session: V2_SESSION_CAPABILITIES,
+            // `providers/list`, `set`, and `disable`, which the agent serves for
+            // every client.
+            providers: {},
+            ...(meta != null ? { _meta: meta } : {}),
+        },
         authMethods: (response.authMethods ?? []).map(v2AuthMethod),
-        ...(response._meta != null ? { _meta: response._meta } : {}),
+        ...(Object.keys(topMeta).length > 0 ? { _meta: topMeta } : {}),
     };
 }
+/**
+ * The session capabilities of the v2 surface, which serves each through a v1
+ * method of the agent.
+ *
+ * - The session baseline: `session/new`, `list`, `resume` (with replay),
+ *   `close`, `prompt`, `cancel`, and `update`.
+ * - `session/delete`, `session/fork` (which returns a session the client can
+ *   prompt, see `v1ForkSessionRequests`), and `additionalDirectories`.
+ * - The prompt content and MCP transports that the agent's v1 `initialize`
+ *   lists: images, embedded context, and HTTP servers. Stdio servers are in the
+ *   v1 baseline; v2 has no SSE transport.
+ */
+const V2_SESSION_CAPABILITIES = {
+    prompt: { image: {}, embeddedContext: {} },
+    mcp: { stdio: {}, http: {} },
+    delete: {},
+    fork: {},
+    additionalDirectories: {},
+};
 /** v2 names the id of a method `methodId`, requires `type`, and lists `env` as name and value pairs. */
 function v2AuthMethod(method) {
     if ("type" in method && method.type === "terminal") {

package/dist/v2/permission.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The v2 form of the permission requests that `ClaudeAcpAgent` sends, and the
+ * v1 form of their answers.
+ */
+import type { RequestPermissionResponse } from "@agentclientprotocol/sdk";
+import type * as v2 from "@agentclientprotocol/sdk/experimental/v2";
+import type { AcpPermissionRequest } from "../permissions/presentation.js";
+/**
+ * The v2 form of a permission request of the agent.
+ *
+ * v1 asks about a tool call, whose title the prompt shows. v2 gives the prompt
+ * its own `title` and `description`, which the agent sets for a v2 client
+ * (`AcpPermissionRequest`), and asks about a `subject`: here always the tool
+ * call, as the same patch that a `tool_call_update` carries.
+ */
+export declare function v2PermissionRequest(request: AcpPermissionRequest): v2.RequestPermissionRequest;
+/**
+ * The v1 form of the answer to a permission request.
+ *
+ * v2 adds outcomes that v1 does not know, which the draft says are no
+ * approval. They become `cancelled`, which the agent reads as an aborted tool
+ * use, as it does a cancelled prompt.
+ */
+export declare function v1PermissionResponse(response: v2.RequestPermissionResponse): RequestPermissionResponse;
+//# sourceMappingURL=permission.d.ts.map

package/dist/v2/permission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.d.ts","sourceRoot":"","sources":["../../src/v2/permission.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,KAAK,KAAK,EAAE,MAAM,0CAA0C,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAG3E;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,EAAE,CAAC,wBAAwB,CAY9F;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,EAAE,CAAC,yBAAyB,GACrC,yBAAyB,CAS3B"}

package/dist/v2/permission.js

@@ -0,0 +1,38 @@
+import { v2ToolCallPatch } from "./tool-call.js";
+/**
+ * The v2 form of a permission request of the agent.
+ *
+ * v1 asks about a tool call, whose title the prompt shows. v2 gives the prompt
+ * its own `title` and `description`, which the agent sets for a v2 client
+ * (`AcpPermissionRequest`), and asks about a `subject`: here always the tool
+ * call, as the same patch that a `tool_call_update` carries.
+ */
+export function v2PermissionRequest(request) {
+    if (request.title === undefined) {
+        throw new Error("An ACP v2 permission request needs a title");
+    }
+    return {
+        sessionId: request.sessionId,
+        title: request.title,
+        ...(request.description ? { description: request.description } : {}),
+        subject: { type: "tool_call", toolCall: v2ToolCallPatch(request.toolCall) },
+        options: request.options,
+        ...(request._meta != null ? { _meta: request._meta } : {}),
+    };
+}
+/**
+ * The v1 form of the answer to a permission request.
+ *
+ * v2 adds outcomes that v1 does not know, which the draft says are no
+ * approval. They become `cancelled`, which the agent reads as an aborted tool
+ * use, as it does a cancelled prompt.
+ */
+export function v1PermissionResponse(response) {
+    const outcome = response.outcome;
+    return {
+        outcome: outcome.outcome === "selected"
+            ? outcome
+            : { outcome: "cancelled" },
+        ...(response._meta != null ? { _meta: response._meta } : {}),
+    };
+}

package/dist/v2/session-update.d.ts

@@ -4,6 +4,12 @@
  */
 import * as v2 from "@agentclientprotocol/sdk/experimental/v2";
 import type { AcpSessionNotification } from "../acp-subagents.js";
+/**
+ * The id of the plan of a session. v1 has one plan per session, which every
+ * plan update replaces whole, from TodoWrite and from the Task tools alike.
+ * v2 tracks plans by id, so that plan gets one.
+ */
+export declare const SESSION_PLAN_ID = "plan";
 /**
  * The v2 form of a v1 session update, or `undefined` when v2 has no
  * counterpart and the update tells a v2 client nothing new.

package/dist/v2/session-update.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-update.d.ts","sourceRoot":"","sources":["../../src/v2/session-update.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAC/D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAGlE;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,sBAAsB,CAAC,QAAQ,CAAC,GACvC,EAAE,CAAC,aAAa,GAAG,SAAS,CA8B9B"}
+{"version":3,"file":"session-update.d.ts","sourceRoot":"","sources":["../../src/v2/session-update.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAC/D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAIlE;;;;GAIG;AACH,eAAO,MAAM,eAAe,SAAS,CAAC;AAEtC;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,sBAAsB,CAAC,QAAQ,CAAC,GACvC,EAAE,CAAC,aAAa,GAAG,SAAS,CA0C9B"}

package/dist/v2/session-update.js

@@ -1,4 +1,11 @@
 import { v2AvailableCommands, v2ConfigOptions } from "./session.js";
+import { v2ToolCallUpdate } from "./tool-call.js";
+/**
+ * The id of the plan of a session. v1 has one plan per session, which every
+ * plan update replaces whole, from TodoWrite and from the Task tools alike.
+ * v2 tracks plans by id, so that plan gets one.
+ */
+export const SESSION_PLAN_ID = "plan";
 /**
  * The v2 form of a v1 session update, or `undefined` when v2 has no
  * counterpart and the update tells a v2 client nothing new.
@@ -15,6 +22,8 @@ export function v2SessionUpdate(update) {
         case "session_info_update":
         case "usage_update":
         case "notice":
+        case "compaction_update":
+        case "compaction_summary_chunk":
             return update;
         case "agent_message_chunk":
         case "agent_thought_chunk":
@@ -26,6 +35,16 @@ export function v2SessionUpdate(update) {
             }
             return { ...chunk, messageId };
         }
+        case "tool_call":
+        case "tool_call_update":
+            return v2ToolCallUpdate(update);
+        case "plan":
+            // A v2 plan of items is replaced whole as well.
+            return {
+                sessionUpdate: "plan_update",
+                plan: { type: "items", planId: SESSION_PLAN_ID, entries: update.entries },
+                ...(update._meta != null ? { _meta: update._meta } : {}),
+            };
         case "current_mode_update":
             // v2 has no modes: the mode is the `mode` config option. Every mode
             // change also reaches the client as a `config_option_update` or in the