@assistant-ui/react-langchain 0.0.31 → 0.0.32

package/src/useSubagentTranscripts.test.tsx

@@ -2,6 +2,7 @@
 
 import { act, renderHook, waitFor } from "@testing-library/react";
 import { describe, expect, it, vi } from "vitest";
+import type { ThreadMessage } from "@assistant-ui/core";
 import type { LangChainBaseMessage, UIMessage } from "./types";
 
 const { streamController } = vi.hoisted(() => ({
@@ -17,15 +18,15 @@ import {
   useSubagentTranscripts,
 } from "./useSubagentTranscripts";
 
-type FakeStore = {
-  getSnapshot(): LangChainBaseMessage[];
+type FakeStore<T> = {
+  getSnapshot(): T;
   subscribe(listener: () => void): () => void;
   notify(): void;
-  setSnapshot(messages: LangChainBaseMessage[]): void;
+  setSnapshot(snapshot: T): void;
 };
 
-const createStore = (messages: LangChainBaseMessage[] = []): FakeStore => {
-  let snapshot = messages;
+const createFakeStore = <T,>(initial: T): FakeStore<T> => {
+  let snapshot = initial;
   const listeners = new Set<() => void>();
   return {
     getSnapshot: () => snapshot,
@@ -36,13 +37,27 @@ const createStore = (messages: LangChainBaseMessage[] = []): FakeStore => {
     notify() {
       for (const listener of listeners) listener();
     },
-    setSnapshot(messages) {
-      snapshot = messages;
+    setSnapshot(next) {
+      snapshot = next;
       for (const listener of listeners) listener();
     },
   };
 };
 
+const createStore = (messages: LangChainBaseMessage[] = []) =>
+  createFakeStore(messages);
+
+const createUIStore = (events: UIChannelEvent[] = []) =>
+  createFakeStore(events);
+
+const createDeferred = () => {
+  let resolve!: () => void;
+  const promise = new Promise<void>((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+};
+
 const message = (
   id: string,
   type: "human" | "ai",
@@ -59,25 +74,42 @@ const subagent = (
   status: "running" | "complete" | "error" = "running",
   parentId: string | null = null,
   depth = 1,
+  startedAt = new Date(1_000),
+  completedAt: Date | null = status === "running" ? null : new Date(4_000),
 ) => ({
   id,
   namespace,
   status,
   parentId,
   depth,
+  startedAt,
+  completedAt,
 });
 
+const messagesOf = (
+  transcripts: ReadonlyMap<string, { messages: readonly ThreadMessage[] }>,
+  id: string,
+) => transcripts.get(id)?.messages;
+
 const createStream = (
   subagents: ReadonlyMap<string, ReturnType<typeof subagent>>,
-  stores: Map<string, FakeStore>,
+  stores: Map<string, FakeStore<LangChainBaseMessage[]>>,
+  uiStores = new Map<string, FakeStore<UIChannelEvent[]>>(),
 ) => {
   const releases = new Map<string, ReturnType<typeof vi.fn>>();
-  const acquire = vi.fn((spec: { namespace: readonly string[] }) => {
-    const key = spec.namespace.join("/");
-    const release = vi.fn();
-    releases.set(key, release);
-    return { store: stores.get(key)!, release };
-  });
+  const uiReleases = new Map<string, ReturnType<typeof vi.fn>>();
+  const acquire = vi.fn(
+    (spec: { key: string; namespace: readonly string[] }) => {
+      const key = spec.namespace.join("/");
+      const release = vi.fn();
+      if (spec.key.startsWith("channel|")) {
+        uiReleases.set(key, release);
+        return { store: uiStores.get(key) ?? createUIStore(), release };
+      }
+      releases.set(key, release);
+      return { store: stores.get(key)!, release };
+    },
+  );
   const resolveSubagentNamespace = vi.fn(async () => {});
   return {
     subagents,
@@ -87,6 +119,7 @@ const createStream = (
     },
     acquire,
     releases,
+    uiReleases,
     resolveSubagentNamespace,
   };
 };
@@ -101,6 +134,34 @@ const chart = (id: string, messageId: string): UIMessage => ({
   metadata: { message_id: messageId },
 });
 
+type UIChannelEvent = {
+  method: "custom";
+  params: { namespace: readonly string[]; data: unknown };
+};
+
+const uiEvent = (
+  namespace: readonly string[],
+  data: unknown,
+): UIChannelEvent => ({
+  method: "custom",
+  params: { namespace, data },
+});
+
+const nestedSubagents = () =>
+  new Map([
+    ["task-parent", subagent("task-parent", ["tools:parent"])],
+    [
+      "task-child",
+      subagent(
+        "task-child",
+        ["tools:parent", "tools:child"],
+        "running",
+        "task-parent",
+        2,
+      ),
+    ],
+  ]);
+
 describe("useSubagentTranscripts", () => {
   it("acquires each namespace once and releases every projection on unmount", async () => {
     const stores = new Map([
@@ -122,17 +183,139 @@ describe("useSubagentTranscripts", () => {
     hook.rerender();
 
     expect(stream.acquire).toHaveBeenCalledTimes(2);
-    expect(stream.resolveSubagentNamespace).toHaveBeenCalledTimes(2);
+    expect(stream.resolveSubagentNamespace).not.toHaveBeenCalled();
     hook.unmount();
     expect(stream.releases.get("tools:one")).toHaveBeenCalledOnce();
     expect(stream.releases.get("tools:two")).toHaveBeenCalledOnce();
   });
 
+  it("serializes a bounded retry for a later unresolved status", async () => {
+    const stores = new Map([["tools:task-one", createStore()]]);
+    const stream = createStream(
+      new Map([["task-one", subagent("task-one", ["tools:task-one"])]]),
+      stores,
+    );
+    const firstRequest = createDeferred();
+    const secondRequest = createDeferred();
+    stream.resolveSubagentNamespace
+      .mockImplementationOnce(() => firstRequest.promise)
+      .mockImplementationOnce(() => secondRequest.promise);
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, noUIMessages),
+    );
+
+    await waitFor(() =>
+      expect(stream.resolveSubagentNamespace).toHaveBeenCalledOnce(),
+    );
+    act(() => {
+      stream.subagents = new Map([
+        ["task-one", subagent("task-one", ["tools:task-one"])],
+      ]);
+      hook.rerender();
+    });
+    expect(stream.resolveSubagentNamespace).toHaveBeenCalledOnce();
+
+    act(() => {
+      stream.subagents = new Map([
+        ["task-one", subagent("task-one", ["tools:task-one"], "complete")],
+      ]);
+      hook.rerender();
+    });
+    expect(stream.resolveSubagentNamespace).toHaveBeenCalledOnce();
+
+    await act(async () => {
+      firstRequest.resolve();
+    });
+
+    await waitFor(() =>
+      expect(stream.resolveSubagentNamespace).toHaveBeenCalledTimes(2),
+    );
+    act(() => {
+      stream.subagents = new Map([
+        ["task-one", subagent("task-one", ["tools:task-one"], "complete")],
+      ]);
+      hook.rerender();
+    });
+    secondRequest.resolve();
+    await act(() => Promise.resolve());
+    expect(stream.resolveSubagentNamespace).toHaveBeenCalledTimes(2);
+  });
+
+  it("retries only after an unresolved namespace changes status", async () => {
+    const stores = new Map([["tools:task-one", createStore()]]);
+    const stream = createStream(
+      new Map([["task-one", subagent("task-one", ["tools:task-one"])]]),
+      stores,
+    );
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, noUIMessages),
+    );
+
+    await waitFor(() =>
+      expect(stream.resolveSubagentNamespace).toHaveBeenCalledOnce(),
+    );
+    await act(async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+      stream.subagents = new Map([
+        ["task-one", subagent("task-one", ["tools:task-one"])],
+      ]);
+      hook.rerender();
+    });
+    expect(stream.resolveSubagentNamespace).toHaveBeenCalledOnce();
+
+    await act(async () => {
+      stream.subagents = new Map([
+        ["task-one", subagent("task-one", ["tools:task-one"], "complete")],
+      ]);
+      hook.rerender();
+    });
+    await waitFor(() =>
+      expect(stream.resolveSubagentNamespace).toHaveBeenCalledTimes(2),
+    );
+
+    act(() => {
+      stream.subagents = new Map([
+        ["task-one", subagent("task-one", ["tools:task-one"], "complete")],
+      ]);
+      hook.rerender();
+    });
+    expect(stream.resolveSubagentNamespace).toHaveBeenCalledTimes(2);
+  });
+
+  it("retries an initially terminal unresolved namespace once", async () => {
+    const stores = new Map([["tools:task-one", createStore()]]);
+    const stream = createStream(
+      new Map([
+        ["task-one", subagent("task-one", ["tools:task-one"], "complete")],
+      ]),
+      stores,
+    );
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, noUIMessages),
+    );
+
+    await waitFor(() =>
+      expect(stream.resolveSubagentNamespace).toHaveBeenCalledTimes(2),
+    );
+    await act(async () => {
+      await Promise.resolve();
+      stream.subagents = new Map([
+        ["task-one", subagent("task-one", ["tools:task-one"], "complete")],
+      ]);
+      hook.rerender();
+    });
+    expect(stream.resolveSubagentNamespace).toHaveBeenCalledTimes(2);
+  });
+
   it("does not acquire depth-17 subagents and releases projections that move past the depth cap", async () => {
-    const stores = new Map([["tools:one", createStore()]]);
+    const stores = new Map([["tools:task-one", createStore()]]);
     const stream = createStream(
       new Map([
-        ["task-one", subagent("task-one", ["tools:one"], "running", null, 16)],
+        [
+          "task-one",
+          subagent("task-one", ["tools:task-one"], "running", null, 16),
+        ],
       ]),
       stores,
     );
@@ -150,7 +333,7 @@ describe("useSubagentTranscripts", () => {
     hook.rerender();
 
     await waitFor(() =>
-      expect(stream.releases.get("tools:one")).toHaveBeenCalledOnce(),
+      expect(stream.releases.get("tools:task-one")).toHaveBeenCalledOnce(),
     );
     expect(stream.acquire).toHaveBeenCalledOnce();
     expect(stream.resolveSubagentNamespace).toHaveBeenCalledOnce();
@@ -164,9 +347,9 @@ describe("useSubagentTranscripts", () => {
       message("promoted-ai", "ai", "promoted"),
     ]);
     const stream = createStream(
-      new Map([["task-one", subagent("task-one", ["tools:placeholder"])]]),
+      new Map([["task-one", subagent("task-one", ["tools:task-one"])]]),
       new Map([
-        ["tools:placeholder", placeholderStore],
+        ["tools:task-one", placeholderStore],
         ["tools:promoted", promotedStore],
       ]),
     );
@@ -175,9 +358,9 @@ describe("useSubagentTranscripts", () => {
     );
 
     await waitFor(() =>
-      expect(hook.result.current.get("task-one")?.[0]?.content).toMatchObject([
-        { type: "text", text: "placeholder" },
-      ]),
+      expect(
+        messagesOf(hook.result.current, "task-one")?.[0]?.content,
+      ).toMatchObject([{ type: "text", text: "placeholder" }]),
     );
 
     stream.subagents = new Map([
@@ -186,11 +369,11 @@ describe("useSubagentTranscripts", () => {
     hook.rerender();
 
     await waitFor(() =>
-      expect(hook.result.current.get("task-one")?.[0]?.content).toMatchObject([
-        { type: "text", text: "promoted" },
-      ]),
+      expect(
+        messagesOf(hook.result.current, "task-one")?.[0]?.content,
+      ).toMatchObject([{ type: "text", text: "promoted" }]),
     );
-    expect(stream.releases.get("tools:placeholder")).toHaveBeenCalledOnce();
+    expect(stream.releases.get("tools:task-one")).toHaveBeenCalledOnce();
     expect(stream.acquire).toHaveBeenCalledWith(
       expect.objectContaining({ namespace: ["tools:promoted"] }),
     );
@@ -223,9 +406,9 @@ describe("useSubagentTranscripts", () => {
     });
 
     expect(hook.result.current).not.toBe(initial);
-    expect(hook.result.current.get("task-one")?.[0]?.content).toMatchObject([
-      { type: "text", text: "two" },
-    ]);
+    expect(
+      messagesOf(hook.result.current, "task-one")?.[0]?.content,
+    ).toMatchObject([{ type: "text", text: "two" }]);
   });
 
   it("keeps unchanged transcript messages when a projection update replaces one", async () => {
@@ -240,15 +423,15 @@ describe("useSubagentTranscripts", () => {
     );
 
     await waitFor(() =>
-      expect(hook.result.current.get("task-one")).toHaveLength(2),
+      expect(messagesOf(hook.result.current, "task-one")).toHaveLength(2),
     );
-    const initial = hook.result.current.get("task-one");
+    const initial = messagesOf(hook.result.current, "task-one");
 
     await act(async () => {
       store.setSnapshot([question, message("subagent-ai", "ai", "partial")]);
     });
 
-    const updated = hook.result.current.get("task-one");
+    const updated = messagesOf(hook.result.current, "task-one");
     expect(updated).toHaveLength(2);
     expect(updated).not.toBe(initial);
     expect(updated?.[0]).toBe(initial?.[0]);
@@ -273,7 +456,9 @@ describe("useSubagentTranscripts", () => {
     hook.rerender();
 
     await waitFor(() =>
-      expect(hook.result.current.get("task-one")?.[0]?.content).toMatchObject([
+      expect(
+        messagesOf(hook.result.current, "task-one")?.[0]?.content,
+      ).toMatchObject([
         { type: "text", text: "answer" },
         { type: "data", name: "chart", data: { points: [1, 2, 3] } },
       ]),
@@ -309,7 +494,7 @@ describe("useSubagentTranscripts", () => {
     uiMessagesByParent = new Map([["one-ai", [ui]]]);
     hook.rerender();
     await waitFor(() =>
-      expect(hook.result.current.get("task-one")).not.toBe(
+      expect(messagesOf(hook.result.current, "task-one")).not.toBe(
         initial.get("task-one"),
       ),
     );
@@ -332,7 +517,9 @@ describe("useSubagentTranscripts", () => {
     );
 
     await waitFor(() =>
-      expect(hook.result.current.get("task-one")?.[0]?.status).toMatchObject({
+      expect(
+        messagesOf(hook.result.current, "task-one")?.[0]?.status,
+      ).toMatchObject({
         type: "running",
       }),
     );
@@ -343,7 +530,9 @@ describe("useSubagentTranscripts", () => {
     hook.rerender();
 
     await waitFor(() =>
-      expect(hook.result.current.get("task-one")?.[0]?.status).toMatchObject({
+      expect(
+        messagesOf(hook.result.current, "task-one")?.[0]?.status,
+      ).toMatchObject({
         type: "complete",
       }),
     );
@@ -368,16 +557,16 @@ describe("useSubagentTranscripts", () => {
 
     await waitFor(() => expect(hook.result.current.size).toBe(2));
     const initial = hook.result.current;
-    const initialOne = initial.get("task-one");
-    const initialTwo = initial.get("task-two");
+    const initialOne = messagesOf(initial, "task-one");
+    const initialTwo = messagesOf(initial, "task-two");
 
     await act(async () => {
       oneStore.setSnapshot([message("one-ai", "ai", "updated")]);
     });
 
     expect(hook.result.current).not.toBe(initial);
-    expect(hook.result.current.get("task-one")).not.toBe(initialOne);
-    expect(hook.result.current.get("task-two")).toBe(initialTwo);
+    expect(messagesOf(hook.result.current, "task-one")).not.toBe(initialOne);
+    expect(messagesOf(hook.result.current, "task-two")).toBe(initialTwo);
   });
 
   it("nests a child discovered at the same depth as its parent", async () => {
@@ -407,18 +596,19 @@ describe("useSubagentTranscripts", () => {
     );
 
     await waitFor(() => expect(hook.result.current.size).toBe(2));
-    const taskCall = hook.result.current
-      .get("task-parent")?.[0]
-      ?.content.find((part) => part.type === "tool-call");
+    const taskCall = messagesOf(
+      hook.result.current,
+      "task-parent",
+    )?.[0]?.content.find((part) => part.type === "tool-call");
 
     expect(taskCall).toMatchObject({
-      messages: hook.result.current.get("task-child"),
+      messages: messagesOf(hook.result.current, "task-child"),
     });
   });
 
   it("stops attaching descendants past sixteen levels of actual nesting", async () => {
     const subagents = new Map<string, ReturnType<typeof subagent>>();
-    const stores = new Map<string, FakeStore>();
+    const stores = new Map<string, FakeStore<LangChainBaseMessage[]>>();
     const levels = MAX_SUBAGENT_DEPTH + 2;
     for (let level = 1; level <= levels; level += 1) {
       const id = `task-${level}`;
@@ -453,7 +643,7 @@ describe("useSubagentTranscripts", () => {
     );
 
     await waitFor(() => expect(hook.result.current.size).toBe(levels));
-    let transcript = hook.result.current.get("task-1");
+    let transcript = messagesOf(hook.result.current, "task-1");
     let nested = 1;
     while (transcript) {
       const taskCall = transcript[0]?.content.find(
@@ -465,9 +655,10 @@ describe("useSubagentTranscripts", () => {
     }
 
     expect(nested).toBe(MAX_SUBAGENT_DEPTH);
-    const deepest = hook.result.current
-      .get(`task-${MAX_SUBAGENT_DEPTH + 1}`)?.[0]
-      ?.content.find((part) => part.type === "tool-call");
+    const deepest = messagesOf(
+      hook.result.current,
+      `task-${MAX_SUBAGENT_DEPTH + 1}`,
+    )?.[0]?.content.find((part) => part.type === "tool-call");
     expect(deepest).not.toHaveProperty("messages");
   });
 
@@ -504,12 +695,564 @@ describe("useSubagentTranscripts", () => {
     );
 
     await waitFor(() => expect(hook.result.current.size).toBe(2));
-    const parentTranscript = hook.result.current.get("task-parent");
-    const childTranscript = hook.result.current.get("task-child");
+    const parentTranscript = messagesOf(hook.result.current, "task-parent");
+    const childTranscript = messagesOf(hook.result.current, "task-child");
     const taskCall = parentTranscript?.[0]?.content.find(
       (part) => part.type === "tool-call",
     );
 
     expect(taskCall).toMatchObject({ messages: childTranscript });
   });
+  it("renders live UI a subagent pushed from its own nested namespace", async () => {
+    const childStore = createStore([message("child-ai", "ai", "child answer")]);
+    const childUIStore = createUIStore([
+      uiEvent(["tools:parent", "tools:child"], chart("ui-child", "child-ai")),
+      uiEvent(
+        ["tools:parent", "tools:child", "tools:grandchild"],
+        chart("ui-grandchild", "grandchild-ai"),
+      ),
+    ]);
+    const stream = createStream(
+      nestedSubagents(),
+      new Map([
+        [
+          "tools:parent",
+          createStore([message("parent-ai", "ai", "delegating")]),
+        ],
+        ["tools:parent/tools:child", childStore],
+      ]),
+      new Map([["tools:parent/tools:child", childUIStore]]),
+    );
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, noUIMessages),
+    );
+
+    await waitFor(() =>
+      expect(
+        messagesOf(hook.result.current, "task-child")?.[0]?.content,
+      ).toMatchObject([
+        { type: "text", text: "child answer" },
+        { type: "data", name: "chart", data: { points: [1, 2, 3] } },
+      ]),
+    );
+
+    await act(async () => {
+      childUIStore.setSnapshot([
+        uiEvent(["tools:parent", "tools:child"], chart("ui-child", "child-ai")),
+        uiEvent(["tools:parent", "tools:child"], {
+          type: "remove-ui",
+          id: "ui-child",
+        }),
+      ]);
+    });
+
+    expect(
+      messagesOf(hook.result.current, "task-child")?.[0]?.content.some(
+        (part) => part.type === "data",
+      ),
+    ).toBe(false);
+  });
+
+  it("opens a custom projection only for subagents the root channel cannot reach", async () => {
+    const stream = createStream(
+      nestedSubagents(),
+      new Map([
+        ["tools:parent", createStore()],
+        ["tools:parent/tools:child", createStore()],
+      ]),
+    );
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, noUIMessages),
+    );
+
+    await waitFor(() => expect(stream.acquire).toHaveBeenCalledTimes(3));
+    const channelSpecs = stream.acquire.mock.calls
+      .map(([spec]) => spec)
+      .filter((spec) => spec.key.startsWith("channel|"));
+    expect(channelSpecs).toHaveLength(1);
+    expect(channelSpecs[0]?.namespace).toEqual(["tools:parent", "tools:child"]);
+
+    hook.unmount();
+    expect(
+      stream.uiReleases.get("tools:parent/tools:child"),
+    ).toHaveBeenCalledOnce();
+  });
+
+  it("ignores live UI whose message is absent from this transcript", async () => {
+    const childUI = uiEvent(
+      ["tools:parent", "tools:child"],
+      chart("ui-child", "child-ai"),
+    );
+    const childUIStore = createUIStore([childUI]);
+    const stream = createStream(
+      nestedSubagents(),
+      new Map([
+        ["tools:parent", createStore()],
+        [
+          "tools:parent/tools:child",
+          createStore([message("child-ai", "ai", "child answer")]),
+        ],
+      ]),
+      new Map([["tools:parent/tools:child", childUIStore]]),
+    );
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, noUIMessages),
+    );
+
+    await waitFor(() =>
+      expect(
+        messagesOf(hook.result.current, "task-child")?.[0]?.content.some(
+          (part) => part.type === "data",
+        ),
+      ).toBe(true),
+    );
+    const transcript = messagesOf(hook.result.current, "task-child");
+
+    await act(async () => {
+      childUIStore.setSnapshot([
+        childUI,
+        uiEvent(
+          ["tools:parent", "tools:child", "tools:grandchild"],
+          chart("ui-grandchild", "grandchild-ai"),
+        ),
+      ]);
+    });
+
+    expect(messagesOf(hook.result.current, "task-child")).toBe(transcript);
+  });
+
+  it("keeps a nested transcript stable while a streamed UI update repeats", async () => {
+    const streamedChart = (props: Record<string, unknown>): UIMessage => ({
+      type: "ui",
+      id: "ui-child",
+      name: "chart",
+      props,
+      metadata: { message_id: "child-ai", merge: true },
+    });
+    const parentStore = createStore([message("parent-ai", "ai", "delegating")]);
+    const childUIStore = createUIStore([
+      uiEvent(["tools:parent", "tools:child"], streamedChart({ points: [1] })),
+      uiEvent(["tools:parent", "tools:child"], streamedChart({ label: "a" })),
+    ]);
+    const stream = createStream(
+      nestedSubagents(),
+      new Map([
+        ["tools:parent", parentStore],
+        [
+          "tools:parent/tools:child",
+          createStore([message("child-ai", "ai", "child answer")]),
+        ],
+      ]),
+      new Map([["tools:parent/tools:child", childUIStore]]),
+    );
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, noUIMessages),
+    );
+
+    await waitFor(() =>
+      expect(
+        messagesOf(hook.result.current, "task-child")?.[0]?.content.some(
+          (part) => part.type === "data",
+        ),
+      ).toBe(true),
+    );
+    const transcript = messagesOf(hook.result.current, "task-child");
+
+    await act(async () => {
+      parentStore.notify();
+    });
+
+    expect(messagesOf(hook.result.current, "task-child")).toBe(transcript);
+  });
+
+  it("keeps graph state authoritative over a live nested update", async () => {
+    const childUIStore = createUIStore([
+      uiEvent(["tools:parent", "tools:child"], chart("ui-child", "child-ai")),
+    ]);
+    const stream = createStream(
+      nestedSubagents(),
+      new Map([
+        ["tools:parent", createStore()],
+        [
+          "tools:parent/tools:child",
+          createStore([message("child-ai", "ai", "child answer")]),
+        ],
+      ]),
+      new Map([["tools:parent/tools:child", childUIStore]]),
+    );
+    const stateUiMessages = new Map<string, UIMessage[]>([
+      [
+        "child-ai",
+        [
+          {
+            type: "ui",
+            id: "ui-child",
+            name: "chart",
+            props: { points: [9] },
+            metadata: { message_id: "child-ai" },
+          },
+        ],
+      ],
+    ]);
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, stateUiMessages),
+    );
+
+    await waitFor(() =>
+      expect(
+        messagesOf(hook.result.current, "task-child")?.[0]?.content,
+      ).toMatchObject([
+        { type: "text", text: "child answer" },
+        { type: "data", name: "chart", data: { points: [9] } },
+      ]),
+    );
+  });
+
+  it("carries the subagent's wall clock onto its task call", async () => {
+    const parentMessage: LangChainBaseMessage = {
+      id: "parent-ai",
+      _getType: () => "ai",
+      content: "delegating",
+      tool_calls: [{ id: "task-child", name: "task", args: {} }],
+    };
+    const stream = createStream(
+      new Map([
+        ["task-parent", subagent("task-parent", ["tools:parent"])],
+        [
+          "task-child",
+          subagent(
+            "task-child",
+            ["tools:parent", "tools:child"],
+            "running",
+            "task-parent",
+            2,
+            new Date(1_000),
+            null,
+          ),
+        ],
+      ]),
+      new Map([
+        ["tools:parent", createStore([parentMessage])],
+        [
+          "tools:parent/tools:child",
+          createStore([message("child-ai", "ai", "child answer")]),
+        ],
+      ]),
+    );
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, noUIMessages),
+    );
+
+    const taskCall = () =>
+      messagesOf(hook.result.current, "task-parent")?.[0]?.content.find(
+        (part) => part.type === "tool-call",
+      );
+
+    await waitFor(() =>
+      expect(taskCall()).toMatchObject({ timing: { startedAt: 1_000 } }),
+    );
+    expect(taskCall()).not.toHaveProperty("timing.completedAt");
+
+    stream.subagents = new Map([
+      ["task-parent", subagent("task-parent", ["tools:parent"])],
+      [
+        "task-child",
+        subagent(
+          "task-child",
+          ["tools:parent", "tools:child"],
+          "complete",
+          "task-parent",
+          2,
+          new Date(1_000),
+          new Date(4_500),
+        ),
+      ],
+    ]);
+    hook.rerender();
+
+    await waitFor(() =>
+      expect(taskCall()).toMatchObject({
+        timing: { startedAt: 1_000, completedAt: 4_500 },
+      }),
+    );
+  });
+
+  it("records streaming timing for a nested message once its subagent finishes", async () => {
+    const store = createStore([message("child-ai", "ai", "partial")]);
+    const stream = createStream(
+      new Map([
+        [
+          "task-child",
+          subagent(
+            "task-child",
+            ["tools:parent", "tools:child"],
+            "running",
+            null,
+            2,
+          ),
+        ],
+      ]),
+      new Map([["tools:parent/tools:child", store]]),
+    );
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, noUIMessages),
+    );
+
+    await waitFor(() =>
+      expect(messagesOf(hook.result.current, "task-child")).toHaveLength(1),
+    );
+    expect(
+      messagesOf(hook.result.current, "task-child")?.[0]?.metadata,
+    ).not.toHaveProperty("timing");
+
+    await act(async () => {
+      store.setSnapshot([message("child-ai", "ai", "partial answer")]);
+    });
+
+    stream.subagents = new Map([
+      [
+        "task-child",
+        subagent(
+          "task-child",
+          ["tools:parent", "tools:child"],
+          "complete",
+          null,
+          2,
+        ),
+      ],
+    ]);
+    hook.rerender();
+
+    await waitFor(() =>
+      expect(
+        messagesOf(hook.result.current, "task-child")?.[0]?.metadata?.timing,
+      ).toMatchObject({ totalChunks: 2, toolCallCount: 0 }),
+    );
+    const timing = messagesOf(hook.result.current, "task-child")?.[0]?.metadata
+      ?.timing;
+    expect(timing?.tokenCount).toBeGreaterThan(0);
+    expect(timing?.totalStreamTime).toBeGreaterThanOrEqual(0);
+  });
+
+  it("gives a task seeded from a checkpoint no wall clock", async () => {
+    const parentMessage: LangChainBaseMessage = {
+      id: "parent-ai",
+      _getType: () => "ai",
+      content: "delegating",
+      tool_calls: [{ id: "task-child", name: "task", args: {} }],
+    };
+    const seeded = new Date(2_000);
+    const stream = createStream(
+      new Map([
+        ["task-parent", subagent("task-parent", ["tools:parent"])],
+        [
+          "task-child",
+          subagent(
+            "task-child",
+            ["tools:parent", "tools:child"],
+            "complete",
+            "task-parent",
+            2,
+            seeded,
+            seeded,
+          ),
+        ],
+      ]),
+      new Map([
+        ["tools:parent", createStore([parentMessage])],
+        [
+          "tools:parent/tools:child",
+          createStore([message("child-ai", "ai", "child answer")]),
+        ],
+      ]),
+    );
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, noUIMessages),
+    );
+
+    await waitFor(() =>
+      expect(hook.result.current.has("task-child")).toBe(true),
+    );
+    const taskCall = messagesOf(
+      hook.result.current,
+      "task-parent",
+    )?.[0]?.content.find((part) => part.type === "tool-call");
+
+    expect(taskCall).toMatchObject({ toolCallId: "task-child" });
+    expect(taskCall).not.toHaveProperty("timing");
+  });
+
+  it("keeps the wall clock of a task whose namespace resolves after it finished", async () => {
+    const stream = createStream(
+      new Map([
+        [
+          "task-one",
+          subagent(
+            "task-one",
+            ["tools:task-one"],
+            "running",
+            null,
+            1,
+            new Date(1_000),
+            null,
+          ),
+        ],
+      ]),
+      new Map([
+        ["tools:task-one", createStore([message("one-ai", "ai", "partial")])],
+        ["tools:promoted", createStore([message("one-ai", "ai", "answer")])],
+      ]),
+    );
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, noUIMessages),
+    );
+
+    await waitFor(() =>
+      expect(hook.result.current.get("task-one")?.timing).toMatchObject({
+        startedAt: 1_000,
+      }),
+    );
+
+    stream.subagents = new Map([
+      [
+        "task-one",
+        subagent(
+          "task-one",
+          ["tools:promoted"],
+          "complete",
+          null,
+          1,
+          new Date(1_000),
+          new Date(6_000),
+        ),
+      ],
+    ]);
+    hook.rerender();
+
+    await waitFor(() =>
+      expect(hook.result.current.get("task-one")?.timing).toMatchObject({
+        startedAt: 1_000,
+        completedAt: 6_000,
+      }),
+    );
+  });
+
+  it("keeps finalized nested timing when the namespace resolves after completion", async () => {
+    const placeholderStore = createStore([message("one-ai", "ai", "partial")]);
+    const stream = createStream(
+      new Map([["task-one", subagent("task-one", ["tools:task-one"])]]),
+      new Map([
+        ["tools:task-one", placeholderStore],
+        ["tools:promoted", createStore([message("one-ai", "ai", "answer")])],
+      ]),
+    );
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, noUIMessages),
+    );
+
+    await waitFor(() =>
+      expect(messagesOf(hook.result.current, "task-one")).toHaveLength(1),
+    );
+    await act(async () => {
+      placeholderStore.setSnapshot([message("one-ai", "ai", "partial answer")]);
+    });
+
+    stream.subagents = new Map([
+      ["task-one", subagent("task-one", ["tools:task-one"], "complete")],
+    ]);
+    hook.rerender();
+    await waitFor(() =>
+      expect(
+        messagesOf(hook.result.current, "task-one")?.[0]?.metadata?.timing,
+      ).toBeDefined(),
+    );
+
+    stream.subagents = new Map([
+      ["task-one", subagent("task-one", ["tools:promoted"], "complete")],
+    ]);
+    hook.rerender();
+
+    await waitFor(() =>
+      expect(
+        messagesOf(hook.result.current, "task-one")?.[0]?.content,
+      ).toMatchObject([{ type: "text", text: "answer" }]),
+    );
+    expect(
+      messagesOf(hook.result.current, "task-one")?.[0]?.metadata?.timing,
+    ).toBeDefined();
+  });
+
+  it("keeps counting a streaming message across a namespace rebind", async () => {
+    const placeholderStore = createStore([message("one-ai", "ai", "partial")]);
+    const promotedStore = createStore([
+      message("one-ai", "ai", "partial answer"),
+    ]);
+    const stream = createStream(
+      new Map([["task-one", subagent("task-one", ["tools:task-one"])]]),
+      new Map([
+        ["tools:task-one", placeholderStore],
+        ["tools:promoted", promotedStore],
+      ]),
+    );
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, noUIMessages),
+    );
+
+    await waitFor(() =>
+      expect(messagesOf(hook.result.current, "task-one")).toHaveLength(1),
+    );
+
+    stream.subagents = new Map([
+      ["task-one", subagent("task-one", ["tools:promoted"])],
+    ]);
+    hook.rerender();
+    await waitFor(() =>
+      expect(
+        messagesOf(hook.result.current, "task-one")?.[0]?.content,
+      ).toMatchObject([{ type: "text", text: "partial answer" }]),
+    );
+
+    stream.subagents = new Map([
+      ["task-one", subagent("task-one", ["tools:promoted"], "complete")],
+    ]);
+    hook.rerender();
+
+    await waitFor(() =>
+      expect(
+        messagesOf(hook.result.current, "task-one")?.[0]?.metadata?.timing,
+      ).toMatchObject({ totalChunks: 2 }),
+    );
+  });
+
+  it("finalizes nested timing when one update both promotes and completes", async () => {
+    const placeholderStore = createStore([message("one-ai", "ai", "partial")]);
+    const stream = createStream(
+      new Map([["task-one", subagent("task-one", ["tools:task-one"])]]),
+      new Map([
+        ["tools:task-one", placeholderStore],
+        [
+          "tools:promoted",
+          createStore([message("one-ai", "ai", "partial answer")]),
+        ],
+      ]),
+    );
+    const hook = renderHook(() =>
+      useSubagentTranscripts(stream as never, noUIMessages),
+    );
+
+    await waitFor(() =>
+      expect(messagesOf(hook.result.current, "task-one")).toHaveLength(1),
+    );
+
+    stream.subagents = new Map([
+      ["task-one", subagent("task-one", ["tools:promoted"], "complete")],
+    ]);
+    hook.rerender();
+
+    await waitFor(() =>
+      expect(
+        messagesOf(hook.result.current, "task-one")?.[0]?.metadata?.timing,
+      ).toMatchObject({ totalChunks: 2 }),
+    );
+  });
 });