@agentclientprotocol/claude-agent-acp 0.85.2-preview.2 → 0.85.2-preview.20

package/dist/v2/initialize.js

@@ -38,11 +38,8 @@ export function v1InitializeRequest(request) {
 /**
  * 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 the unstable `providers` methods, which the v2
+ * surface does not serve yet.
  */
 export function v2InitializeResponse(response) {
     if (!response.agentInfo) {
@@ -54,11 +51,31 @@ export function v2InitializeResponse(response) {
         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,
+            ...(meta != null ? { _meta: meta } : {}),
+        },
         authMethods: (response.authMethods ?? []).map(v2AuthMethod),
         ...(response._meta != null ? { _meta: response._meta } : {}),
     };
 }
+/**
+ * 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` and `additionalDirectories`. Not `session/fork` yet.
+ * - 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: {},
+    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/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

@@ -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,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;;;;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,CAwC9B"}

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.
@@ -16,6 +23,26 @@ 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 "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

package/dist/v2/session.d.ts

@@ -3,14 +3,25 @@
  * `ClaudeAcpAgent`: v2 requests become the v1 requests that the agent serves,
  * and its v1 responses become v2 responses.
  */
-import { type AvailableCommand, type NewSessionRequest, type NewSessionResponse, type ResumeSessionRequest, type ResumeSessionResponse, type SessionConfigOption, type SetSessionConfigOptionRequest } from "@agentclientprotocol/sdk";
+import { type AvailableCommand, type LoadSessionRequest, type NewSessionRequest, type NewSessionResponse, type ResumeSessionRequest, type ResumeSessionResponse, type SessionConfigOption, type SetSessionConfigOptionRequest } from "@agentclientprotocol/sdk";
 import * as v2 from "@agentclientprotocol/sdk/experimental/v2";
 export declare function v1NewSessionRequest(params: v2.NewSessionRequest): NewSessionRequest;
 /**
- * `replayFrom` is rejected until the v2 surface can translate the replayed
- * history, which needs the message and tool call updates.
+ * The v1 request that a v2 `session/resume` means.
+ *
+ * v2 restores a session with `session/resume` and replays its history only
+ * when `replayFrom` asks for it. v1 has two methods: `session/resume`, which
+ * never replays, and `session/load`, which replays the whole history before it
+ * responds. `replayFrom: { type: "start" }` is the second; a cursor that
+ * starts elsewhere is rejected.
  */
-export declare function v1ResumeSessionRequest(params: v2.ResumeSessionRequest): ResumeSessionRequest;
+export declare function v1RestoreSessionRequest(params: v2.ResumeSessionRequest): {
+    method: "resume";
+    request: ResumeSessionRequest;
+} | {
+    method: "load";
+    request: LoadSessionRequest;
+};
 /** v2 drops `modes`: the session mode is the `mode` config option, which the agent always lists. */
 export declare function v2NewSessionResponse(response: NewSessionResponse): v2.NewSessionResponse;
 export declare function v2ResumeSessionResponse(response: ResumeSessionResponse): v2.ResumeSessionResponse;

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

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/v2/session.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAEL,KAAK,gBAAgB,EAErB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EAGxB,KAAK,6BAA6B,EACnC,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAE/D,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,EAAE,CAAC,iBAAiB,GAAG,iBAAiB,CAInF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,EAAE,CAAC,oBAAoB,GAAG,oBAAoB,CAS5F;AAED,oGAAoG;AACpG,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,EAAE,CAAC,kBAAkB,CAExF;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,qBAAqB,GAAG,EAAE,CAAC,qBAAqB,CAKjG;AAED,uEAAuE;AACvE,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,EAAE,CAAC,6BAA6B,GACvC,6BAA6B,CAgB/B;AAED,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB,EAAE,GAAG,EAAE,CAAC,mBAAmB,EAAE,CAQxF;AAWD,oEAAoE;AACpE,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,EAAE,CAAC,gBAAgB,EAAE,CAKvF"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/v2/session.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EAEvB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EAGxB,KAAK,6BAA6B,EACnC,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAE/D,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,EAAE,CAAC,iBAAiB,GAAG,iBAAiB,CAInF;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,EAAE,CAAC,oBAAoB,GAE7B;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,oBAAoB,CAAA;CAAE,GACnD;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,kBAAkB,CAAA;CAAE,CAkBlD;AAED,oGAAoG;AACpG,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,EAAE,CAAC,kBAAkB,CAExF;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,qBAAqB,GAAG,EAAE,CAAC,qBAAqB,CAKjG;AAED,uEAAuE;AACvE,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,EAAE,CAAC,6BAA6B,GACvC,6BAA6B,CAgB/B;AAED,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB,EAAE,GAAG,EAAE,CAAC,mBAAmB,EAAE,CAQxF;AAWD,oEAAoE;AACpE,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,EAAE,CAAC,gBAAgB,EAAE,CAKvF"}

package/dist/v2/session.js

@@ -11,15 +11,29 @@ export function v1NewSessionRequest(params) {
     return { ...request, mcpServers: (mcpServers ?? []).map(v1McpServer) };
 }
 /**
- * `replayFrom` is rejected until the v2 surface can translate the replayed
- * history, which needs the message and tool call updates.
+ * The v1 request that a v2 `session/resume` means.
+ *
+ * v2 restores a session with `session/resume` and replays its history only
+ * when `replayFrom` asks for it. v1 has two methods: `session/resume`, which
+ * never replays, and `session/load`, which replays the whole history before it
+ * responds. `replayFrom: { type: "start" }` is the second; a cursor that
+ * starts elsewhere is rejected.
  */
-export function v1ResumeSessionRequest(params) {
+export function v1RestoreSessionRequest(params) {
     const { replayFrom, mcpServers, ...request } = params;
-    if (replayFrom != null) {
-        throw RequestError.invalidParams({ replayFrom }, "The ACP v2 surface does not replay session history yet");
+    if (replayFrom == null) {
+        return {
+            method: "resume",
+            request: { ...request, ...(mcpServers ? { mcpServers: mcpServers.map(v1McpServer) } : {}) },
+        };
     }
-    return { ...request, ...(mcpServers ? { mcpServers: mcpServers.map(v1McpServer) } : {}) };
+    if (replayFrom.type !== "start") {
+        throw RequestError.invalidParams({ replayFrom }, `Replaying from a ${replayFrom.type} cursor is not supported`);
+    }
+    return {
+        method: "load",
+        request: { ...request, mcpServers: (mcpServers ?? []).map(v1McpServer) },
+    };
 }
 /** v2 drops `modes`: the session mode is the `mode` config option, which the agent always lists. */
 export function v2NewSessionResponse(response) {

package/dist/v2/terminal.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Agent-owned display terminals for the commands that the agent runs.
+ *
+ * The agent reports a command through the terminal extension of ACP v1
+ * clients, as codex-acp does: `_meta.terminal_info` names the terminal of a
+ * tool call, whose content references it; `terminal_output` (a snapshot) or
+ * `terminal_output_delta` (a chunk) carries the output, and `terminal_exit` the
+ * exit. ACP v2 standardizes this as display-only terminals: the same content
+ * reference, and `terminal_update` and `terminal_output_chunk` for the
+ * terminal's state. The agent reports to a v2 client as to a client of the
+ * extension (`ToolCallClientCapabilities.from`), and {@link V2Terminals} turns
+ * the extension's keys into those 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";
+});
+/** The terminal updates of the tool call reports of one v2 connection. */
+export declare class V2Terminals {
+    /** The terminal and the last reported command of each running command, by session and tool call. */
+    private readonly running;
+    /**
+     * The terminal updates that a tool call report carries in the extension's
+     * keys, and the report without them, or undefined when nothing else is left
+     * in it.
+     *
+     * The extension names no command, so the terminal gets the command of the
+     * tool call's `rawInput` once a report carries it: the first report of a
+     * streamed tool use has no input yet.
+     */
+    split(sessionId: string, report: V1ToolCallReport): {
+        terminal: v2.SessionUpdate[];
+        report: V1ToolCallReport | undefined;
+    };
+    /** Forgets the terminals of a session. */
+    forget(sessionId: string): void;
+}
+export {};
+//# sourceMappingURL=terminal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../src/v2/terminal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AACzE,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;AAiB7D,0EAA0E;AAC1E,qBAAa,WAAW;IACtB,oGAAoG;IACpG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+D;IAEvF;;;;;;;;OAQG;IACH,KAAK,CACH,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,gBAAgB,GACvB;QAAE,QAAQ,EAAE,EAAE,CAAC,aAAa,EAAE,CAAC;QAAC,MAAM,EAAE,gBAAgB,GAAG,SAAS,CAAA;KAAE;IAuCzE,0CAA0C;IAC1C,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;CAKhC"}

package/dist/v2/terminal.js

@@ -0,0 +1,95 @@
+const TERMINAL_KEYS = [
+    "terminal_info",
+    "terminal_output",
+    "terminal_output_delta",
+    "terminal_exit",
+];
+/** The terminal updates of the tool call reports of one v2 connection. */
+export class V2Terminals {
+    /** The terminal and the last reported command of each running command, by session and tool call. */
+    running = new Map();
+    /**
+     * The terminal updates that a tool call report carries in the extension's
+     * keys, and the report without them, or undefined when nothing else is left
+     * in it.
+     *
+     * The extension names no command, so the terminal gets the command of the
+     * tool call's `rawInput` once a report carries it: the first report of a
+     * streamed tool use has no input yet.
+     */
+    split(sessionId, report) {
+        const meta = (report._meta ?? {});
+        const key = `${sessionId} ${report.toolCallId}`;
+        if (meta.terminal_info)
+            this.running.set(key, { terminalId: meta.terminal_info.terminal_id });
+        const terminal = [];
+        const running = this.running.get(key);
+        if (running) {
+            const command = commandOf(report.rawInput);
+            const newCommand = command !== undefined && command !== running.command;
+            if (newCommand)
+                running.command = command;
+            const { terminal_output: output, terminal_output_delta: delta, terminal_exit: exit } = meta;
+            if (meta.terminal_info || newCommand || output || exit) {
+                terminal.push({
+                    sessionUpdate: "terminal_update",
+                    terminalId: running.terminalId,
+                    ...(newCommand ? { command } : {}),
+                    ...(output ? { output: { data: base64(output.data) } } : {}),
+                    ...(exit
+                        ? {
+                            exitStatus: {
+                                exitCode: exit.exit_code,
+                                ...(exit.signal != null ? { signal: exit.signal } : {}),
+                            },
+                        }
+                        : {}),
+                });
+            }
+            if (delta) {
+                terminal.push({
+                    sessionUpdate: "terminal_output_chunk",
+                    terminalId: running.terminalId,
+                    data: base64(delta.data),
+                });
+            }
+            if (exit)
+                this.running.delete(key);
+        }
+        return { terminal, report: withoutTerminalKeys(report) };
+    }
+    /** Forgets the terminals of a session. */
+    forget(sessionId) {
+        for (const key of this.running.keys()) {
+            if (key.startsWith(`${sessionId} `))
+                this.running.delete(key);
+        }
+    }
+}
+/**
+ * The report without the extension's keys, or undefined when it carried
+ * nothing else but `_meta`: the output report of a command carries the output
+ * alone, and only the stamps that every report of the tool call repeats. In v2
+ * a concrete `_meta` replaces the stored one, so sending them would drop the
+ * other keys that the tool call holds.
+ */
+function withoutTerminalKeys(report) {
+    if (!report._meta || !TERMINAL_KEYS.some((key) => key in report._meta))
+        return report;
+    const meta = Object.fromEntries(Object.entries(report._meta).filter(([key]) => !TERMINAL_KEYS.includes(key)));
+    const stripped = { ...report };
+    if (Object.keys(meta).length > 0)
+        stripped._meta = meta;
+    else
+        delete stripped._meta;
+    const fields = Object.keys(stripped).filter((key) => key !== "sessionUpdate" && key !== "toolCallId" && key !== "_meta");
+    return fields.length > 0 || report.sessionUpdate === "tool_call" ? stripped : undefined;
+}
+function commandOf(rawInput) {
+    const command = rawInput?.command;
+    return typeof command === "string" && command.length > 0 ? command : undefined;
+}
+/** The output bytes, base64-encoded as a v2 terminal carries them. */
+function base64(text) {
+    return Buffer.from(text, "utf8").toString("base64");
+}

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

@@ -0,0 +1,38 @@
+/**
+ * The v2 form of the tool call reports that `ClaudeAcpAgent` sends as v1
+ * `tool_call` and `tool_call_update` updates, and in permission requests.
+ */
+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 references a display terminal, as in v2: a v2 client has no client
+ * terminals, so the agent's only terminals are those of its terminal extension
+ * (see `terminal.ts`).
+ */
+export declare function v2ToolCallUpdate(report: V1ToolCallReport): V2ToolCallUpdate;
+/**
+ * The v2 form of the fields of a v1 tool call report, which a session update
+ * and the subject of a permission request carry. See {@link v2ToolCallUpdate}.
+ */
+export declare function v2ToolCallPatch(toolCall: ToolCall | ToolCallUpdate): v2.ToolCallUpdate;
+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;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,CAE3E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,cAAc,GAAG,EAAE,CAAC,cAAc,CAUtF"}