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

package/dist/v2/session.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The ACP v2 session lifecycle, expressed through the v1 session methods of
+ * `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 * 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.
+ */
+export declare function v1ResumeSessionRequest(params: v2.ResumeSessionRequest): ResumeSessionRequest;
+/** 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;
+/** v2 tags a select value with `type: "id"`; v1 leaves it untagged. */
+export declare function v1SetSessionConfigOptionRequest(params: v2.SetSessionConfigOptionRequest): SetSessionConfigOptionRequest;
+/** v2 names the id of an option `configId` and the id of a select group `groupId`. */
+export declare function v2ConfigOptions(options: SessionConfigOption[]): v2.SessionConfigOption[];
+/** v2 tags the free-text input of a command with `type: "text"`. */
+export declare function v2AvailableCommands(commands: AvailableCommand[]): v2.AvailableCommand[];
+//# sourceMappingURL=session.d.ts.map

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

@@ -0,0 +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"}

package/dist/v2/session.js

@@ -0,0 +1,96 @@
+/**
+ * The ACP v2 session lifecycle, expressed through the v1 session methods of
+ * `ClaudeAcpAgent`: v2 requests become the v1 requests that the agent serves,
+ * and its v1 responses become v2 responses.
+ */
+import { RequestError, } from "@agentclientprotocol/sdk";
+import * as v2 from "@agentclientprotocol/sdk/experimental/v2";
+export function v1NewSessionRequest(params) {
+    const { mcpServers, ...request } = params;
+    // v1 requires the list; v2 treats an omitted list as an empty one.
+    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.
+ */
+export function v1ResumeSessionRequest(params) {
+    const { replayFrom, mcpServers, ...request } = params;
+    if (replayFrom != null) {
+        throw RequestError.invalidParams({ replayFrom }, "The ACP v2 surface does not replay session history yet");
+    }
+    return { ...request, ...(mcpServers ? { mcpServers: mcpServers.map(v1McpServer) } : {}) };
+}
+/** v2 drops `modes`: the session mode is the `mode` config option, which the agent always lists. */
+export function v2NewSessionResponse(response) {
+    return { sessionId: response.sessionId, ...v2ResumeSessionResponse(response) };
+}
+export function v2ResumeSessionResponse(response) {
+    return {
+        ...v2ConfigOptionsField(response.configOptions),
+        ...(response._meta != null ? { _meta: response._meta } : {}),
+    };
+}
+/** v2 tags a select value with `type: "id"`; v1 leaves it untagged. */
+export function v1SetSessionConfigOptionRequest(params) {
+    const request = {
+        sessionId: params.sessionId,
+        configId: params.configId,
+        ...(params._meta != null ? { _meta: params._meta } : {}),
+    };
+    if (v2.SetSessionConfigOptionRequest.isId(params)) {
+        return { ...request, value: params.value };
+    }
+    if (v2.SetSessionConfigOptionRequest.isBoolean(params)) {
+        return { ...request, type: "boolean", value: params.value };
+    }
+    throw RequestError.invalidParams({ type: params.type }, `Config option values of type ${params.type} are not supported`);
+}
+/** v2 names the id of an option `configId` and the id of a select group `groupId`. */
+export function v2ConfigOptions(options) {
+    return options.map((option) => {
+        const { id, ...rest } = option;
+        if (rest.type === "select") {
+            return { ...rest, configId: id, options: v2SelectOptions(rest.options) };
+        }
+        return { ...rest, configId: id };
+    });
+}
+function v2SelectOptions(options) {
+    if (!isGrouped(options))
+        return options;
+    return options.map(({ group, ...selectGroup }) => ({ ...selectGroup, groupId: group }));
+}
+function isGrouped(options) {
+    return options.some((entry) => "group" in entry);
+}
+/** v2 tags the free-text input of a command with `type: "text"`. */
+export function v2AvailableCommands(commands) {
+    return commands.map(({ input, ...command }) => ({
+        ...command,
+        ...(input != null ? { input: { type: "text", ...input } } : {}),
+    }));
+}
+/** v1 responses may send `null`; v2 omits the field instead. */
+function v2ConfigOptionsField(options) {
+    return options != null ? { configOptions: v2ConfigOptions(options) } : {};
+}
+/**
+ * v2 requires a `type` on every transport and makes the empty lists optional.
+ * The agent recognizes a v1 stdio server by its missing `type`, so the v2 tag
+ * is dropped. A transport that v1 cannot express is rejected rather than
+ * silently left out of the session.
+ */
+function v1McpServer(server) {
+    if (v2.McpServer.isStdio(server)) {
+        const { name, command, args, env, _meta } = server;
+        return { name, command, args: args ?? [], env: env ?? [], ...(_meta != null ? { _meta } : {}) };
+    }
+    if (v2.McpServer.isHttp(server)) {
+        return { ...server, headers: server.headers ?? [] };
+    }
+    if (v2.McpServer.isAcp(server)) {
+        return server;
+    }
+    throw RequestError.invalidParams({ type: server.type }, `MCP servers of type ${server.type} are not supported`);
+}

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.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",
@@ -65,8 +65,8 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "1.6.0",
-    "@anthropic-ai/claude-agent-sdk": "0.3.286",
+    "@agentclientprotocol/sdk": "1.7.0",
+    "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "diff": "9.0.0",
     "zod": "4.6.5"
   },