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

package/dist/v2/prompt.js

@@ -8,27 +8,15 @@ import { RequestError, } from "@agentclientprotocol/sdk";
 import * as v2 from "@agentclientprotocol/sdk/experimental/v2";
 /**
  * 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.
+ * in, with the id of the user message it became. `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 the `error` stop reason and the
- *   JSON-RPC error that v1 answers the prompt with, so a client can show its
- *   message and handle its code as for an error response (for example,
- *   `-32000` starts the client's sign-in).
+ * - Taken in: the prompt's `user_message`, then the answer. From then on, the
+ *   turn is the session's foreground work, which reports its states (see
+ *   {@link v2Foreground}).
  * - 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) => {
@@ -37,37 +25,18 @@ export function v2Prompt(agent, params, send) {
             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"));
-                }
+                if (inserted)
+                    return;
+                reject(outcome.stopReason === "cancelled"
+                    ? RequestError.requestCancelled()
+                    : RequestError.internalError({ stopReason: outcome.stopReason }, "The turn ended before Claude Code took the prompt in"));
             },
             failed(error) {
-                if (!inserted) {
+                if (!inserted)
                     reject(error);
-                    return;
-                }
-                send({
-                    sessionUpdate: "state_update",
-                    state: "idle",
-                    stopReason: "error",
-                    error: jsonRpcError(error),
-                });
             },
         };
         let request;
@@ -81,6 +50,48 @@ export function v2Prompt(agent, params, send) {
         agent.startTurn(request, events).catch(reject);
     });
 }
+/**
+ * Reports the foreground work of a session (see {@link ForegroundEvents}) as
+ * its `state_update`s. `send` delivers a session update of that session, as
+ * for {@link v2Prompt}.
+ *
+ * - Started: `running`. For a prompt's turn, right after its `user_message`.
+ * - 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 work.
+ * - Failed: `idle` with the `error` stop reason and the JSON-RPC error that v1
+ *   answers the prompt with, so a client can show its message and handle its
+ *   code as for an error response (for example, `-32000` starts the client's
+ *   sign-in).
+ *
+ * The work is a prompt's turn or a model cycle that Claude Code started on its
+ * own, such as its follow-up after a background subagent finished. A turn's
+ * work ends at its result, also when v1 holds the turn's answer for the
+ * background subagents it spawned (`Turn.deferredSettle`): v2 allows
+ * background updates while idle, so the subagents' output and requests arrive
+ * after `idle`, and their follow-up is a cycle of its own.
+ */
+export function v2Foreground(send) {
+    return {
+        running() {
+            send({ sessionUpdate: "state_update", state: "running" });
+        },
+        awaitingUser() {
+            send({ sessionUpdate: "state_update", state: "requires_action" });
+        },
+        ended(outcome) {
+            send(idle(outcome));
+        },
+        failed(error) {
+            send({
+                sessionUpdate: "state_update",
+                state: "idle",
+                stopReason: "error",
+                error: jsonRpcError(error),
+            });
+        },
+    };
+}
 /** The JSON-RPC error that v1 answers a failed prompt with. */
 function jsonRpcError(error) {
     if (error instanceof RequestError) {

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

@@ -18,4 +18,15 @@ export declare const SESSION_PLAN_ID = "plan";
  * an error rather than a silently missing update.
  */
 export declare function v2SessionUpdate(update: AcpSessionNotification["update"]): v2.SessionUpdate | undefined;
+/**
+ * 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 declare function v2ChildStateUpdate(update: AcpSessionNotification["update"]): v2.UpdateSessionNotification | undefined;
 //# sourceMappingURL=session-update.d.ts.map

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;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,CA0C9B"}
+{"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,CAyD9B;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,sBAAsB,CAAC,QAAQ,CAAC,GACvC,EAAE,CAAC,yBAAyB,GAAG,SAAS,CAM1C"}

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.2",
+  "version": "0.89.2-preview.20",
   "description": "An ACP-compatible coding agent powered by the Claude Agent SDK (TypeScript)",
   "main": "dist/lib.js",
   "types": "dist/lib.d.ts",