@agentclientprotocol/claude-agent-acp 0.89.2-preview.8 → 0.90.0

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.8",
+  "version": "0.90.0",
   "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"
   }
 }