@assistant-ui/react-langchain 0.0.29 → 0.0.31

package/dist/useSubagentTranscripts.js

@@ -0,0 +1,171 @@
+"use client";
+import { attachSubagentTranscripts, createAttachMemo } from "./attachSubagentTranscripts.js";
+import { convertLangChainBaseMessage } from "./convertMessages.js";
+import { convertExternalMessages, createExternalMessageConversionCache } from "@assistant-ui/core/react";
+import { useEffect, useRef, useSyncExternalStore } from "react";
+import { STREAM_CONTROLLER } from "@langchain/react";
+import { messagesProjection } from "@langchain/langgraph-sdk/stream";
+//#region src/useSubagentTranscripts.ts
+const MAX_SUBAGENT_DEPTH = 16;
+const TRANSCRIPT_METADATA = {};
+const sameNamespace = (a, b) => a.length === b.length && a.every((segment, index) => segment === b[index]);
+const sameTranscriptEntries = (a, b) => a?.size === b.size && [...b].every(([id, transcript]) => a.get(id) === transcript);
+const collectUIMessages = (messages, uiMessagesByParent) => {
+	const collected = [];
+	if (uiMessagesByParent.size === 0) return collected;
+	for (const message of messages) {
+		const uiMessages = message.id && uiMessagesByParent.get(message.id);
+		if (uiMessages) collected.push(...uiMessages);
+	}
+	return collected;
+};
+const sameUIMessages = (a, b) => a.length === b.length && a.every((ui, index) => ui === b[index]);
+const convertWithUIMessages = (uiMessagesByParent) => (message, metadata) => convertLangChainBaseMessage(message, {
+	...metadata,
+	uiMessagesByParent
+});
+const createSubagentTranscriptSource = () => {
+	const uiMessagesByParent = /* @__PURE__ */ new Map();
+	const source = {
+		resources: /* @__PURE__ */ new Map(),
+		requestedNamespaceIds: /* @__PURE__ */ new Set(),
+		snapshot: /* @__PURE__ */ new Map(),
+		listeners: /* @__PURE__ */ new Set(),
+		controller: void 0,
+		uiMessagesByParent,
+		convert: convertWithUIMessages(uiMessagesByParent),
+		subscribe(listener) {
+			source.listeners.add(listener);
+			return () => source.listeners.delete(listener);
+		},
+		getSnapshot() {
+			return source.snapshot;
+		},
+		reconcile(controller, subagents, uiMessagesByParent) {
+			if (source.uiMessagesByParent !== uiMessagesByParent) {
+				source.uiMessagesByParent = uiMessagesByParent;
+				source.convert = convertWithUIMessages(uiMessagesByParent);
+			}
+			if (source.controller !== controller) {
+				source.dispose();
+				source.controller = controller;
+			}
+			for (const id of source.requestedNamespaceIds) if (!subagents.has(id)) source.requestedNamespaceIds.delete(id);
+			for (const [id, resource] of source.resources) {
+				const snapshot = subagents.get(id);
+				if (!snapshot || snapshot.depth > 16 || !sameNamespace(resource.namespace, snapshot.namespace)) {
+					resource.unsubscribe();
+					resource.release();
+					source.resources.delete(id);
+					continue;
+				}
+				resource.snapshot = snapshot;
+			}
+			for (const snapshot of subagents.values()) {
+				if (snapshot.depth > 16) continue;
+				if (!source.requestedNamespaceIds.has(snapshot.id)) {
+					source.requestedNamespaceIds.add(snapshot.id);
+					controller.resolveSubagentNamespace(snapshot.id).catch(() => {
+						if (source.controller === controller) source.requestedNamespaceIds.delete(snapshot.id);
+					});
+				}
+				if (source.resources.has(snapshot.id)) continue;
+				const acquired = controller.registry.acquire(messagesProjection(snapshot.namespace));
+				const resource = {
+					snapshot,
+					namespace: snapshot.namespace,
+					store: acquired.store,
+					unsubscribe: () => {},
+					release: acquired.release,
+					storeSnapshot: void 0,
+					status: void 0,
+					uiMessages: [],
+					converted: void 0,
+					childTranscripts: void 0,
+					transcript: void 0,
+					memo: createAttachMemo(),
+					cache: createExternalMessageConversionCache()
+				};
+				resource.unsubscribe = resource.store.subscribe(() => rebuild());
+				source.resources.set(snapshot.id, resource);
+			}
+			rebuild();
+		},
+		dispose() {
+			for (const resource of source.resources.values()) {
+				resource.unsubscribe();
+				resource.release();
+			}
+			source.resources.clear();
+			source.requestedNamespaceIds.clear();
+			source.snapshot = /* @__PURE__ */ new Map();
+			for (const listener of source.listeners) listener();
+		}
+	};
+	const rebuild = () => {
+		const { convert, uiMessagesByParent } = source;
+		const resources = [...source.resources.values()];
+		const childrenByParent = /* @__PURE__ */ new Map();
+		for (const resource of resources) {
+			const parentId = resource.snapshot.parentId;
+			if (parentId == null) continue;
+			const children = childrenByParent.get(parentId);
+			if (children) children.push(resource);
+			else childrenByParent.set(parentId, [resource]);
+		}
+		const transcripts = /* @__PURE__ */ new Map();
+		let changed = source.snapshot.size !== resources.length;
+		const built = /* @__PURE__ */ new Set();
+		const build = (resource, depth) => {
+			if (built.has(resource.snapshot.id)) return;
+			built.add(resource.snapshot.id);
+			const children = depth < 16 ? childrenByParent.get(resource.snapshot.id) ?? [] : [];
+			for (const child of children) build(child, depth + 1);
+			const childTranscripts = new Map(children.flatMap((child) => child.transcript ? [[child.snapshot.id, child.transcript]] : []));
+			const storeSnapshot = resource.store.getSnapshot();
+			const status = resource.snapshot.status;
+			const uiMessages = collectUIMessages(storeSnapshot, uiMessagesByParent);
+			const conversionChanged = resource.converted === void 0 || resource.storeSnapshot !== storeSnapshot || resource.status !== status || !sameUIMessages(resource.uiMessages, uiMessages);
+			if (conversionChanged) {
+				resource.converted = convertExternalMessages(storeSnapshot, convert, status === "running", TRANSCRIPT_METADATA, resource.cache);
+				resource.storeSnapshot = storeSnapshot;
+				resource.status = status;
+				resource.uiMessages = uiMessages;
+			}
+			if (resource.transcript === void 0 || conversionChanged || !sameTranscriptEntries(resource.childTranscripts, childTranscripts)) {
+				const transcript = attachSubagentTranscripts(resource.converted, childTranscripts, resource.memo);
+				changed ||= resource.transcript !== transcript;
+				resource.transcript = transcript;
+				resource.childTranscripts = childTranscripts;
+			}
+			if (!source.snapshot.has(resource.snapshot.id)) changed = true;
+			transcripts.set(resource.snapshot.id, resource.transcript);
+		};
+		for (const resource of resources) if (resource.snapshot.parentId == null || !source.resources.has(resource.snapshot.parentId)) build(resource, 1);
+		for (const resource of resources) build(resource, 16);
+		if (!changed) return;
+		source.snapshot = transcripts;
+		for (const listener of source.listeners) listener();
+	};
+	return source;
+};
+const useSubagentTranscripts = (stream, uiMessagesByParent) => {
+	const sourceRef = useRef(void 0);
+	if (!sourceRef.current) sourceRef.current = createSubagentTranscriptSource();
+	const source = sourceRef.current;
+	const controller = stream[STREAM_CONTROLLER];
+	useEffect(() => {
+		source.reconcile(controller, stream.subagents, uiMessagesByParent);
+	}, [
+		controller,
+		source,
+		stream.subagents,
+		uiMessagesByParent
+	]);
+	useEffect(() => () => source.dispose(), [source]);
+	return useSyncExternalStore(source.subscribe, source.getSnapshot, source.getSnapshot);
+};
+//#endregion
+export { MAX_SUBAGENT_DEPTH, useSubagentTranscripts };
+
+//# sourceMappingURL=useSubagentTranscripts.js.map

package/dist/useSubagentTranscripts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSubagentTranscripts.js","names":[],"sources":["../src/useSubagentTranscripts.ts"],"sourcesContent":["\"use client\";\n\nimport { useEffect, useRef, useSyncExternalStore } from \"react\";\nimport type { ThreadMessage } from \"@assistant-ui/core\";\nimport {\n  convertExternalMessages,\n  createExternalMessageConversionCache,\n  type ExternalMessageConversionCache,\n  type useExternalMessageConverter,\n} from \"@assistant-ui/core/react\";\nimport { STREAM_CONTROLLER, type AnyStream } from \"@langchain/react\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport { messagesProjection } from \"@langchain/langgraph-sdk/stream\";\nimport type { SubagentDiscoverySnapshot } from \"@langchain/react\";\nimport {\n  attachSubagentTranscripts,\n  type AttachMemo,\n  createAttachMemo,\n} from \"./attachSubagentTranscripts\";\nimport { convertLangChainBaseMessage } from \"./convertMessages\";\nimport type { LangChainBaseMessage, UIMessage } from \"./types\";\n\nexport const MAX_SUBAGENT_DEPTH = 16;\n\nconst TRANSCRIPT_METADATA = {};\n\ntype ProjectionStore = {\n  getSnapshot(): BaseMessage[];\n  subscribe(listener: () => void): () => void;\n};\n\ntype ProjectionResource = {\n  snapshot: SubagentDiscoverySnapshot;\n  namespace: readonly string[];\n  store: ProjectionStore;\n  unsubscribe: () => void;\n  release: () => void;\n  storeSnapshot: BaseMessage[] | undefined;\n  status: SubagentDiscoverySnapshot[\"status\"] | undefined;\n  uiMessages: readonly UIMessage[];\n  converted: readonly ThreadMessage[] | undefined;\n  childTranscripts: ReadonlyMap<string, readonly ThreadMessage[]> | undefined;\n  transcript: readonly ThreadMessage[] | undefined;\n  memo: AttachMemo;\n  cache: ExternalMessageConversionCache;\n};\n\ntype SubagentTranscriptSource = {\n  resources: Map<string, ProjectionResource>;\n  requestedNamespaceIds: Set<string>;\n  snapshot: ReadonlyMap<string, readonly ThreadMessage[]>;\n  listeners: Set<() => void>;\n  controller: AnyStream[typeof STREAM_CONTROLLER] | undefined;\n  uiMessagesByParent: Map<string, UIMessage[]>;\n  convert: useExternalMessageConverter.Callback<LangChainBaseMessage>;\n  subscribe(listener: () => void): () => void;\n  getSnapshot(): ReadonlyMap<string, readonly ThreadMessage[]>;\n  reconcile(\n    controller: AnyStream[typeof STREAM_CONTROLLER],\n    subagents: AnyStream[\"subagents\"],\n    uiMessagesByParent: Map<string, UIMessage[]>,\n  ): void;\n  dispose(): void;\n};\n\nconst sameNamespace = (a: readonly string[], b: readonly string[]) =>\n  a.length === b.length && a.every((segment, index) => segment === b[index]);\n\nconst sameTranscriptEntries = (\n  a: ReadonlyMap<string, readonly ThreadMessage[]> | undefined,\n  b: ReadonlyMap<string, readonly ThreadMessage[]>,\n) =>\n  a?.size === b.size &&\n  [...b].every(([id, transcript]) => a.get(id) === transcript);\n\nconst collectUIMessages = (\n  messages: readonly BaseMessage[],\n  uiMessagesByParent: Map<string, UIMessage[]>,\n) => {\n  const collected: UIMessage[] = [];\n  if (uiMessagesByParent.size === 0) return collected;\n  for (const message of messages) {\n    const uiMessages = message.id && uiMessagesByParent.get(message.id);\n    if (uiMessages) collected.push(...uiMessages);\n  }\n  return collected;\n};\n\nconst sameUIMessages = (a: readonly UIMessage[], b: readonly UIMessage[]) =>\n  a.length === b.length && a.every((ui, index) => ui === b[index]);\n\nconst convertWithUIMessages =\n  (\n    uiMessagesByParent: Map<string, UIMessage[]>,\n  ): useExternalMessageConverter.Callback<LangChainBaseMessage> =>\n  (message, metadata) =>\n    convertLangChainBaseMessage(message, { ...metadata, uiMessagesByParent });\n\nconst createSubagentTranscriptSource = (): SubagentTranscriptSource => {\n  const uiMessagesByParent = new Map<string, UIMessage[]>();\n  const source: SubagentTranscriptSource = {\n    resources: new Map(),\n    requestedNamespaceIds: new Set(),\n    snapshot: new Map(),\n    listeners: new Set(),\n    controller: undefined,\n    uiMessagesByParent,\n    convert: convertWithUIMessages(uiMessagesByParent),\n    subscribe(listener) {\n      source.listeners.add(listener);\n      return () => source.listeners.delete(listener);\n    },\n    getSnapshot() {\n      return source.snapshot;\n    },\n    reconcile(controller, subagents, uiMessagesByParent) {\n      if (source.uiMessagesByParent !== uiMessagesByParent) {\n        source.uiMessagesByParent = uiMessagesByParent;\n        source.convert = convertWithUIMessages(uiMessagesByParent);\n      }\n\n      if (source.controller !== controller) {\n        source.dispose();\n        source.controller = controller;\n      }\n\n      for (const id of source.requestedNamespaceIds) {\n        if (!subagents.has(id)) source.requestedNamespaceIds.delete(id);\n      }\n\n      for (const [id, resource] of source.resources) {\n        const snapshot = subagents.get(id);\n        if (\n          !snapshot ||\n          snapshot.depth > MAX_SUBAGENT_DEPTH ||\n          !sameNamespace(resource.namespace, snapshot.namespace)\n        ) {\n          resource.unsubscribe();\n          resource.release();\n          source.resources.delete(id);\n          continue;\n        }\n        resource.snapshot = snapshot;\n      }\n\n      for (const snapshot of subagents.values()) {\n        if (snapshot.depth > MAX_SUBAGENT_DEPTH) continue;\n        if (!source.requestedNamespaceIds.has(snapshot.id)) {\n          source.requestedNamespaceIds.add(snapshot.id);\n          void controller.resolveSubagentNamespace(snapshot.id).catch(() => {\n            if (source.controller === controller)\n              source.requestedNamespaceIds.delete(snapshot.id);\n          });\n        }\n        if (source.resources.has(snapshot.id)) continue;\n        const acquired = controller.registry.acquire(\n          messagesProjection(snapshot.namespace),\n        );\n        const resource: ProjectionResource = {\n          snapshot,\n          namespace: snapshot.namespace,\n          store: acquired.store,\n          unsubscribe: () => {},\n          release: acquired.release,\n          storeSnapshot: undefined,\n          status: undefined,\n          uiMessages: [],\n          converted: undefined,\n          childTranscripts: undefined,\n          transcript: undefined,\n          memo: createAttachMemo(),\n          cache: createExternalMessageConversionCache(),\n        };\n        resource.unsubscribe = resource.store.subscribe(() => rebuild());\n        source.resources.set(snapshot.id, resource);\n      }\n\n      rebuild();\n    },\n    dispose() {\n      for (const resource of source.resources.values()) {\n        resource.unsubscribe();\n        resource.release();\n      }\n      source.resources.clear();\n      source.requestedNamespaceIds.clear();\n      source.snapshot = new Map();\n      for (const listener of source.listeners) listener();\n    },\n  };\n\n  const rebuild = () => {\n    const { convert, uiMessagesByParent } = source;\n    const resources = [...source.resources.values()];\n    const childrenByParent = new Map<string, ProjectionResource[]>();\n\n    for (const resource of resources) {\n      const parentId = resource.snapshot.parentId;\n      if (parentId == null) continue;\n      const children = childrenByParent.get(parentId);\n      if (children) children.push(resource);\n      else childrenByParent.set(parentId, [resource]);\n    }\n\n    const transcripts = new Map<string, readonly ThreadMessage[]>();\n    let changed = source.snapshot.size !== resources.length;\n    const built = new Set<string>();\n\n    const build = (resource: ProjectionResource, depth: number) => {\n      if (built.has(resource.snapshot.id)) return;\n      built.add(resource.snapshot.id);\n      const children =\n        depth < MAX_SUBAGENT_DEPTH\n          ? (childrenByParent.get(resource.snapshot.id) ?? [])\n          : [];\n      for (const child of children) build(child, depth + 1);\n      const childTranscripts = new Map(\n        children.flatMap((child) =>\n          child.transcript\n            ? [[child.snapshot.id, child.transcript] as const]\n            : [],\n        ),\n      );\n      const storeSnapshot = resource.store.getSnapshot();\n      const status = resource.snapshot.status;\n      const uiMessages = collectUIMessages(storeSnapshot, uiMessagesByParent);\n\n      const conversionChanged =\n        resource.converted === undefined ||\n        resource.storeSnapshot !== storeSnapshot ||\n        resource.status !== status ||\n        !sameUIMessages(resource.uiMessages, uiMessages);\n      if (conversionChanged) {\n        resource.converted = convertExternalMessages(\n          storeSnapshot as LangChainBaseMessage[],\n          convert,\n          status === \"running\",\n          TRANSCRIPT_METADATA,\n          resource.cache,\n        );\n        resource.storeSnapshot = storeSnapshot;\n        resource.status = status;\n        resource.uiMessages = uiMessages;\n      }\n\n      if (\n        resource.transcript === undefined ||\n        conversionChanged ||\n        !sameTranscriptEntries(resource.childTranscripts, childTranscripts)\n      ) {\n        const transcript = attachSubagentTranscripts(\n          resource.converted!,\n          childTranscripts,\n          resource.memo,\n        );\n        changed ||= resource.transcript !== transcript;\n        resource.transcript = transcript;\n        resource.childTranscripts = childTranscripts;\n      }\n\n      if (!source.snapshot.has(resource.snapshot.id)) changed = true;\n      transcripts.set(resource.snapshot.id, resource.transcript);\n    };\n\n    for (const resource of resources) {\n      if (\n        resource.snapshot.parentId == null ||\n        !source.resources.has(resource.snapshot.parentId)\n      )\n        build(resource, 1);\n    }\n    for (const resource of resources) build(resource, MAX_SUBAGENT_DEPTH);\n\n    if (!changed) return;\n    source.snapshot = transcripts;\n    for (const listener of source.listeners) listener();\n  };\n\n  return source;\n};\n\nexport const useSubagentTranscripts = (\n  stream: AnyStream,\n  uiMessagesByParent: Map<string, UIMessage[]>,\n): ReadonlyMap<string, readonly ThreadMessage[]> => {\n  const sourceRef = useRef<SubagentTranscriptSource | undefined>(undefined);\n  if (!sourceRef.current) {\n    sourceRef.current = createSubagentTranscriptSource();\n  }\n  const source = sourceRef.current;\n  const controller = stream[STREAM_CONTROLLER];\n\n  useEffect(() => {\n    source.reconcile(controller, stream.subagents, uiMessagesByParent);\n  }, [controller, source, stream.subagents, uiMessagesByParent]);\n\n  useEffect(() => () => source.dispose(), [source]);\n\n  return useSyncExternalStore(\n    source.subscribe,\n    source.getSnapshot,\n    source.getSnapshot,\n  );\n};\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react-langchain",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "description": "LangChain useStream adapter for assistant-ui",
   "keywords": [
     "langchain",
@@ -40,17 +40,21 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@assistant-ui/core": "^0.3.17",
-    "@assistant-ui/store": "^0.3.12",
+    "@assistant-ui/core": "^0.3.19",
+    "@assistant-ui/store": "^0.3.13",
     "assistant-cloud": "*",
-    "assistant-stream": "^0.3.41"
+    "assistant-stream": "^0.3.43"
   },
   "peerDependencies": {
-    "@langchain/react": "^1.0.2",
+    "@langchain/langgraph-sdk": "^1.9.20",
+    "@langchain/react": "^1.0.20",
     "@types/react": "*",
     "react": "^18 || ^19"
   },
   "peerDependenciesMeta": {
+    "@langchain/langgraph-sdk": {
+      "optional": true
+    },
     "@langchain/react": {
       "optional": true
     },
@@ -59,15 +63,15 @@
     }
   },
   "devDependencies": {
-    "@assistant-ui/x-buildutils": "0.0.25",
+    "@assistant-ui/x-buildutils": "0.0.27",
     "@langchain/core": "^1.2.9",
-    "@langchain/langgraph-sdk": "^1.10.0",
-    "@langchain/react": "^1.0.33",
+    "@langchain/langgraph-sdk": "^1.10.2",
+    "@langchain/react": "^1.0.35",
     "@testing-library/react": "^16.3.3",
     "@types/react": "^19.2.18",
     "jsdom": "^30.0.1",
     "react": "^19.2.8",
-    "vitest": "^4.1.11"
+    "vitest": "^5.0.0"
   },
   "publishConfig": {
     "access": "public",

package/src/attachSubagentTranscripts.test.ts

@@ -0,0 +1,190 @@
+import {
+  bindExternalStoreMessage,
+  getExternalStoreMessages,
+  type ThreadMessage,
+} from "@assistant-ui/core";
+import { describe, expect, it } from "vitest";
+import {
+  attachSubagentTranscripts,
+  createAttachMemo,
+} from "./attachSubagentTranscripts";
+
+const assistantMessage = (id: string, toolCallId?: string): ThreadMessage =>
+  ({
+    id,
+    createdAt: new Date(),
+    role: "assistant",
+    status: { type: "complete", reason: "unknown" },
+    content: toolCallId
+      ? [
+          {
+            type: "tool-call",
+            toolCallId,
+            toolName: "task",
+            args: {},
+            argsText: "{}",
+          },
+        ]
+      : [{ type: "text", text: id }],
+    metadata: {
+      unstable_state: null,
+      unstable_annotations: [],
+      unstable_data: [],
+      steps: [],
+      custom: {},
+    },
+  }) as ThreadMessage;
+
+const transcript = (id: string) => [assistantMessage(id)];
+
+describe("attachSubagentTranscripts", () => {
+  it("returns the input array when no tool call has a transcript", () => {
+    const messages = [assistantMessage("message", "unknown")];
+
+    expect(
+      attachSubagentTranscripts(
+        messages,
+        new Map([["task", transcript("transcript")]]),
+        createAttachMemo(),
+      ),
+    ).toBe(messages);
+  });
+
+  it("attaches a transcript and preserves untouched message identities", () => {
+    const matching = assistantMessage("matching", "task");
+    const untouched = assistantMessage("untouched");
+    const messages = [matching, untouched];
+    const childTranscript = transcript("child");
+
+    const attached = attachSubagentTranscripts(
+      messages,
+      new Map([["task", childTranscript]]),
+      createAttachMemo(),
+    );
+
+    expect(attached).not.toBe(messages);
+    expect(attached[0]).not.toBe(matching);
+    expect(attached[1]).toBe(untouched);
+    const part = attached[0]!.content[0]!;
+    expect(part.type).toBe("tool-call");
+    if (part.type !== "tool-call") throw new Error("expected a tool call");
+    expect(part.messages).toBe(childTranscript);
+  });
+
+  it("reuses the attached array when transcript identities are unchanged", () => {
+    const messages = [assistantMessage("matching", "task")];
+    const childTranscript = transcript("child");
+    const memo = createAttachMemo();
+
+    const first = attachSubagentTranscripts(
+      messages,
+      new Map([["task", childTranscript]]),
+      memo,
+    );
+    const second = attachSubagentTranscripts(
+      messages,
+      new Map([["task", childTranscript]]),
+      memo,
+    );
+
+    expect(second).toBe(first);
+  });
+
+  it("rebuilds only messages whose transcript changed", () => {
+    const messages = [
+      assistantMessage("first", "task-one"),
+      assistantMessage("second", "task-two"),
+    ];
+    const firstTranscript = transcript("first-transcript");
+    const secondTranscript = transcript("second-transcript");
+    const memo = createAttachMemo();
+    const first = attachSubagentTranscripts(
+      messages,
+      new Map([
+        ["task-one", firstTranscript],
+        ["task-two", secondTranscript],
+      ]),
+      memo,
+    );
+    const next = attachSubagentTranscripts(
+      messages,
+      new Map([
+        ["task-one", transcript("updated-transcript")],
+        ["task-two", secondTranscript],
+      ]),
+      memo,
+    );
+
+    expect(next).not.toBe(first);
+    expect(next[0]).not.toBe(first[0]);
+    expect(next[1]).toBe(first[1]);
+  });
+
+  it("rebuilds when the same transcript moves to another tool call", () => {
+    const first = assistantMessage("f", "call-a").content[0]!;
+    const second = assistantMessage("s", "call-b").content[0]!;
+    const message = {
+      ...assistantMessage("pair"),
+      content: [first, second],
+    } as ThreadMessage;
+    const nested = transcript("nested");
+    const memo = createAttachMemo();
+
+    const [before] = attachSubagentTranscripts(
+      [message],
+      new Map([["call-a", nested]]),
+      memo,
+    );
+    const [after] = attachSubagentTranscripts(
+      [message],
+      new Map([["call-b", nested]]),
+      memo,
+    );
+
+    expect(before?.content[0]).toMatchObject({ messages: nested });
+    expect(after).not.toBe(before);
+    expect(after?.content[0]).toBe(first);
+    expect(after?.content[1]).toMatchObject({ messages: nested });
+  });
+
+  it("keeps untouched parts of a partially matched message by reference", () => {
+    const text = { type: "text" as const, text: "hello" };
+    const matched = assistantMessage("m", "call-matched").content[0]!;
+    const unmatched = assistantMessage("u", "call-unmatched").content[0]!;
+    const message = {
+      ...assistantMessage("mixed"),
+      content: [text, matched, unmatched],
+    } as ThreadMessage;
+    const nested = transcript("nested");
+
+    const [attached] = attachSubagentTranscripts(
+      [message],
+      new Map([["call-matched", nested]]),
+      createAttachMemo(),
+    );
+
+    expect(attached?.content[0]).toBe(text);
+    expect(attached?.content[1]).toMatchObject({ messages: nested });
+    expect(attached?.content[2]).toBe(unmatched);
+  });
+
+  it("preserves message and array external-store bindings", () => {
+    const message = assistantMessage("matching", "task");
+    const messages = [message];
+    const originalMessage = { id: "original-message" };
+    const originalMessages = [{ id: "original-messages" }];
+    bindExternalStoreMessage(message, originalMessage);
+    bindExternalStoreMessage(messages, originalMessages);
+
+    const attached = attachSubagentTranscripts(
+      messages,
+      new Map([["task", transcript("child")]]),
+      createAttachMemo(),
+    );
+
+    expect(getExternalStoreMessages(attached[0]!)).toEqual([originalMessage]);
+    expect(getExternalStoreMessages({ messages: attached })).toBe(
+      originalMessages,
+    );
+  });
+});

package/src/attachSubagentTranscripts.ts

@@ -0,0 +1,72 @@
+import {
+  bindExternalStoreMessage,
+  getExternalStoreMessages,
+  type ThreadMessage,
+} from "@assistant-ui/core";
+
+type AttachedTranscript = readonly [string, readonly ThreadMessage[]];
+
+type AttachedMessage = {
+  transcripts: readonly AttachedTranscript[];
+  attached: ThreadMessage;
+};
+
+export type AttachMemo = {
+  messages: WeakMap<ThreadMessage, AttachedMessage>;
+  results: WeakMap<readonly ThreadMessage[], readonly ThreadMessage[]>;
+};
+
+export const createAttachMemo = (): AttachMemo => ({
+  messages: new WeakMap(),
+  results: new WeakMap(),
+});
+
+const sameTranscripts = (
+  a: readonly AttachedTranscript[],
+  b: readonly AttachedTranscript[],
+) =>
+  a.length === b.length &&
+  a.every(
+    ([toolCallId, transcript], index) =>
+      toolCallId === b[index]![0] && transcript === b[index]![1],
+  );
+
+export const attachSubagentTranscripts = (
+  messages: readonly ThreadMessage[],
+  transcripts: ReadonlyMap<string, readonly ThreadMessage[]>,
+  memo: AttachMemo,
+): readonly ThreadMessage[] => {
+  let attachedAny = false;
+  const next = messages.map((message) => {
+    const attachedTranscripts = message.content.flatMap((part) =>
+      part.type === "tool-call" && transcripts.has(part.toolCallId)
+        ? [[part.toolCallId, transcripts.get(part.toolCallId)!] as const]
+        : [],
+    );
+    if (attachedTranscripts.length === 0) return message;
+    attachedAny = true;
+
+    const cached = memo.messages.get(message);
+    if (cached && sameTranscripts(cached.transcripts, attachedTranscripts))
+      return cached.attached;
+
+    const attached = {
+      ...message,
+      content: message.content.map((part) =>
+        part.type === "tool-call" && transcripts.has(part.toolCallId)
+          ? { ...part, messages: transcripts.get(part.toolCallId)! }
+          : part,
+      ),
+    } as ThreadMessage;
+    memo.messages.set(message, { transcripts: attachedTranscripts, attached });
+    return attached;
+  });
+
+  if (!attachedAny) return messages;
+  const previous = memo.results.get(messages);
+  if (previous && previous.every((message, index) => message === next[index]))
+    return previous;
+  bindExternalStoreMessage(next, getExternalStoreMessages({ messages }));
+  memo.results.set(messages, next);
+  return next;
+};

package/src/convertMessages.test.ts

@@ -6,6 +6,7 @@ import {
   getMessageContent,
   getMessageType,
 } from "./convertMessages";
+import { createLangChainStreamingTimingAccessors } from "./converter";
 import type { LangChainBaseMessage, UIMessage } from "./types";
 
 const humanMessage = (content: unknown): LangChainBaseMessage => ({
@@ -755,13 +756,38 @@ describe("convertLangChainBaseMessage reasoning content parts", () => {
     ]);
   });
 
-  it("does not throw when a reasoning block omits both summary and reasoning", () => {
+  it("omits reasoning parts that contain only provider metadata", () => {
     const result = convertLangChainBaseMessage(
-      aiMessage([{ type: "reasoning" }]),
+      aiMessage([
+        { type: "reasoning", signature: "signed", index: 0 },
+        { type: "reasoning", summary: [{ type: "summary_text" }], index: 1 },
+        { type: "text", text: "Answer." },
+      ]),
       {},
     );
 
-    expect(contentOf(result)).toEqual([{ type: "reasoning", text: "" }]);
+    expect(contentOf(result)).toEqual([{ type: "text", text: "Answer." }]);
+  });
+
+  it("renders the summary, falling back to the reasoning string when it is blank", () => {
+    const convert = (summary: string) =>
+      contentOf(
+        convertLangChainBaseMessage(
+          aiMessage([
+            {
+              type: "reasoning",
+              reasoning: "Check net",
+              summary: [{ type: "summary_text", text: summary }],
+            },
+          ]),
+          {},
+        ),
+      );
+
+    expect(convert("temperature")).toEqual([
+      { type: "reasoning", text: "temperature" },
+    ]);
+    expect(convert("  ")).toEqual([{ type: "reasoning", text: "Check net" }]);
   });
 
   it("tolerates null entries inside the summary array", () => {
@@ -1114,6 +1140,49 @@ describe("convertLangChainBaseMessage malformed messages", () => {
     expect(contentOf(result)).toEqual([{ type: "text", text: "kept" }]);
   });
 
+  it("coalesces a text block without a text field to empty text", () => {
+    const result = convertLangChainBaseMessage(
+      humanMessage([{ type: "text" }]),
+      {},
+    );
+
+    expect(contentOf(result)).toEqual([{ type: "text", text: "" }]);
+  });
+
+  it("skips null entries when measuring streamed text length", () => {
+    const { getTextLength } = createLangChainStreamingTimingAccessors<{
+      id?: string | undefined;
+      content?: unknown;
+      _getType: () => string;
+    }>((message) => message._getType());
+
+    expect(
+      getTextLength(
+        [
+          {
+            _getType: () => "ai",
+            id: "ai-1",
+            content: [null, { type: "text", text: "abc" }, undefined],
+          },
+        ],
+        "ai-1",
+      ),
+    ).toBe(3);
+  });
+
+  it("renders a textless block as empty system text", () => {
+    const result = convertLangChainBaseMessage(
+      {
+        _getType: () => "system",
+        id: "msg-7",
+        content: [{ type: "text" }, { type: "text", text: "kept" }],
+      },
+      {},
+    );
+
+    expect(contentOf(result)).toEqual([{ type: "text", text: "kept" }]);
+  });
+
   it("skips null entries when collecting system text", () => {
     const result = convertLangChainBaseMessage(
       {