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

package/dist/serve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../src/serve.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAC/D,OAAO,EAAc,KAAK,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAI9E;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE;IAAE,cAAc,EAAE,OAAO,CAAA;CAAE,GACnC;IAAE,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAmBrD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GACvC,EAAE,CAAC,mBAAmB,CAKxB"}
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../src/serve.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,0CAA0C,CAAC;AAC/D,OAAO,EAAc,KAAK,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAI9E;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE;IAAE,cAAc,EAAE,OAAO,CAAA;CAAE,GACnC;IAAE,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAkBrD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GACvC,EAAE,CAAC,mBAAmB,CAKxB"}

package/dist/serve.js

@@ -23,8 +23,7 @@ export function serveAcp(logger, options) {
         ? acpProtocolRouter(logger, onAgent).connect(v2.ndJsonStream(output, input))
         : v1AgentApp(logger, onAgent).connect(ndJsonStream(output, input));
     return {
-        // The router types `closed` as optional, but always sets it.
-        closed: closed,
+        closed,
         dispose: async () => {
             await agent?.dispose();
         },

package/dist/v2/agent.d.ts

@@ -1,10 +1,3 @@
-/**
- * The experimental draft ACP v2 surface of the adapter.
- *
- * `ClaudeAcpAgent` speaks ACP v1 types. This surface translates each v2
- * request into the v1 request that the agent serves, and each v1 message that
- * the agent sends into its v2 form, so v1 and v2 share one implementation.
- */
 import * as v2 from "@agentclientprotocol/sdk/experimental/v2";
 import { ClaudeAcpAgent, type Logger } from "../acp-agent.js";
 /**

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

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

package/dist/v2/agent.js

@@ -1,13 +1,8 @@
-/**
- * The experimental draft ACP v2 surface of the adapter.
- *
- * `ClaudeAcpAgent` speaks ACP v1 types. This surface translates each v2
- * request into the v1 request that the agent serves, and each v1 message that
- * the agent sends into its v2 form, so v1 and v2 share one implementation.
- */
 import * as v2 from "@agentclientprotocol/sdk/experimental/v2";
 import { ClaudeAcpAgent } from "../acp-agent.js";
 import { v1InitializeRequest, v2InitializeResponse } from "./initialize.js";
+import { v1NewSessionRequest, v1ResumeSessionRequest, v1SetSessionConfigOptionRequest, v2ConfigOptions, v2NewSessionResponse, v2ResumeSessionResponse, } from "./session.js";
+import { v2SessionUpdate } from "./session-update.js";
 /**
  * The ACP v2 surface, for one connection.
  *
@@ -25,15 +20,23 @@ export function v2AgentApp(logger, onAgent) {
     })
         .onRequest(v2.methods.agent.initialize, async ({ params }) => v2InitializeResponse(await agent.initialize(v1InitializeRequest(params))))
         .onRequest(v2.methods.agent.auth.login, ({ params }) => agent.authenticate(params))
-        .onRequest(v2.methods.agent.auth.logout, ({ params }) => agent.logout(params));
+        .onRequest(v2.methods.agent.auth.logout, ({ params }) => agent.logout(params))
+        .onRequest(v2.methods.agent.session.new, async ({ params }) => v2NewSessionResponse(await agent.newSession(v1NewSessionRequest(params))))
+        .onRequest(v2.methods.agent.session.list, ({ params }) => agent.listSessions(params))
+        .onRequest(v2.methods.agent.session.resume, async ({ params }) => v2ResumeSessionResponse(await agent.resumeSession(v1ResumeSessionRequest(params))))
+        .onRequest(v2.methods.agent.session.close, ({ params }) => agent.closeSession(params))
+        .onRequest(v2.methods.agent.session.delete, ({ params }) => agent.deleteSession(params))
+        .onRequest(v2.methods.agent.session.setConfigOption, async ({ params }) => {
+        const { configOptions, ...response } = await agent.setSessionConfigOption(v1SetSessionConfigOptionRequest(params));
+        return { ...response, configOptions: v2ConfigOptions(configOptions) };
+    });
 }
 /**
  * The {@link AcpClient} of an ACP v2 connection: it sends the v1 messages of
  * the agent as v2 messages.
  *
- * The v2 surface serves no sessions yet, so only connection-level messages
- * reach it, such as the `_auth/status_update` extension notification. Every
- * session-scoped method rejects until the v2 surface serves sessions.
+ * The v2 surface does not serve prompts yet, so permission requests, which
+ * only a prompt turn makes, still reject.
  */
 class V2ClientConnection {
     ctx;
@@ -46,17 +49,28 @@ class V2ClientConnection {
         }
         return this.ctx.notify(method, params);
     }
-    sessionUpdate() {
-        return noV2Sessions("session/update");
+    async sessionUpdate({ update, ...notification }) {
+        const v2Update = v2SessionUpdate(update);
+        if (v2Update) {
+            await this.ctx.notify(v2.methods.client.session.update, {
+                ...notification,
+                update: v2Update,
+            });
+        }
     }
     requestPermission() {
-        return noV2Sessions("session/request_permission");
+        return Promise.reject(new Error("The ACP v2 surface does not serve session/request_permission yet"));
     }
-    createElicitation() {
-        return noV2Sessions("elicitation/create");
+    // Elicitation is the same in v1 and v2.
+    createElicitation(params, signal) {
+        return this.ctx.request(v2.methods.client.elicitation.create, 
+        // The v1 types accept a property schema with any tag; the v2 types accept
+        // one only in a received value. As on v1, an MCP server's schema is
+        // relayed here unchanged, so this cast does not check it.
+        params, { cancellationSignal: signal });
     }
-    completeElicitation() {
-        return noV2Sessions("elicitation/complete");
+    completeElicitation(params) {
+        return this.ctx.notify(v2.methods.client.elicitation.complete, params);
     }
     // v2 has no client file system. The agent never calls these on v2, because
     // `v1InitializeRequest` reports no `fs` capability.
@@ -70,6 +84,3 @@ class V2ClientConnection {
 function isExtensionMethod(method) {
     return method.startsWith("_");
 }
-function noV2Sessions(method) {
-    return Promise.reject(new Error(`The ACP v2 surface does not serve sessions yet (${method})`));
-}

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

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

package/dist/v2/initialize.js

@@ -20,8 +20,10 @@ export function v1InitializeRequest(request) {
             // reads, writes, and runs commands itself.
             fs: { readTextFile: false, writeTextFile: false },
             terminal: false,
-            // Every v2 client handles boolean config options; v1 asks for a marker.
-            session: { configOptions: { boolean: {} } },
+            // Every v2 client handles boolean config options and notices; v1 asks
+            // for a marker. With notices, the agent reports advisories as notices
+            // rather than as transcript messages.
+            session: { configOptions: { boolean: {} }, notices: {} },
             // v1 marks terminal auth support with a boolean, v2 with an object.
             auth: {
                 terminal: capabilities?.auth?.terminal != null,

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

@@ -0,0 +1,15 @@
+/**
+ * The v2 form of the session updates that `ClaudeAcpAgent` sends as v1
+ * updates.
+ */
+import * as v2 from "@agentclientprotocol/sdk/experimental/v2";
+import type { AcpSessionNotification } from "../acp-subagents.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.
+ *
+ * Update kinds that the v2 surface does not translate yet throw, so a gap is
+ * an error rather than a silently missing update.
+ */
+export declare function v2SessionUpdate(update: AcpSessionNotification["update"]): v2.SessionUpdate | undefined;
+//# sourceMappingURL=session-update.d.ts.map

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

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

package/dist/v2/session-update.js

@@ -0,0 +1,27 @@
+import { v2AvailableCommands, v2ConfigOptions } from "./session.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.
+ *
+ * Update kinds that the v2 surface does not translate yet throw, so a gap is
+ * an error rather than a silently missing update.
+ */
+export function v2SessionUpdate(update) {
+    switch (update.sessionUpdate) {
+        case "available_commands_update":
+            return { ...update, availableCommands: v2AvailableCommands(update.availableCommands) };
+        case "config_option_update":
+            return { ...update, configOptions: v2ConfigOptions(update.configOptions) };
+        case "session_info_update":
+        case "usage_update":
+        case "notice":
+            return 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
+            // `configOptions` of a `session/set_config_option` response.
+            return undefined;
+        default:
+            throw new Error(`The ACP v2 surface does not translate ${update.sessionUpdate} session updates yet`);
+    }
+}

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/package.json

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