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

package/dist/tool-calls/client-capabilities.js

@@ -12,6 +12,7 @@ export class ClientCapabilities {
     terminalOutputDelta;
     diffPatch;
     air;
+    v2;
     constructor(
     /** The client renders a terminal from `_meta.terminal_info`, `terminal_output`, and `terminal_exit`. */
     terminalOutput = false, 
@@ -20,20 +21,27 @@ export class ClientCapabilities {
     /** The client accepts an exact git patch in a diff (`jetbrains.air` `diffPatch`). */
     diffPatch = false, 
     /** The capabilities that only JetBrains AIR declares. */
-    air = NO_AIR) {
+    air = NO_AIR, 
+    /**
+     * The client speaks ACP v2. Its diffs carry structured `changes` and an
+     * optional git patch, which a v1 diff cannot express. Only the v2 surface
+     * sets this, never the capabilities that a client sends.
+     */
+    v2 = false) {
         this.terminalOutput = terminalOutput;
         this.terminalOutputDelta = terminalOutputDelta;
         this.diffPatch = diffPatch;
         this.air = air;
+        this.v2 = v2;
     }
-    static from(capabilities) {
+    static from(capabilities, { v2 = false } = {}) {
         const meta = capabilities?._meta;
         const terminalOutputDelta = meta?.["terminal_output_delta"] === true;
         return new ClientCapabilities(terminalOutputDelta || meta?.["terminal_output"] === true, terminalOutputDelta, clientSupportsAirCapability(capabilities, AIR_DIFF_PATCH_CAPABILITY), {
             client: isAirClient(capabilities),
             rawInputRendering: clientSupportsAirCapability(capabilities, AIR_RAW_INPUT_RENDERING_CAPABILITY),
             planFile: clientSupportsAirCapability(capabilities, AIR_PLAN_FILE_CAPABILITY),
-        });
+        }, v2);
     }
 }
 const NO_AIR = {

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;IAkCpF,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,13 @@ 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.
+            if (!(capabilities.diffPatch || capabilities.v2) || replay) {
                 facts.change = [
                     {
                         type: "diff",
@@ -68,7 +69,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 +77,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 +106,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/turn-events.d.ts

@@ -0,0 +1,71 @@
+/**
+ * A prompt turn as the adapter understands it, independent of the ACP version.
+ *
+ * The agent reports each turn through {@link TurnEvents}, and each ACP version
+ * maps the events to its own messages. ACP v1 answers `session/prompt` when the
+ * turn ends or fails. ACP v2 answers it when the prompt is inserted, and
+ * reports the rest as session state.
+ *
+ * The agent calls these synchronously while it updates its own state, so a
+ * handler must not throw, nor call back into the agent before it returns.
+ */
+export interface TurnEvents {
+    /**
+     * Claude Code took the prompt in as the user message `messageId` of the
+     * conversation. Reported at most once per turn, and never after
+     * {@link ended} or {@link failed}.
+     *
+     * When Claude Code reports command lifecycles (`msg_lifecycle_v1`), that is
+     * when the prompt starts a turn, before the turn's output. Otherwise, and
+     * while another turn is still active (held for its background work,
+     * steered, or cancelled but not yet ended), it is the prompt's echo, after
+     * that turn ended; for a command Claude Code does not echo (such as
+     * `/compact`), it is the command's result, after any output it streamed.
+     */
+    inserted(messageId: string): void;
+    /**
+     * The turn waits for the user: a permission request or a question is open in
+     * the session. Requests do not say which prompt they are for, so this
+     * includes one opened before the turn was inserted. Only reported after
+     * {@link inserted}.
+     */
+    awaitingUser(): void;
+    /**
+     * The turn works again: no request is open any more. A turn that ends or
+     * fails while it waits reports that instead.
+     */
+    resumed(): void;
+    /**
+     * The turn ended. A queued turn that is cancelled before it is inserted
+     * ends too, without {@link inserted}; Claude Code may still run its prompt.
+     */
+    ended(outcome: TurnOutcome): void;
+    /**
+     * The turn failed. Without {@link inserted} before, Claude Code was not seen
+     * taking the prompt in. `title`, when the agent has one, describes the
+     * failure for the user in plain text, such as "API Error: 529 Overloaded".
+     */
+    failed(error: unknown, title?: string): void;
+}
+/** Why a turn ended. Every ACP version has these reasons. */
+export type StopReason = "end_turn" | "max_tokens" | "max_turn_requests" | "refusal" | "cancelled";
+/** How a turn ended. */
+export type TurnOutcome = {
+    stopReason: StopReason;
+    /** The tokens that the main agent loop of the turn used. */
+    usage?: TurnUsage;
+    /**
+     * Extension data for the client, such as the quota breakdown of the turn
+     * and a terminal session failure.
+     */
+    _meta?: Record<string, unknown>;
+};
+export type TurnUsage = {
+    totalTokens: number;
+    inputTokens: number;
+    outputTokens: number;
+    thoughtTokens?: number;
+    cachedReadTokens?: number;
+    cachedWriteTokens?: number;
+};
+//# sourceMappingURL=turn-events.d.ts.map

package/dist/turn-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-events.d.ts","sourceRoot":"","sources":["../src/turn-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC;;;;;OAKG;IACH,YAAY,IAAI,IAAI,CAAC;IACrB;;;OAGG;IACH,OAAO,IAAI,IAAI,CAAC;IAChB;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IAClC;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9C;AAED,6DAA6D;AAC7D,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,YAAY,GAAG,mBAAmB,GAAG,SAAS,GAAG,WAAW,CAAC;AAEnG,wBAAwB;AACxB,MAAM,MAAM,WAAW,GAAG;IACxB,UAAU,EAAE,UAAU,CAAC;IACvB,4DAA4D;IAC5D,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC"}

package/dist/turn-events.js

@@ -0,0 +1 @@
+export {};

package/dist/usage-markdown.d.ts

@@ -2,6 +2,8 @@ import type { SDKControlGetUsageResponse } from "@anthropic-ai/claude-agent-sdk"
 /** Validate the experimental SDK response at the runtime boundary. */
 export declare function parseUsageResponse(value: unknown): SDKControlGetUsageResponse | null;
 export declare function isUsageCommandText(text: string): boolean;
+/** Escape the Markdown syntax characters of `value` and fold its line breaks. */
+export declare function escapeMarkdown(value: string): string;
 /** Render the SDK's structured `/usage` response as Markdown. */
 export declare function formatUsageResponse(usage: SDKControlGetUsageResponse): string;
 //# sourceMappingURL=usage-markdown.d.ts.map

package/dist/usage-markdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usage-markdown.d.ts","sourceRoot":"","sources":["../src/usage-markdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AA8DjF,sEAAsE;AACtE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,0BAA0B,GAAG,IAAI,CAMpF;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AA0ED,iEAAiE;AACjE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,0BAA0B,GAAG,MAAM,CAiE7E"}
+{"version":3,"file":"usage-markdown.d.ts","sourceRoot":"","sources":["../src/usage-markdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AA8DjF,sEAAsE;AACtE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,0BAA0B,GAAG,IAAI,CAMpF;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AASD,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AA+DD,iEAAiE;AACjE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,0BAA0B,GAAG,MAAM,CAiE7E"}

package/dist/usage-markdown.js

@@ -71,7 +71,8 @@ function usageBar(percent) {
     const filled = clamped === 0 ? 0 : Math.max(1, Math.round((clamped / 100) * cells));
     return `${"█".repeat(filled)}${"░".repeat(cells - filled)}`;
 }
-function escapeMarkdown(value) {
+/** Escape the Markdown syntax characters of `value` and fold its line breaks. */
+export function escapeMarkdown(value) {
     return value.replace(/([\\`*_[\]<>|])/g, "\\$1").replace(/[\r\n]+/g, " ");
 }
 function formatDuration(milliseconds) {

package/dist/utils.d.ts

@@ -13,4 +13,16 @@ export declare function nodeToWebWritable(nodeStream: Writable): WritableStream<
 export declare function nodeToWebReadable(nodeStream: Readable): ReadableStream<Uint8Array>;
 export declare function unreachable(value: never, logger?: Logger): void;
 export declare function sleep(time: number): Promise<void>;
+/** The outcome of {@link raceTimeoutAndAbort}. */
+export type RaceOutcome<T> = {
+    type: "done";
+    value: T;
+} | {
+    type: "timeout";
+} | {
+    type: "aborted";
+};
+/** Wait for `promise` until `timeoutMs` passes or `signal` aborts. A rejection
+ *  of `promise` rejects the result. The timer does not keep the process alive. */
+export declare function raceTimeoutAndAbort<T>(promise: Promise<T>, timeoutMs: number, signal: AbortSignal): Promise<RaceOutcome<T>>;
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAGxC,qBAAa,QAAQ,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IAClD,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,IAAI,CAAS;IAErB,IAAI,CAAC,IAAI,EAAE,CAAC;IASZ,GAAG;IAQH,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CAgB3C;AAGD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,CAclF;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,CAUlF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,GAAE,MAAgB,QAQjE;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjD"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAGxC,qBAAa,QAAQ,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IAClD,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,IAAI,CAAS;IAErB,IAAI,CAAC,IAAI,EAAE,CAAC;IASZ,GAAG;IAQH,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CAgB3C;AAGD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,CAclF;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,CAUlF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,GAAE,MAAgB,QAQjE;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjD;AAED,kDAAkD;AAClD,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC;AAEpG;kFACkF;AAClF,wBAAsB,mBAAmB,CAAC,CAAC,EACzC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAoBzB"}

package/dist/utils.js

@@ -79,3 +79,31 @@ export function unreachable(value, logger = console) {
 export function sleep(time) {
     return new Promise((resolve) => setTimeout(resolve, time));
 }
+/** Wait for `promise` until `timeoutMs` passes or `signal` aborts. A rejection
+ *  of `promise` rejects the result. The timer does not keep the process alive. */
+export async function raceTimeoutAndAbort(promise, timeoutMs, signal) {
+    let timeout;
+    let onAbort;
+    try {
+        return await Promise.race([
+            promise.then((value) => ({ type: "done", value })),
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve({ type: "timeout" }), timeoutMs);
+                timeout.unref?.();
+            }),
+            new Promise((resolve) => {
+                onAbort = () => resolve({ type: "aborted" });
+                if (signal.aborted)
+                    onAbort();
+                else
+                    signal.addEventListener("abort", onAbort, { once: true });
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+        if (onAbort)
+            signal.removeEventListener("abort", onAbort);
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/v2/agent.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAkB,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAa9E;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GACvC,EAAE,CAAC,QAAQ,CA4Bb"}
+{"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"}

package/dist/v2/agent.js

@@ -1,6 +1,7 @@
 import * as v2 from "@agentclientprotocol/sdk/experimental/v2";
 import { ClaudeAcpAgent } from "../acp-agent.js";
 import { v1InitializeRequest, v2InitializeResponse } from "./initialize.js";
+import { v2Prompt } from "./prompt.js";
 import { v1NewSessionRequest, v1ResumeSessionRequest, v1SetSessionConfigOptionRequest, v2ConfigOptions, v2NewSessionResponse, v2ResumeSessionResponse, } from "./session.js";
 import { v2SessionUpdate } from "./session-update.js";
 /**
@@ -12,10 +13,12 @@ import { v2SessionUpdate } from "./session-update.js";
  */
 export function v2AgentApp(logger, onAgent) {
     let agent;
+    let client;
     return v2
         .agent({ name: "claude-code-acp" })
         .onConnect((connection) => {
-        agent = new ClaudeAcpAgent(new V2ClientConnection(connection.client), logger);
+        client = new V2ClientConnection(connection.client, logger ?? console);
+        agent = new ClaudeAcpAgent(client, logger, { v2: true });
         onAgent(agent);
     })
         .onRequest(v2.methods.agent.initialize, async ({ params }) => v2InitializeResponse(await agent.initialize(v1InitializeRequest(params))))
@@ -29,19 +32,38 @@ export function v2AgentApp(logger, onAgent) {
         .onRequest(v2.methods.agent.session.setConfigOption, async ({ params }) => {
         const { configOptions, ...response } = await agent.setSessionConfigOption(v1SetSessionConfigOptionRequest(params));
         return { ...response, configOptions: v2ConfigOptions(configOptions) };
-    });
+    })
+        .onRequest(v2.methods.agent.session.prompt, ({ params }) => v2Prompt(agent, params, (update) => {
+        void client.send({ sessionId: params.sessionId, update });
+    }))
+        .onNotification(v2.methods.agent.session.cancel, ({ params }) => agent.cancel(params));
 }
 /**
  * The {@link AcpClient} of an ACP v2 connection: it sends the v1 messages of
  * the agent as v2 messages.
  *
- * The v2 surface does not serve prompts yet, so permission requests, which
- * only a prompt turn makes, still reject.
+ * Permission requests still reject until the v2 surface translates them.
  */
 class V2ClientConnection {
     ctx;
-    constructor(ctx) {
+    logger;
+    constructor(ctx, logger) {
         this.ctx = ctx;
+        this.logger = logger;
+    }
+    /**
+     * Sends a v2 session update, and logs rather than rejects when that fails.
+     * It and {@link sessionUpdate} hand updates to the connection synchronously,
+     * so they go out in the order of the calls. The agent's consumer awaits each
+     * of its updates before it reports the next turn event, so a turn's state
+     * follows the output that came before it. (An update the consumer is still
+     * routing can be overtaken by an event from elsewhere, such as a permission
+     * request opening.)
+     */
+    send(notification) {
+        return this.ctx.notify(v2.methods.client.session.update, notification).catch((error) => {
+            this.logger.error(`Failed to send a ${notification.update.sessionUpdate} update:`, error);
+        });
     }
     extNotification(method, params) {
         if (!isExtensionMethod(method)) {

package/dist/v2/prompt.d.ts

@@ -0,0 +1,47 @@
+/**
+ * ACP v2 `session/prompt`, served through the turn events of `ClaudeAcpAgent`.
+ *
+ * v2 answers the prompt once Claude Code takes it in, with the id of the user
+ * message it became, and reports the rest of the turn as `state_update`s.
+ */
+import { type PromptRequest } from "@agentclientprotocol/sdk";
+import * as v2 from "@agentclientprotocol/sdk/experimental/v2";
+import type { ClaudeAcpAgent } from "../acp-agent.js";
+/**
+ * Starts a turn for `params`, and answers when Claude Code takes the prompt
+ * in. `send` delivers a session update of the prompt's session; it must not
+ * throw, and must deliver updates in the order it is called, also relative to
+ * the agent's own updates.
+ *
+ * - Taken in: the prompt's `user_message`, then `running`, then the answer.
+ * - Waiting on a permission request or a question: `requires_action`, and
+ *   `running` once none is open.
+ * - Ended: `idle` with the stop reason, usage, and `_meta` of the turn.
+ * - Failed after it was taken in: `idle` with {@link FAILED_STOP_REASON} and
+ *   the JSON-RPC error that v1 answers with in `_meta.claudeCode.error`, and
+ *   an error `notice` before it that shows the failure. v2 has no error on
+ *   `idle`, and a notice must not be the only report of a failure.
+ * - Ended or failed before it was taken in: the answer is a JSON-RPC error,
+ *   `-32800` for a prompt that a cancel ended in the queue.
+ *
+ * Deferred decision: a turn whose background subagents still run ends only
+ * when they finish (`Turn.deferredSettle`), so `idle` waits for them too. The
+ * hold exists for v1, whose clients stop listening at the prompt response.
+ * v2 allows background updates while idle, so it could report `idle` at the
+ * turn's result instead, with a turn event for the hold. To be decided with
+ * async tasks (step 6 in `docs/acp-v2.md`).
+ */
+export declare function v2Prompt(agent: ClaudeAcpAgent, params: v2.PromptRequest, send: (update: v2.SessionUpdate) => void): Promise<v2.PromptResponse>;
+/**
+ * The stop reason of a turn that failed after it was taken in. v2's stop
+ * reasons all describe work that ended without an error, and a custom one
+ * starts with `_`; clients show it as a generic stop.
+ */
+export declare const FAILED_STOP_REASON = "_error";
+/**
+ * A v2 prompt may hold content blocks that v1 cannot express: a custom one,
+ * or one from a newer ACP version. Clients send only the kinds the agent
+ * advertised, so such a block is rejected rather than silently dropped.
+ */
+export declare function v1PromptRequest({ prompt, ...request }: v2.PromptRequest): PromptRequest;
+//# sourceMappingURL=prompt.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../src/v2/prompt.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAIL,KAAK,aAAa,EAEnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAItD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,EAAE,CAAC,aAAa,EACxB,IAAI,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,aAAa,KAAK,IAAI,GACvC,OAAO,CAAC,EAAE,CAAC,cAAc,CAAC,CA0D5B;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,WAAW,CAAC;AA2B3C;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,EAAE,EAAE,EAAE,CAAC,aAAa,GAAG,aAAa,CAEvF"}

package/dist/v2/prompt.js

@@ -0,0 +1,153 @@
+/**
+ * ACP v2 `session/prompt`, served through the turn events of `ClaudeAcpAgent`.
+ *
+ * v2 answers the prompt once Claude Code takes it in, with the id of the user
+ * message it became, and reports the rest of the turn as `state_update`s.
+ */
+import { RequestError, } from "@agentclientprotocol/sdk";
+import * as v2 from "@agentclientprotocol/sdk/experimental/v2";
+import { splitNoticeText } from "../session-notices.js";
+/**
+ * Starts a turn for `params`, and answers when Claude Code takes the prompt
+ * in. `send` delivers a session update of the prompt's session; it must not
+ * throw, and must deliver updates in the order it is called, also relative to
+ * the agent's own updates.
+ *
+ * - Taken in: the prompt's `user_message`, then `running`, then the answer.
+ * - Waiting on a permission request or a question: `requires_action`, and
+ *   `running` once none is open.
+ * - Ended: `idle` with the stop reason, usage, and `_meta` of the turn.
+ * - Failed after it was taken in: `idle` with {@link FAILED_STOP_REASON} and
+ *   the JSON-RPC error that v1 answers with in `_meta.claudeCode.error`, and
+ *   an error `notice` before it that shows the failure. v2 has no error on
+ *   `idle`, and a notice must not be the only report of a failure.
+ * - Ended or failed before it was taken in: the answer is a JSON-RPC error,
+ *   `-32800` for a prompt that a cancel ended in the queue.
+ *
+ * Deferred decision: a turn whose background subagents still run ends only
+ * when they finish (`Turn.deferredSettle`), so `idle` waits for them too. The
+ * hold exists for v1, whose clients stop listening at the prompt response.
+ * v2 allows background updates while idle, so it could report `idle` at the
+ * turn's result instead, with a turn event for the hold. To be decided with
+ * async tasks (step 6 in `docs/acp-v2.md`).
+ */
+export function v2Prompt(agent, params, send) {
+    return new Promise((resolve, reject) => {
+        let inserted = false;
+        const events = {
+            inserted(messageId) {
+                inserted = true;
+                send({ sessionUpdate: "user_message", messageId, content: params.prompt });
+                send({ sessionUpdate: "state_update", state: "running" });
+                resolve({ messageId });
+            },
+            awaitingUser() {
+                send({ sessionUpdate: "state_update", state: "requires_action" });
+            },
+            resumed() {
+                send({ sessionUpdate: "state_update", state: "running" });
+            },
+            ended(outcome) {
+                if (inserted) {
+                    send(idle(outcome));
+                }
+                else if (outcome.stopReason === "cancelled") {
+                    reject(RequestError.requestCancelled());
+                }
+                else {
+                    reject(RequestError.internalError({ stopReason: outcome.stopReason }, "The turn ended before Claude Code took the prompt in"));
+                }
+            },
+            failed(error, title) {
+                if (!inserted) {
+                    reject(error);
+                    return;
+                }
+                const failure = jsonRpcError(error);
+                send({
+                    sessionUpdate: "notice",
+                    severity: "error",
+                    ...splitNoticeText(title ?? failure.message, "The turn failed"),
+                });
+                send({
+                    sessionUpdate: "state_update",
+                    state: "idle",
+                    stopReason: FAILED_STOP_REASON,
+                    _meta: { claudeCode: { error: failure } },
+                });
+            },
+        };
+        let request;
+        try {
+            request = v1PromptRequest(params);
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        agent.startTurn(request, events).catch(reject);
+    });
+}
+/**
+ * The stop reason of a turn that failed after it was taken in. v2's stop
+ * reasons all describe work that ended without an error, and a custom one
+ * starts with `_`; clients show it as a generic stop.
+ */
+export const FAILED_STOP_REASON = "_error";
+/** The JSON-RPC error that v1 answers a failed prompt with. */
+function jsonRpcError(error) {
+    if (error instanceof RequestError) {
+        return {
+            code: error.code,
+            message: error.message,
+            ...(error.data !== undefined ? { data: error.data } : {}),
+        };
+    }
+    return {
+        code: RequestError.internalError().code,
+        message: error instanceof Error ? error.message : String(error),
+    };
+}
+function idle({ stopReason, usage, _meta }) {
+    return {
+        sessionUpdate: "state_update",
+        state: "idle",
+        stopReason,
+        ...(usage ? { usage } : {}),
+        ...(_meta ? { _meta } : {}),
+    };
+}
+/**
+ * A v2 prompt may hold content blocks that v1 cannot express: a custom one,
+ * or one from a newer ACP version. Clients send only the kinds the agent
+ * advertised, so such a block is rejected rather than silently dropped.
+ */
+export function v1PromptRequest({ prompt, ...request }) {
+    return { ...request, prompt: prompt.map(v1ContentBlock) };
+}
+function v1ContentBlock(block) {
+    if (v2.ContentBlock.isText(block) ||
+        v2.ContentBlock.isImage(block) ||
+        v2.ContentBlock.isAudio(block) ||
+        v2.ContentBlock.isResourceLink(block) ||
+        v2.ContentBlock.isResource(block)) {
+        const { annotations, ...rest } = block;
+        return annotations != null ? { ...rest, annotations: v1Annotations(annotations) } : rest;
+    }
+    throw RequestError.invalidParams({ type: block.type }, `Content blocks of type ${block.type} are not supported`);
+}
+/**
+ * v2 also accepts audiences of a newer ACP version; v1 knows two. An audience
+ * of only unknown roles is dropped rather than narrowed to nobody.
+ */
+function v1Annotations({ audience, ...annotations }) {
+    if (audience == null)
+        return annotations;
+    const known = audience.filter(isV1Role);
+    return known.length > 0 || audience.length === 0
+        ? { ...annotations, audience: known }
+        : annotations;
+}
+function isV1Role(role) {
+    return role === "assistant" || role === "user";
+}

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,CAoB9B"}
+{"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;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,sBAAsB,CAAC,QAAQ,CAAC,GACvC,EAAE,CAAC,aAAa,GAAG,SAAS,CAiC9B"}

package/dist/v2/session-update.js

@@ -1,4 +1,5 @@
 import { v2AvailableCommands, v2ConfigOptions } from "./session.js";
+import { v2ToolCallUpdate } from "./tool-call.js";
 /**
  * The v2 form of a v1 session update, or `undefined` when v2 has no
  * counterpart and the update tells a v2 client nothing new.
@@ -16,6 +17,19 @@ export function v2SessionUpdate(update) {
         case "usage_update":
         case "notice":
             return update;
+        case "agent_message_chunk":
+        case "agent_thought_chunk":
+        case "user_message_chunk": {
+            // v2 requires the id of the message a chunk belongs to; v1 allows none.
+            const { messageId, ...chunk } = update;
+            if (!messageId) {
+                throw new Error(`An ACP v2 ${update.sessionUpdate} needs a messageId`);
+            }
+            return { ...chunk, messageId };
+        }
+        case "tool_call":
+        case "tool_call_update":
+            return v2ToolCallUpdate(update);
         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

package/dist/v2/tool-call.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The v2 form of the tool call reports that `ClaudeAcpAgent` sends as v1
+ * `tool_call` and `tool_call_update` updates.
+ */
+import type { ToolCall, ToolCallUpdate } from "@agentclientprotocol/sdk";
+import type * as v2 from "@agentclientprotocol/sdk/experimental/v2";
+type V1ToolCallReport = (ToolCall & {
+    sessionUpdate: "tool_call";
+}) | (ToolCallUpdate & {
+    sessionUpdate: "tool_call_update";
+});
+type V2ToolCallUpdate = v2.ToolCallUpdate & {
+    sessionUpdate: "tool_call_update";
+};
+/**
+ * The v2 form of a v1 tool call report.
+ *
+ * v1 reports a new tool call with `tool_call` and changes it with
+ * `tool_call_update`; v2 has one `tool_call_update` that upserts by
+ * `toolCallId`. Both leave a field that a report omits unchanged, and both
+ * replace `content` and `locations` as whole arrays. They differ on `null`:
+ * in v1 it leaves the field unchanged too, in v2 it clears the field, so `null`
+ * fields are left out.
+ *
+ * Diffs need what a v1 diff does not say, so the agent builds them in v2 form
+ * for a v2 client (`v2DiffContent`), and they pass as they are. Terminal
+ * content throws until the v2 surface translates it (step 4 of
+ * `docs/acp-v2.md`).
+ */
+export declare function v2ToolCallUpdate(report: V1ToolCallReport): V2ToolCallUpdate;
+export {};
+//# sourceMappingURL=tool-call.d.ts.map

package/dist/v2/tool-call.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call.d.ts","sourceRoot":"","sources":["../../src/v2/tool-call.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAmB,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1F,OAAO,KAAK,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAEpE,KAAK,gBAAgB,GACjB,CAAC,QAAQ,GAAG;IAAE,aAAa,EAAE,WAAW,CAAA;CAAE,CAAC,GAC3C,CAAC,cAAc,GAAG;IAAE,aAAa,EAAE,kBAAkB,CAAA;CAAE,CAAC,CAAC;AAE7D,KAAK,gBAAgB,GAAG,EAAE,CAAC,cAAc,GAAG;IAAE,aAAa,EAAE,kBAAkB,CAAA;CAAE,CAAC;AAElF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,CAW3E"}