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

package/dist/settings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../src/settings.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,QAAQ,EACd,MAAM,gCAAgC,CAAC;AA0BxC,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,MAAM,CAAC,EAAE;QAAE,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;QAAC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAA;KAAE,CAAC;CAC7E;AAED;;;;;;;;GAQG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,mBAAmB,CAAgB;IAC3C,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,QAAQ,CAAC,CAAa;IAC9B,OAAO,CAAC,MAAM,CAAqE;IACnF,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA8C;IACnE,OAAO,CAAC,WAAW,CAA8B;gBAErC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB;IAMzD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAmBjC;;;OAGG;IACH,OAAO,CAAC,eAAe;IASvB;;;OAGG;YACW,eAAe;IAe7B;;OAEG;IACH,OAAO,CAAC,aAAa;IAyBrB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAqB5B;;OAEG;IACH,WAAW,IAAI,QAAQ;IAIvB;;;OAGG;IACH,sBAAsB,IAAI,MAAM,EAAE;IAIlC;;OAEG;IACH,MAAM,IAAI,MAAM;IAIhB;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUxC;;OAEG;IACH,OAAO,IAAI,IAAI;CAehB"}
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../src/settings.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,QAAQ,EACd,MAAM,gCAAgC,CAAC;AA0BxC,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,MAAM,CAAC,EAAE;QAAE,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;QAAC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAA;KAAE,CAAC;CAC7E;AAED;;;;;;;;GAQG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,mBAAmB,CAAgB;IAC3C,OAAO,CAAC,mBAAmB,CAAC,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,QAAQ,CAAC,CAAa;IAC9B,OAAO,CAAC,MAAM,CAAqE;IACnF,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA8C;IACnE,OAAO,CAAC,WAAW,CAA8B;gBAErC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB;IAMzD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAmBjC;;;OAGG;IACH,OAAO,CAAC,eAAe;IASvB;;;OAGG;YACW,eAAe;IAoB7B;;OAEG;IACH,OAAO,CAAC,aAAa;IAyBrB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAqB5B;;OAEG;IACH,WAAW,IAAI,QAAQ;IAIvB;;;OAGG;IACH,eAAe,CAAC,gBAAgB,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS;IAMhE;;;OAGG;IACH,sBAAsB,IAAI,MAAM,EAAE;IAIlC;;OAEG;IACH,MAAM,IAAI,MAAM;IAIhB;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUxC;;OAEG;IACH,OAAO,IAAI,IAAI;CAehB"}

package/dist/settings.js

@@ -38,6 +38,7 @@ export class SettingsManager {
     cwd;
     effective = {};
     managedDeniedModels = [];
+    managedApiKeyHelper;
     watchers = [];
     onChange;
     logger;
@@ -94,11 +95,16 @@ export class SettingsManager {
             this.managedDeniedModels = resolved.sources
                 .filter((entry) => entry.source === "managed")
                 .flatMap((entry) => entry.settings.deniedModels ?? []);
+            this.managedApiKeyHelper =
+                resolved.provenance.apiKeyHelper?.source === "managed"
+                    ? resolved.effective.apiKeyHelper
+                    : undefined;
         }
         catch (error) {
             this.logger.error("Failed to resolve settings:", error);
             this.effective = {};
             this.managedDeniedModels = [];
+            this.managedApiKeyHelper = undefined;
         }
     }
     /**
@@ -155,6 +161,13 @@ export class SettingsManager {
     getSettings() {
         return this.effective;
     }
+    /**
+     * The `apiKeyHelper` the CLI runs: managed settings outrank the `--settings`
+     * override, which outranks the user/project/local files.
+     */
+    getApiKeyHelper(settingsOverride) {
+        return (this.managedApiKeyHelper ?? settingsOverride?.apiKeyHelper ?? this.effective.apiKeyHelper);
+    }
     /**
      * `deniedModels` entries from the managed tier, the only tier the CLI
      * honors them from.

package/dist/subagent-history.d.ts

@@ -1,7 +1,23 @@
+import { type SessionMessage } from "@anthropic-ai/claude-agent-sdk";
+/** What the metadata file of a subagent says about it. */
+export interface SubagentRecord {
+    /** The SDK agent id, the name of its transcript. */
+    agentId: string;
+    /** The `name` that the Agent call gave it. */
+    name?: string;
+    /** Its role, the `subagent_type` of the Agent call. */
+    agentType?: string;
+    /** The short `description` of the Agent call. */
+    description?: string;
+    /** Whether the Agent call ran it in the background. */
+    background: boolean;
+    /** Whether the user stopped it. */
+    stoppedByUser: boolean;
+}
 /** Where the subagent transcripts of a session are. */
 export interface SubagentHistory {
-    /** The subagent id of each Agent or Task tool use that launched a subagent. */
-    ids: Map<string, string>;
+    /** The subagent of each Agent or Task tool use that launched one. */
+    agents: Map<string, SubagentRecord>;
     /**
      * The project directory of the session, as the SDK takes it in `dir`. With
      * it, the SDK reads a subagent transcript without a search of every project.
@@ -17,4 +33,13 @@ export interface SubagentHistory {
  * The ids are empty for a session without a local transcript.
  */
 export declare function subagentHistory(sessionId: string): Promise<SubagentHistory>;
+/**
+ * The transcript of the subagent `agentId` of a session, or an empty list
+ * when it cannot be read. With the project directory, the SDK skips its
+ * search of every project; a session opened from another directory falls
+ * back to that search.
+ */
+export declare function readSubagentMessages(sessionId: string, agentId: string, history: SubagentHistory, logger: {
+    error(...args: unknown[]): void;
+}): Promise<SessionMessage[]>;
 //# sourceMappingURL=subagent-history.d.ts.map

package/dist/subagent-history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subagent-history.d.ts","sourceRoot":"","sources":["../src/subagent-history.ts"],"names":[],"mappings":"AAKA,uDAAuD;AACvD,MAAM,WAAW,eAAe;IAC9B,+EAA+E;IAC/E,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzB;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CA6BjF"}
+{"version":3,"file":"subagent-history.d.ts","sourceRoot":"","sources":["../src/subagent-history.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,gCAAgC,CAAC;AAKxC,0DAA0D;AAC1D,MAAM,WAAW,cAAc;IAC7B,oDAAoD;IACpD,OAAO,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uDAAuD;IACvD,UAAU,EAAE,OAAO,CAAC;IACpB,mCAAmC;IACnC,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,uDAAuD;AACvD,MAAM,WAAW,eAAe;IAC9B,qEAAqE;IACrE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACpC;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAwCjF;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE;IAAE,KAAK,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;CAAE,GAC1C,OAAO,CAAC,cAAc,EAAE,CAAC,CAW3B"}

package/dist/subagent-history.js

@@ -1,4 +1,4 @@
-import { getSessionInfo } from "@anthropic-ai/claude-agent-sdk";
+import { getSessionInfo, getSubagentMessages, } from "@anthropic-ai/claude-agent-sdk";
 import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { findTranscript } from "./resumed-session.js";
@@ -11,17 +11,17 @@ import { findTranscript } from "./resumed-session.js";
  * The ids are empty for a session without a local transcript.
  */
 export async function subagentHistory(sessionId) {
-    const ids = new Map();
+    const agents = new Map();
     const transcript = await findTranscript(sessionId);
     if (!transcript)
-        return { ids };
+        return { agents };
     const directory = path.join(path.dirname(transcript), sessionId, "subagents");
     let names;
     try {
         names = await readdir(directory);
     }
     catch {
-        return { ids };
+        return { agents };
     }
     await Promise.all(names.map(async (name) => {
         const match = /^agent-(.+)\.meta\.json$/.exec(name);
@@ -29,18 +29,46 @@ export async function subagentHistory(sessionId) {
             return;
         try {
             const meta = JSON.parse(await readFile(path.join(directory, name), "utf8"));
-            const toolUseId = meta?.toolUseId;
-            if (typeof toolUseId === "string")
-                ids.set(toolUseId, match[1]);
+            if (typeof meta?.toolUseId !== "string")
+                return;
+            const text = (value) => (typeof value === "string" ? value : undefined);
+            agents.set(meta.toolUseId, {
+                agentId: match[1],
+                name: text(meta.name),
+                agentType: text(meta.agentType),
+                description: text(meta.description),
+                background: meta.requestShape === "background",
+                stoppedByUser: meta.stoppedByUser === true,
+            });
         }
         catch {
             // A damaged meta file leaves its subagent without history.
         }
     }));
-    if (ids.size === 0)
-        return { ids };
+    if (agents.size === 0)
+        return { agents };
     // The folder name encodes the project directory, and the encoding loses
     // characters. The session info reads it back from the transcript.
     const dir = (await getSessionInfo(sessionId).catch(() => undefined))?.cwd;
-    return dir ? { ids, dir } : { ids };
+    return dir ? { agents, dir } : { agents };
+}
+/**
+ * The transcript of the subagent `agentId` of a session, or an empty list
+ * when it cannot be read. With the project directory, the SDK skips its
+ * search of every project; a session opened from another directory falls
+ * back to that search.
+ */
+export async function readSubagentMessages(sessionId, agentId, history, logger) {
+    try {
+        if (history.dir) {
+            const messages = await getSubagentMessages(sessionId, agentId, { dir: history.dir });
+            if (messages.length > 0)
+                return messages;
+        }
+        return await getSubagentMessages(sessionId, agentId);
+    }
+    catch (error) {
+        logger.error(`Failed to read the history of subagent ${agentId}:`, error);
+        return [];
+    }
 }

package/dist/subagent-replay.d.ts

@@ -0,0 +1,108 @@
+/**
+ * The replay of subagents to a client on the subagents RFD form.
+ *
+ * Claude Code keeps each subagent's history in its own transcript, and the
+ * subagent's metadata file names the Agent or Task call that launched it (see
+ * `subagentHistory`). The replay announces each child right after that call,
+ * under the session id it had live, the SDK agent id, and sends the child's
+ * history to the child session. Every child's end goes out before the replay
+ * ends, since no subagent from before the reload still runs.
+ *
+ * A launch without metadata has no known id, so it is not announced: the RFD
+ * forbids inventing one. Its Agent call stays an ordinary tool call of the
+ * parent, and a notice says that subagent history is missing.
+ */
+import type { SessionMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { AcpSessionNotification, SubagentState } from "./acp-subagents.js";
+import type { SubagentHistory, SubagentRecord } from "./subagent-history.js";
+type Publish = (notification: AcpSessionNotification) => Promise<void>;
+/** A child that the replay shows: its launch has metadata. */
+export type ReplayChild = {
+    /** The Agent or Task tool use that launched it. */
+    launchId: string;
+    /** Its session id: the SDK agent id, as live. */
+    sessionId: string;
+    record: SubagentRecord;
+    /** The session that made the launch. */
+    parentSessionId: string;
+    /** The input of the launch call. */
+    input: Record<string, unknown>;
+    /** How the launch's tool result ended a foreground child's run. */
+    launchEnd?: SubagentState;
+    /** The state of the child's last persisted task notification. */
+    notified?: SubagentState;
+    announced: boolean;
+    promptSent: boolean;
+};
+export declare class RfdSubagentReplay {
+    private readonly history;
+    private readonly publish;
+    /** The children by the id of the tool use that launched each. */
+    private readonly children;
+    private readonly byAgentId;
+    private readonly sendMessages;
+    /** Launches without metadata, which the replay leaves out. */
+    private readonly omitted;
+    /** Children whose transcript could not be read: only their association is replayed. */
+    private withoutHistory;
+    constructor(history: SubagentHistory, publish: Publish);
+    /**
+     * Registers the launches, the launch results, and the SendMessage calls in
+     * `messages`, the transcript of the session `ownerSessionId`.
+     */
+    scan(messages: readonly SessionMessage[], ownerSessionId: string): void;
+    /** The child that the tool use `toolUseId` launched, when the replay shows it. */
+    childOfLaunch(toolUseId: string): ReplayChild | undefined;
+    /** Announces `child` on its parent, as live: running, with the parent's labels. */
+    announce(child: ReplayChild): Promise<void>;
+    /**
+     * The rest of a child's user message to replay, or `null` when nothing is
+     * left, after its text went out as the child's incoming `session_message`.
+     *
+     * A child session has no user, so the text of its user messages is never a
+     * user message. The first text is the prompt of the launch. A message that
+     * a SendMessage call delivered (`origin.kind: "coordinator"`) is another
+     * incoming message. Any other text is harness text, such as "[Request
+     * interrupted by user for tool use]", which the live child session does not
+     * show. Tool results stay.
+     */
+    childContent(child: ReplayChild, message: SessionMessage, content: unknown): Promise<unknown>;
+    /**
+     * Ends the replay of `child`'s history. `messages` is its transcript: when
+     * it is empty, the replay has only the child's association, and the prompt
+     * comes from the launch call.
+     */
+    childReplayed(child: ReplayChild, messages: readonly SessionMessage[]): Promise<void>;
+    /**
+     * Takes a persisted task notification. Returns whether it was a child's:
+     * its task id is the agent id.
+     */
+    taskNotification(taskId: string, status: string): boolean;
+    /**
+     * Sends the end of every announced child, and a notice when subagent history
+     * is missing. The end is the state of the child's last task notification,
+     * else `cancelled` for a child the user stopped, else the result of its
+     * foreground launch, else `idle` with no stop reason.
+     */
+    finish(supportsNotices: boolean, rootSessionId: string): Promise<void>;
+    private registerLaunch;
+    /** The prompt of the launch, with the launch's id, as live. */
+    private sendPrompt;
+    /**
+     * A message that a SendMessage call delivered. Claude Code frames it for the
+     * child's model ("The coordinator sent a message while you were working:",
+     * then the message, then an instruction), so the call it came from is the
+     * first undelivered SendMessage to the child whose message the delivered
+     * text contains. With that call, the message has the call's id and text and
+     * its sender, as live; without it, its transcript id and the delivered text.
+     */
+    private sendDelivery;
+    private sendMessage;
+}
+/**
+ * The end of a foreground launch from its tool result: an error result that
+ * names a stop is a cancellation, any other error a failure.
+ */
+export declare function replaySubagentTerminalState(block: Record<string, unknown>): "completed" | "failed" | "cancelled";
+export {};
+//# sourceMappingURL=subagent-replay.d.ts.map

package/dist/subagent-replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-replay.d.ts","sourceRoot":"","sources":["../src/subagent-replay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAShF,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE7E,KAAK,OAAO,GAAG,CAAC,YAAY,EAAE,sBAAsB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEvE,8DAA8D;AAC9D,MAAM,MAAM,WAAW,GAAG;IACxB,mDAAmD;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,cAAc,CAAC;IACvB,wCAAwC;IACxC,eAAe,EAAE,MAAM,CAAC;IACxB,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,mEAAmE;IACnE,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,iEAAiE;IACjE,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAUF,qBAAa,iBAAiB;IAW1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAX1B,iEAAiE;IACjE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAC3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkC;IAC5D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyB;IACtD,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,uFAAuF;IACvF,OAAO,CAAC,cAAc,CAAK;gBAGR,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,OAAO;IAGnC;;;OAGG;IACH,IAAI,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI;IA6BvE,kFAAkF;IAClF,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAIzD,mFAAmF;IAC7E,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBjD;;;;;;;;;;OAUG;IACG,YAAY,CAChB,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,OAAO,CAAC;IAanB;;;;OAIG;IACG,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,cAAc,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAO3F;;;OAGG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO;IAOzD;;;;;OAKG;IACG,MAAM,CAAC,eAAe,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B5E,OAAO,CAAC,cAAc;IAwBtB,+DAA+D;YACjD,UAAU;IAKxB;;;;;;;OAOG;YACW,YAAY;YAoBZ,WAAW;CAiB1B;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,WAAW,GAAG,QAAQ,GAAG,WAAW,CAMtC"}

package/dist/subagent-replay.js

@@ -0,0 +1,261 @@
+import { isNativeSubagentControlTool, nativeSubagentState, rfdEndState, rfdLabels, } from "./native-subagents.js";
+import { noticeUpdate } from "./session-notices.js";
+export class RfdSubagentReplay {
+    history;
+    publish;
+    /** The children by the id of the tool use that launched each. */
+    children = new Map();
+    byAgentId = new Map();
+    sendMessages = [];
+    /** Launches without metadata, which the replay leaves out. */
+    omitted = new Set();
+    /** Children whose transcript could not be read: only their association is replayed. */
+    withoutHistory = 0;
+    constructor(history, publish) {
+        this.history = history;
+        this.publish = publish;
+    }
+    /**
+     * Registers the launches, the launch results, and the SendMessage calls in
+     * `messages`, the transcript of the session `ownerSessionId`.
+     */
+    scan(messages, ownerSessionId) {
+        for (const message of messages) {
+            for (const block of contentBlocks(message)) {
+                if (block.type === "tool_use" && typeof block.id === "string") {
+                    if (isNativeSubagentControlTool(block.name)) {
+                        this.registerLaunch(block.id, inputOf(block), ownerSessionId);
+                    }
+                    else if (block.name === "SendMessage") {
+                        const input = inputOf(block);
+                        if (typeof input.to === "string" && typeof input.message === "string") {
+                            this.sendMessages.push({
+                                toolUseId: block.id,
+                                to: input.to,
+                                message: input.message,
+                                senderSessionId: ownerSessionId,
+                                delivered: false,
+                            });
+                        }
+                    }
+                }
+                else if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+                    const child = this.children.get(block.tool_use_id);
+                    // A background launch answers at once; its result is not the end.
+                    if (child && !child.record.background) {
+                        child.launchEnd = replaySubagentTerminalState(block);
+                    }
+                }
+            }
+        }
+    }
+    /** The child that the tool use `toolUseId` launched, when the replay shows it. */
+    childOfLaunch(toolUseId) {
+        return this.children.get(toolUseId);
+    }
+    /** Announces `child` on its parent, as live: running, with the parent's labels. */
+    async announce(child) {
+        if (child.announced)
+            return;
+        const labels = rfdLabels(child.record.name ?? child.input.name, child.record.agentType ?? child.input.subagent_type, child.record.description ?? child.input.description);
+        await this.publish({
+            sessionId: child.parentSessionId,
+            update: {
+                sessionUpdate: "subagent_update",
+                sessionId: child.sessionId,
+                ...(labels.title ? { title: labels.title } : {}),
+                ...(labels.description ? { description: labels.description } : {}),
+                state: { state: "running" },
+            },
+        });
+        child.announced = true;
+    }
+    /**
+     * The rest of a child's user message to replay, or `null` when nothing is
+     * left, after its text went out as the child's incoming `session_message`.
+     *
+     * A child session has no user, so the text of its user messages is never a
+     * user message. The first text is the prompt of the launch. A message that
+     * a SendMessage call delivered (`origin.kind: "coordinator"`) is another
+     * incoming message. Any other text is harness text, such as "[Request
+     * interrupted by user for tool use]", which the live child session does not
+     * show. Tool results stay.
+     */
+    async childContent(child, message, content) {
+        const text = textOf(content);
+        if (text.trim()) {
+            if (isDelivery(message))
+                await this.sendDelivery(child, message, text);
+            else if (!child.promptSent)
+                await this.sendPrompt(child, text);
+        }
+        if (!Array.isArray(content))
+            return null;
+        const rest = content.filter((block) => !(typeof block === "object" && block !== null && block.type === "text"));
+        return rest.length > 0 ? rest : null;
+    }
+    /**
+     * Ends the replay of `child`'s history. `messages` is its transcript: when
+     * it is empty, the replay has only the child's association, and the prompt
+     * comes from the launch call.
+     */
+    async childReplayed(child, messages) {
+        if (messages.length === 0)
+            this.withoutHistory++;
+        if (!child.promptSent && typeof child.input.prompt === "string") {
+            await this.sendPrompt(child, child.input.prompt);
+        }
+    }
+    /**
+     * Takes a persisted task notification. Returns whether it was a child's:
+     * its task id is the agent id.
+     */
+    taskNotification(taskId, status) {
+        const child = this.byAgentId.get(taskId);
+        if (!child)
+            return false;
+        child.notified = nativeSubagentState(status) ?? child.notified;
+        return true;
+    }
+    /**
+     * Sends the end of every announced child, and a notice when subagent history
+     * is missing. The end is the state of the child's last task notification,
+     * else `cancelled` for a child the user stopped, else the result of its
+     * foreground launch, else `idle` with no stop reason.
+     */
+    async finish(supportsNotices, rootSessionId) {
+        for (const child of [...this.children.values()].reverse()) {
+            if (!child.announced)
+                continue;
+            const end = child.notified ?? (child.record.stoppedByUser ? "cancelled" : child.launchEnd);
+            const state = end ? rfdEndState(end, undefined) : { state: "idle" };
+            await this.publish({
+                sessionId: child.parentSessionId,
+                update: { sessionUpdate: "subagent_update", sessionId: child.sessionId, state },
+            });
+        }
+        const missing = this.omitted.size + this.withoutHistory;
+        if (missing > 0 && supportsNotices) {
+            await this.publish({
+                sessionId: rootSessionId,
+                update: noticeUpdate({
+                    severity: "info",
+                    title: "Some subagent history is not available",
+                    description: missing === 1
+                        ? "The history of 1 subagent of this session could not be restored."
+                        : `The history of ${missing} subagents of this session could not be restored.`,
+                }),
+            });
+        }
+    }
+    registerLaunch(toolUseId, input, parentSessionId) {
+        if (this.children.has(toolUseId))
+            return;
+        const record = this.history.agents.get(toolUseId);
+        if (!record) {
+            this.omitted.add(toolUseId);
+            return;
+        }
+        const child = {
+            launchId: toolUseId,
+            sessionId: record.agentId,
+            record,
+            parentSessionId,
+            input,
+            announced: false,
+            promptSent: false,
+        };
+        this.children.set(toolUseId, child);
+        this.byAgentId.set(record.agentId, child);
+    }
+    /** The prompt of the launch, with the launch's id, as live. */
+    async sendPrompt(child, text) {
+        child.promptSent = true;
+        await this.sendMessage(child, child.launchId, text, child.parentSessionId);
+    }
+    /**
+     * A message that a SendMessage call delivered. Claude Code frames it for the
+     * child's model ("The coordinator sent a message while you were working:",
+     * then the message, then an instruction), so the call it came from is the
+     * first undelivered SendMessage to the child whose message the delivered
+     * text contains. With that call, the message has the call's id and text and
+     * its sender, as live; without it, its transcript id and the delivered text.
+     */
+    async sendDelivery(child, message, text) {
+        const names = [child.sessionId, child.record.name, child.input.name];
+        const call = this.sendMessages.find((candidate) => !candidate.delivered &&
+            names.includes(candidate.to) &&
+            text.includes(candidate.message.trim()));
+        if (call) {
+            call.delivered = true;
+            await this.sendMessage(child, call.toolUseId, call.message, call.senderSessionId);
+        }
+        else {
+            await this.sendMessage(child, message.uuid, text, undefined);
+        }
+    }
+    async sendMessage(child, messageId, text, sender) {
+        await this.publish({
+            sessionId: child.sessionId,
+            update: {
+                sessionUpdate: "session_message",
+                messageId,
+                ...(sender ? { senderSessionId: sender } : {}),
+                recipientSessionId: child.sessionId,
+                content: [{ type: "text", text }],
+            },
+        });
+    }
+}
+/**
+ * The end of a foreground launch from its tool result: an error result that
+ * names a stop is a cancellation, any other error a failure.
+ */
+export function replaySubagentTerminalState(block) {
+    if (block.is_error !== true)
+        return "completed";
+    const text = replayContentText(block.content).toLowerCase();
+    return /\b(?:cancelled|canceled|interrupted|stopped|killed)\b/.test(text)
+        ? "cancelled"
+        : "failed";
+}
+function replayContentText(value, seen = new Set()) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value !== "object" || value === null || seen.has(value))
+        return "";
+    seen.add(value);
+    if (Array.isArray(value))
+        return value.map((item) => replayContentText(item, seen)).join(" ");
+    const record = value;
+    return [record.text, record.content, record.message]
+        .map((item) => replayContentText(item, seen))
+        .filter(Boolean)
+        .join(" ");
+}
+function contentBlocks(message) {
+    const content = message.message?.content;
+    return Array.isArray(content)
+        ? content.filter((block) => typeof block === "object" && block !== null)
+        : [];
+}
+function inputOf(block) {
+    return typeof block.input === "object" && block.input !== null
+        ? block.input
+        : {};
+}
+/** The text of user message content: a string, or its text blocks. */
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .flatMap((block) => typeof block === "object" && block !== null && block.type === "text" ? [block.text] : [])
+        .filter((text) => typeof text === "string")
+        .join("\n");
+}
+/** A message that a SendMessage call delivered to the child. */
+function isDelivery(message) {
+    return message.origin?.kind === "coordinator";
+}

package/dist/tool-calls/background.d.ts

@@ -20,4 +20,13 @@ import type { SessionNotification } from "@agentclientprotocol/sdk";
  * promise a card state it has no way to ever resolve.
  */
 export declare function backgroundedBashToolCall(notification: SessionNotification, backgroundedToolCallIds: ReadonlySet<string>, asyncTasksSupported: boolean): SessionNotification;
+/**
+ * Keeps the display terminal of a command that went to the background running:
+ * drops `terminal_exit` from the tool result update of `toolCallId`.
+ *
+ * The Bash call returns as soon as the command detaches, so that exit would
+ * mark the terminal as ended while the command still runs. The consumer sends
+ * the exit when the command's task ends (see `Session.backgroundTerminals`).
+ */
+export declare function withRunningTerminal(notification: SessionNotification, toolCallId: string | undefined): SessionNotification;
 //# sourceMappingURL=background.d.ts.map

package/dist/tool-calls/background.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"background.d.ts","sourceRoot":"","sources":["../../src/tool-calls/background.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAGpE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,mBAAmB,EACjC,uBAAuB,EAAE,WAAW,CAAC,MAAM,CAAC,EAC5C,mBAAmB,EAAE,OAAO,GAC3B,mBAAmB,CAgBrB"}
+{"version":3,"file":"background.d.ts","sourceRoot":"","sources":["../../src/tool-calls/background.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAGpE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,mBAAmB,EACjC,uBAAuB,EAAE,WAAW,CAAC,MAAM,CAAC,EAC5C,mBAAmB,EAAE,OAAO,GAC3B,mBAAmB,CAgBrB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,mBAAmB,EACjC,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,mBAAmB,CAiBrB"}

package/dist/tool-calls/background.js

@@ -34,3 +34,28 @@ export function backgroundedBashToolCall(notification, backgroundedToolCallIds,
         },
     };
 }
+/**
+ * Keeps the display terminal of a command that went to the background running:
+ * drops `terminal_exit` from the tool result update of `toolCallId`.
+ *
+ * The Bash call returns as soon as the command detaches, so that exit would
+ * mark the terminal as ended while the command still runs. The consumer sends
+ * the exit when the command's task ends (see `Session.backgroundTerminals`).
+ */
+export function withRunningTerminal(notification, toolCallId) {
+    const update = notification.update;
+    if (toolCallId === undefined ||
+        update.sessionUpdate !== "tool_call_update" ||
+        update.toolCallId !== toolCallId ||
+        !update._meta ||
+        !("terminal_exit" in update._meta)) {
+        return notification;
+    }
+    const meta = { ...update._meta };
+    delete meta.terminal_exit;
+    const next = { ...update, _meta: meta };
+    // An empty `_meta` would clear what a v2 client stores for the tool call.
+    if (Object.keys(meta).length === 0)
+        delete next._meta;
+    return { ...notification, update: next };
+}