@agentclientprotocol/claude-agent-acp 0.89.2-preview.9 → 0.90.1-preview.1

package/dist/v2/session-update.js

@@ -45,6 +45,21 @@ export function v2SessionUpdate(update) {
                 plan: { type: "items", planId: SESSION_PLAN_ID, entries: update.entries },
                 ...(update._meta != null ? { _meta: update._meta } : {}),
             };
+        case "plan_update":
+        case "plan_removed":
+            // v1's draft plan operations have v2's shape.
+            return update;
+        case "subagent_update": {
+            // The subagents RFD gives it the same shape in v1 and v2. One that
+            // reports a state also has a copy on the child's stream (see
+            // `v2ChildStateUpdate`).
+            const { state, ...association } = update;
+            return { ...association, ...(state != null ? { state: v2SubagentState(state) } : {}) };
+        }
+        case "session_message":
+        case "session_message_chunk":
+            // The subagents RFD gives these the same shape in v1 and v2.
+            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
@@ -54,3 +69,55 @@ export function v2SessionUpdate(update) {
             throw new Error(`The ACP v2 surface does not translate ${update.sessionUpdate} session updates yet`);
     }
 }
+/**
+ * The child's own `state_update` for a v1 `subagent_update` that reports the
+ * child's work state, or `undefined` when it reports none.
+ *
+ * v1 reports a child's work state only on its parent, as the `state` of the
+ * `subagent_update`. v2 reports it on the child's own stream, as for any
+ * session, and mirrors it on the parent (the subagents RFD). The child's copy
+ * goes right after the parent's: never before the announcement, and both
+ * copies of a state before any later state.
+ */
+export function v2ChildStateUpdate(update) {
+    if (update.sessionUpdate !== "subagent_update" || update.state == null)
+        return undefined;
+    return {
+        sessionId: update.sessionId,
+        update: { sessionUpdate: "state_update", ...v2SubagentState(update.state) },
+    };
+}
+/** The work states of the subagents RFD, and the stop reasons of its `idle`. */
+const SUBAGENT_STATES = new Set([
+    "running",
+    "requires_action",
+    "unknown",
+    "idle",
+]);
+const IDLE_STOP_REASONS = new Set([
+    undefined,
+    null,
+    "end_turn",
+    "max_tokens",
+    "max_turn_requests",
+    "refusal",
+    "cancelled",
+    "error",
+]);
+/**
+ * The v2 form of a subagent's v1 work state.
+ *
+ * The RFD's states have the same shape in v1 and v2. Each version also types
+ * an open member for states and stop reasons it does not know, and those two
+ * members are typed apart. So the state is checked to be one of the RFD's, and
+ * any other throws, as an update kind that this surface does not translate
+ * does.
+ */
+function v2SubagentState(state) {
+    const stopReason = state.stopReason;
+    if (!SUBAGENT_STATES.has(state.state) ||
+        (state.state === "idle" && !IDLE_STOP_REASONS.has(stopReason))) {
+        throw new Error(`The ACP v2 surface does not translate the subagent state ${state.state}${state.state === "idle" ? ` with the stop reason ${String(stopReason)}` : ""}`);
+    }
+    return state;
+}

package/dist/v2/session.d.ts

@@ -23,19 +23,10 @@ export declare function v1RestoreSessionRequest(params: v2.ResumeSessionRequest)
     request: LoadSessionRequest;
 };
 /**
- * The v1 requests that a v2 `session/fork` means.
- *
- * The agent's v1 fork copies the transcript into a new session and returns
- * only its id; a v1 client then resumes or loads it. A v2 fork returns the new
- * session with its config options, like `session/new`, so the client can
- * prompt it. The v2 surface therefore forks, then resumes the fork without
- * replay, with the request's `cwd`, `additionalDirectories`, and
- * `mcpServers`. The request's `_meta` goes to the fork alone.
+ * The v1 request of a v2 `session/fork`. In both versions the agent's fork
+ * returns a session that the client can prompt, with its config options.
  */
-export declare function v1ForkSessionRequests(params: v2.ForkSessionRequest): {
-    fork: ForkSessionRequest;
-    resume: (sessionId: string) => ResumeSessionRequest;
-};
+export declare function v1ForkSessionRequest(params: v2.ForkSessionRequest): ForkSessionRequest;
 /** 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,EACrB,KAAK,kBAAkB,EACvB,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;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,EAAE,CAAC,kBAAkB,GAAG;IACpE,IAAI,EAAE,kBAAkB,CAAC;IACzB,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,oBAAoB,CAAC;CACrD,CAUA;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,EACvB,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;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,EAAE,CAAC,kBAAkB,GAAG,kBAAkB,CAGtF;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

@@ -36,25 +36,12 @@ export function v1RestoreSessionRequest(params) {
     };
 }
 /**
- * The v1 requests that a v2 `session/fork` means.
- *
- * The agent's v1 fork copies the transcript into a new session and returns
- * only its id; a v1 client then resumes or loads it. A v2 fork returns the new
- * session with its config options, like `session/new`, so the client can
- * prompt it. The v2 surface therefore forks, then resumes the fork without
- * replay, with the request's `cwd`, `additionalDirectories`, and
- * `mcpServers`. The request's `_meta` goes to the fork alone.
+ * The v1 request of a v2 `session/fork`. In both versions the agent's fork
+ * returns a session that the client can prompt, with its config options.
  */
-export function v1ForkSessionRequests(params) {
-    const { mcpServers, _meta, ...request } = params;
-    const session = {
-        ...request,
-        ...(mcpServers ? { mcpServers: mcpServers.map(v1McpServer) } : {}),
-    };
-    return {
-        fork: { ...session, ...(_meta != null ? { _meta } : {}) },
-        resume: (sessionId) => ({ ...session, sessionId }),
-    };
+export function v1ForkSessionRequest(params) {
+    const { mcpServers, ...request } = params;
+    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) {

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

@@ -0,0 +1,44 @@
+/**
+ * The `_meta` of the tool calls of one ACP v2 connection, as the client stores
+ * it.
+ *
+ * The agent gives each v1 tool call report the `_meta` keys of that report.
+ * An AIR client merges them by key (see `ToolCallFieldTracker`), and another
+ * v1 client reads them per report. A v2 client stores a tool call's `_meta`,
+ * and a report that carries `_meta` replaces it. So the earlier keys must
+ * travel again, or the `{ toolName }` of a tool's result would replace, for
+ * example, the reason of the denial before it.
+ *
+ * {@link V2ToolCallMeta} therefore keeps the merged `_meta` of each tool call,
+ * with the `claudeCode` keys merged one by one and every other key replaced
+ * whole, as `ToolCallFieldTracker` models it. A report that changes it carries
+ * all of it; a report that changes nothing carries no `_meta`.
+ *
+ * `claudeCode.toolName` repeats the name of the tool, which v2 has a field
+ * for. It becomes the `name` of a tool call that has none yet, and is left out
+ * of the stored `_meta`. Subagent routing reads it before this, on the agent's
+ * v1 reports.
+ */
+import type { ToolCall, ToolCallUpdate } from "@agentclientprotocol/sdk";
+export declare class V2ToolCallMeta {
+    /** The stored `_meta` of each tool call, by session and tool call, oldest first. */
+    private readonly calls;
+    /**
+     * `report` with the tool call's whole `_meta` when the report changes it,
+     * without `_meta` when it does not, and with `name` when it names the tool
+     * call for the first time. `starts` says that the report starts the tool
+     * call (a v1 `tool_call`), which forgets what an earlier one stored.
+     */
+    apply<Report extends ToolCall | ToolCallUpdate>(sessionId: string, report: Report, starts: boolean): Report;
+    /**
+     * The tool call of a permission request's subject: like {@link apply}, but
+     * with the tool call's whole `_meta` even when the subject changes nothing,
+     * since a client can show the request from the request alone.
+     */
+    subject<Report extends ToolCall | ToolCallUpdate>(sessionId: string, toolCall: Report): Report;
+    /** Forgets the tool calls of a session, when it closes. */
+    forget(sessionId: string): void;
+    /** Stores the entry as the most recent one, and forgets the oldest one past the limit. */
+    private remember;
+}
+//# sourceMappingURL=tool-call-meta.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-meta.d.ts","sourceRoot":"","sources":["../../src/v2/tool-call-meta.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAOzE,qBAAa,cAAc;IACzB,oFAAoF;IACpF,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqD;IAE3E;;;;;OAKG;IACH,KAAK,CAAC,MAAM,SAAS,QAAQ,GAAG,cAAc,EAC5C,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,GACd,MAAM;IA6BT;;;;OAIG;IACH,OAAO,CAAC,MAAM,SAAS,QAAQ,GAAG,cAAc,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAO9F,2DAA2D;IAC3D,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAM/B,0FAA0F;IAC1F,OAAO,CAAC,QAAQ;CAQjB"}

package/dist/v2/tool-call-meta.js

@@ -0,0 +1,72 @@
+/** The number of tool calls whose `_meta` a connection remembers. */
+const TOOL_CALL_LIMIT = 2048;
+export class V2ToolCallMeta {
+    /** The stored `_meta` of each tool call, by session and tool call, oldest first. */
+    calls = new Map();
+    /**
+     * `report` with the tool call's whole `_meta` when the report changes it,
+     * without `_meta` when it does not, and with `name` when it names the tool
+     * call for the first time. `starts` says that the report starts the tool
+     * call (a v1 `tool_call`), which forgets what an earlier one stored.
+     */
+    apply(sessionId, report, starts) {
+        const key = `${sessionId} ${report.toolCallId}`;
+        const call = (!starts && this.calls.get(key)) || { meta: {}, named: false };
+        this.remember(key, call);
+        const { _meta, ...fields } = report;
+        const result = fields;
+        const { toolName, ...claudeCode } = asRecord(_meta?.claudeCode) ?? {};
+        if (report.name != null) {
+            call.named = true;
+        }
+        else if (!call.named && typeof toolName === "string") {
+            result.name = toolName;
+            call.named = true;
+        }
+        const meta = { ...call.meta };
+        for (const [name, value] of Object.entries(_meta ?? {})) {
+            if (name !== "claudeCode")
+                meta[name] = value;
+        }
+        if (Object.keys(claudeCode).length > 0) {
+            meta.claudeCode = { ...asRecord(call.meta.claudeCode), ...claudeCode };
+        }
+        if (JSON.stringify(meta) !== JSON.stringify(call.meta)) {
+            call.meta = meta;
+            result._meta = meta;
+        }
+        return result;
+    }
+    /**
+     * The tool call of a permission request's subject: like {@link apply}, but
+     * with the tool call's whole `_meta` even when the subject changes nothing,
+     * since a client can show the request from the request alone.
+     */
+    subject(sessionId, toolCall) {
+        const result = this.apply(sessionId, toolCall, false);
+        const stored = this.calls.get(`${sessionId} ${toolCall.toolCallId}`)?.meta ?? {};
+        if (result._meta === undefined && Object.keys(stored).length > 0)
+            result._meta = stored;
+        return result;
+    }
+    /** Forgets the tool calls of a session, when it closes. */
+    forget(sessionId) {
+        for (const key of this.calls.keys()) {
+            if (key.startsWith(`${sessionId} `))
+                this.calls.delete(key);
+        }
+    }
+    /** Stores the entry as the most recent one, and forgets the oldest one past the limit. */
+    remember(key, call) {
+        this.calls.delete(key);
+        this.calls.set(key, call);
+        if (this.calls.size > TOOL_CALL_LIMIT) {
+            const oldest = this.calls.keys().next().value;
+            if (oldest !== undefined)
+                this.calls.delete(oldest);
+        }
+    }
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.89.2-preview.9",
+  "version": "0.90.1-preview.1",
   "description": "An ACP-compatible coding agent powered by the Claude Agent SDK (TypeScript)",
   "main": "dist/lib.js",
   "types": "dist/lib.d.ts",
@@ -66,25 +66,25 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.8.0",
-    "@anthropic-ai/claude-agent-sdk": "0.3.293",
+    "@anthropic-ai/claude-agent-sdk": "0.3.296",
     "diff": "9.0.0",
-    "zod": "4.6.5"
+    "zod": "4.6.7"
   },
   "devDependencies": {
-    "@anthropic-ai/sdk": "0.132.1",
+    "@anthropic-ai/sdk": "0.133.0",
     "@eslint/js": "10.0.1",
     "@tsconfig/node22": "22.0.6",
-    "@types/node": "26.6.4",
-    "@typescript-eslint/eslint-plugin": "8.71.1",
-    "@typescript-eslint/parser": "8.71.1",
+    "@types/node": "26.6.5",
+    "@typescript-eslint/eslint-plugin": "8.71.2",
+    "@typescript-eslint/parser": "8.71.2",
     "ajv": "8.20.0",
     "ajv-formats": "3.0.1",
     "eslint": "10.12.0",
     "eslint-config-prettier": "10.1.8",
     "globals": "17.13.0",
-    "prettier": "3.9.9",
+    "prettier": "3.9.10",
     "ts-node": "10.9.2",
     "typescript": "6.0.3",
-    "vitest": "5.0.3"
+    "vitest": "5.0.4"
   }
 }