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

package/dist/session-mode.js

@@ -1,5 +1,6 @@
 import { RequestError, } from "@agentclientprotocol/sdk";
 import { AIR_KIND_KEY, airOnlyMeta } from "./air-extension.js";
+import { resolvePermissionMode } from "./permissions/modes.js";
 import { noticeOrTranscriptUpdate, noticeTranscriptText, sentenceCase, } from "./session-notices.js";
 export const MODE_CONFIG_ID = "mode";
 export const AUTO_MODE_FALLBACK = "acceptEdits";
@@ -11,6 +12,27 @@ const AUTO_MODE_FALLBACK_NOTICE = {
     title: "Auto mode unavailable",
     description: sentenceCase(AUTO_MODE_FALLBACK_REASON),
 };
+/**
+ * The permission mode a new Claude query starts in.
+ *
+ * An explicit mode wins. A resume or a load continues in the mode of the last
+ * user record of the transcript. If that mode is unknown or not available now,
+ * for example bypass, the session starts in `defaultMode` of the settings.
+ */
+export function resolveInitialPermissionMode(sources, logger, allowBypass) {
+    if (sources.explicit !== undefined) {
+        return resolvePermissionMode(sources.explicit, logger, allowBypass);
+    }
+    if (sources.resumed !== undefined) {
+        let rejected = false;
+        const mode = resolvePermissionMode(sources.resumed, { error: () => (rejected = true) }, allowBypass);
+        if (!rejected)
+            return mode;
+        logger.error(`Ignoring permission mode "${sources.resumed}" of the resumed transcript: ` +
+            `not available in this session.`);
+    }
+    return resolvePermissionMode(sources.defaultMode, logger, allowBypass);
+}
 /** Owns session-mode policy and the ACP/SDK synchronization it requires. */
 export class SessionModeManager {
     options;

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);
         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,30 @@
+/**
+ * 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.
+ *
+ * Diff and terminal content throw until the v2 surface translates them
+ * (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;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,CAW3E"}

package/dist/v2/tool-call.js

@@ -0,0 +1,30 @@
+/**
+ * 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.
+ *
+ * Diff and terminal content throw until the v2 surface translates them
+ * (step 4 of `docs/acp-v2.md`).
+ */
+export function v2ToolCallUpdate(report) {
+    const patch = Object.fromEntries(Object.entries(report).filter(([key, value]) => value !== null && key !== "sessionUpdate" && key !== "content"));
+    return {
+        ...patch,
+        sessionUpdate: "tool_call_update",
+        ...(report.content != null ? { content: report.content.map(v2ToolCallContent) } : {}),
+    };
+}
+function v2ToolCallContent(item) {
+    switch (item.type) {
+        case "content":
+            // v2 content blocks are a superset of the v1 blocks.
+            return item;
+        default:
+            throw new Error(`The ACP v2 surface does not translate ${item.type} tool call content yet`);
+    }
+}

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.85.2-preview.1",
+  "version": "0.85.2-preview.10",
   "description": "An ACP-compatible coding agent powered by the Claude Agent SDK (TypeScript)",
   "main": "dist/lib.js",
   "types": "dist/lib.d.ts",
@@ -66,7 +66,7 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.7.0",
-    "@anthropic-ai/claude-agent-sdk": "0.3.286",
+    "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "diff": "9.0.0",
     "zod": "4.6.5"
   },