@agentclientprotocol/claude-agent-acp 0.95.1-preview.1 → 0.95.1-preview.3

package/dist/subagent-replay.js

@@ -1,8 +1,9 @@
-import { HANDBACK_TOOL, handbackMessage, isNativeSubagentControlTool, launchReply, linkedSessionMessages, nativeSubagentState, rfdEndState, rfdLabels, } from "./native-subagents.js";
+import { childModelOption, HANDBACK_TOOL, handbackMessage, isNativeSubagentControlTool, launchReply, linkedSessionMessages, nativeSubagentState, responseModelEntry, rfdEndState, rfdLabels, } from "./native-subagents.js";
 import { noticeUpdate } from "./session-notices.js";
 export class RfdSubagentReplay {
     history;
     publish;
+    models;
     /** The children by the id of the tool use that launched each. */
     children = new Map();
     byAgentId = new Map();
@@ -13,9 +14,10 @@ export class RfdSubagentReplay {
     withoutHistory = 0;
     /** The SubagentHandback calls, with their report and whether their result failed. */
     handbacks = new Map();
-    constructor(history, publish) {
+    constructor(history, publish, models) {
         this.history = history;
         this.publish = publish;
+        this.models = models;
     }
     /**
      * Registers the launches, the launch results, and the SendMessage calls in
@@ -41,7 +43,8 @@ export class RfdSubagentReplay {
                                 to: input.to,
                                 message: input.message,
                                 senderSessionId: ownerSessionId,
-                                delivered: false,
+                                shownAsToolCall: false,
+                                outgoingSent: false,
                             });
                         }
                     }
@@ -63,8 +66,12 @@ export class RfdSubagentReplay {
     childOfLaunch(toolUseId) {
         return this.children.get(toolUseId);
     }
-    /** Announces `child` on its parent, as live: running, with the parent's labels. */
-    async announce(child) {
+    /**
+     * Announces `child` on its parent, as live: running, with the parent's
+     * labels. Then it sends `firstModel`, the model of the child's first
+     * response, when the transcript has one.
+     */
+    async announce(child, firstModel) {
         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);
@@ -79,6 +86,30 @@ export class RfdSubagentReplay {
             },
         });
         child.announced = true;
+        await this.responseModel(child, firstModel);
+    }
+    /**
+     * Takes the model of a replayed response of the child `owner`. A child
+     * whose model changes gets its `model` option again.
+     */
+    async responseModel(owner, model) {
+        const entry = responseModelEntry(model, this.models);
+        if (!entry || !owner.announced)
+            return;
+        owner.responseModel = model;
+        await this.sendModel(owner, entry);
+    }
+    async sendModel(child, model) {
+        if (child.model?.value === model.value && child.model.name === model.name)
+            return;
+        child.model = model;
+        await this.publish({
+            sessionId: child.sessionId,
+            update: {
+                sessionUpdate: "config_option_update",
+                configOptions: [childModelOption(model)],
+            },
+        });
     }
     /**
      * The rest of a child's user message to replay, or `null` when nothing is
@@ -119,15 +150,30 @@ export class RfdSubagentReplay {
     /**
      * Takes a replayed update of a tool call, from the transcript of `owner`
      * when it is a child's. Returns whether the client is not shown it: an
-     * update of the launch of a child that the replay shows, or of a successful
+     * update of the launch of a child that the replay shows, of a SendMessage
+     * call whose message the replay already delivered, or of a successful
      * SubagentHandback call of `owner`. A foreground launch's completed result
-     * goes out as the child's reply, and a hand-back as the child's message to
-     * its parent.
+     * goes out as the child's reply, a delivered SendMessage as the sender's
+     * outgoing message, and a hand-back as the child's message to its parent.
      */
     async toolCallUpdate(update, owner) {
         if (update.sessionUpdate !== "tool_call" && update.sessionUpdate !== "tool_call_update") {
             return false;
         }
+        const sendMessage = this.sendMessages.find((call) => call.toolUseId === update.toolCallId);
+        if (sendMessage) {
+            if (sendMessage.recipientSessionId === undefined) {
+                sendMessage.shownAsToolCall = true;
+                return false;
+            }
+            if (!sendMessage.outgoingSent) {
+                sendMessage.outgoingSent = true;
+                const [outgoing] = linkedSessionMessages(sendMessage.toolUseId, sendMessage.senderSessionId, sendMessage.recipientSessionId, sendMessage.message);
+                if (outgoing)
+                    await this.publish(outgoing);
+            }
+            return true;
+        }
         const handback = owner ? this.handbacks.get(update.toolCallId) : undefined;
         if (owner && handback && !handback.failed) {
             if (!handback.sent) {
@@ -205,21 +251,37 @@ export class RfdSubagentReplay {
      * can be cancelled, as live. Any other child cannot be running, because the
      * process that ran it is gone, so its replayed end is its current state.
      */
-    currentStates(live) {
+    currentStates(live, liveConfiguration) {
         return [...this.children.values()]
             .filter((child) => child.announced)
-            .map((child) => {
+            .flatMap((child) => {
             const liveState = live(child.sessionId);
             const state = liveState === undefined || liveState === "idle" ? endState(child) : { state: liveState };
-            return {
-                sessionId: child.parentSessionId,
-                update: {
-                    sessionUpdate: "subagent_update",
-                    sessionId: child.sessionId,
-                    ...(liveState !== undefined ? { capabilities: { cancel: {} } } : {}),
-                    state,
+            // The session's model list may be known only now, after the load response.
+            const entry = responseModelEntry(child.responseModel, this.models);
+            const replayed = child.model ? JSON.stringify([childModelOption(child.model)]) : undefined;
+            const current = liveConfiguration?.(child.sessionId) ?? (entry ? [childModelOption(entry)] : undefined);
+            // A configuration that the replay already sent does not go again.
+            const configOptions = current && JSON.stringify(current) !== replayed ? current : undefined;
+            return [
+                {
+                    sessionId: child.parentSessionId,
+                    update: {
+                        sessionUpdate: "subagent_update",
+                        sessionId: child.sessionId,
+                        ...(liveState !== undefined ? { capabilities: { cancel: {} } } : {}),
+                        state,
+                    },
                 },
-            };
+                ...(configOptions
+                    ? [
+                        {
+                            sessionId: child.sessionId,
+                            update: { sessionUpdate: "config_option_update", configOptions },
+                        },
+                    ]
+                    : []),
+            ];
         });
     }
     registerLaunch(toolUseId, input, parentSessionId) {
@@ -256,21 +318,26 @@ export class RfdSubagentReplay {
      * 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.
+     * Unless the replay already showed the call as a tool call, the message
+     * replaces it, so this view names the sender's view, which goes out at the
+     * call (see {@link toolCallUpdate}).
      */
     async sendDelivery(child, message, text) {
         const names = [child.sessionId, child.record.name, child.input.name];
-        const call = this.sendMessages.find((candidate) => !candidate.delivered &&
+        const call = this.sendMessages.find((candidate) => candidate.recipientSessionId === undefined &&
             names.includes(candidate.to) &&
             text.includes(candidate.message.trim()));
         if (call) {
-            call.delivered = true;
-            await this.sendMessage(child, call.toolUseId, call.message, call.senderSessionId);
+            call.recipientSessionId = child.sessionId;
+            await this.sendMessage(child, call.toolUseId, call.message, call.senderSessionId, {
+                linked: !call.shownAsToolCall,
+            });
         }
         else {
             await this.sendMessage(child, message.uuid, text, undefined);
         }
     }
-    async sendMessage(child, messageId, text, sender) {
+    async sendMessage(child, messageId, text, sender, { linked = false } = {}) {
         await this.publish({
             sessionId: child.sessionId,
             update: {
@@ -278,11 +345,23 @@ export class RfdSubagentReplay {
                 messageId,
                 ...(sender ? { senderSessionId: sender } : {}),
                 recipientSessionId: child.sessionId,
+                ...(linked ? { senderMessageId: messageId } : {}),
                 content: [{ type: "text", text }],
             },
         });
     }
 }
+/** The model of the first response in `messages`, a subagent's transcript. */
+export function firstResponseModel(messages) {
+    for (const message of messages) {
+        if (message.type !== "assistant")
+            continue;
+        const model = message.message?.model;
+        if (typeof model === "string" && model && model !== "<synthetic>")
+            return model;
+    }
+    return undefined;
+}
 /**
  * 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.

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.95.1-preview.1",
+  "version": "0.95.1-preview.3",
   "description": "An ACP-compatible coding agent powered by the Claude Agent SDK (TypeScript)",
   "main": "dist/lib.js",
   "types": "dist/lib.d.ts",