@assistant-ui/core 0.3.17 → 0.3.19

package/src/react/adapters/LocalStorageThreadListAdapter.test.ts

@@ -139,6 +139,250 @@ describe("parseStoredMessageRepository", () => {
     expect(repo.messages.map((item) => item.message.id)).toEqual(["valid"]);
   });
 
+  it("drops unreadable parts and attachments while keeping their messages", () => {
+    const attachment = {
+      id: "attachment-1",
+      type: "document",
+      name: "notes.txt",
+      status: { type: "complete" },
+      content: [null, { type: "text", text: "notes" }],
+    };
+    const repo = parseStoredMessageRepository(
+      JSON.stringify({
+        headId: "answer",
+        messages: [
+          {
+            message: {
+              ...storedMessage("question"),
+              content: [
+                null,
+                "text",
+                { type: 1 },
+                { type: "text", text: "hi" },
+              ],
+              attachments: [
+                null,
+                attachment,
+                { ...attachment, id: 2 },
+                { ...attachment, id: "uploading", status: { type: "running" } },
+                { ...attachment, id: "no-content", content: undefined },
+                { ...attachment, id: "no-name", name: undefined },
+              ],
+            },
+            parentId: null,
+          },
+          {
+            message: {
+              ...storedMessage("answer", "assistant"),
+              content: [null, { type: "future-part", value: 1 }],
+            },
+            parentId: "question",
+          },
+        ],
+      }),
+    );
+
+    const [question, answer] = repo.messages.map((item) => item.message);
+    expect(repo.headId).toBe("answer");
+    expect(question?.content).toEqual([{ type: "text", text: "hi" }]);
+    expect(question?.attachments).toEqual([
+      { ...attachment, content: [{ type: "text", text: "notes" }] },
+    ]);
+    expect(answer?.content).toEqual([{ type: "future-part", value: 1 }]);
+  });
+
+  it("drops known parts that are missing a required field", () => {
+    const parts = {
+      text: { type: "text", text: "hi" },
+      reasoning: { type: "reasoning", text: "because" },
+      summary: { type: "reasoning", unstable_summary: "Searching the docs" },
+      image: { type: "image", image: "https://example.com/a.png" },
+      file: { type: "file", data: "SGk=", mimeType: "text/plain" },
+      audio: { type: "audio", audio: { data: "SGk=", format: "mp3" } },
+      data: { type: "data", name: "weather", data: { sunny: true } },
+      url: {
+        type: "source",
+        sourceType: "url",
+        id: "source-1",
+        url: "https://example.com",
+      },
+      document: {
+        type: "source",
+        sourceType: "document",
+        id: "source-2",
+        title: "Notes",
+        mediaType: "text/plain",
+      },
+      generativeUI: { type: "generative-ui", spec: { root: "hi" } },
+      toolCall: {
+        type: "tool-call",
+        toolCallId: "call-1",
+        toolName: "search",
+        args: {},
+        argsText: "{}",
+      },
+    };
+    const repo = parseStoredMessageRepository(
+      JSON.stringify({
+        messages: [
+          {
+            message: {
+              ...storedMessage("assistant", "assistant"),
+              content: [
+                { type: "text" },
+                { ...parts.reasoning, text: 1 },
+                { type: "image" },
+                { ...parts.file, mimeType: undefined },
+                { type: "audio", audio: null },
+                { type: "data", data: {} },
+                { ...parts.url, url: undefined },
+                { ...parts.document, sourceType: "unknown" },
+                { type: "generative-ui" },
+                { ...parts.toolCall, argsText: undefined },
+                ...Object.values(parts),
+              ],
+            },
+            parentId: null,
+          },
+        ],
+      }),
+    );
+
+    expect(repo.messages[0]?.message.content).toEqual(Object.values(parts));
+  });
+
+  it("applies the same rules to nested tool call messages", () => {
+    const toolCall = {
+      type: "tool-call",
+      toolCallId: "call-1",
+      toolName: "delegate",
+      args: {},
+      argsText: "{}",
+    };
+    const repo = parseStoredMessageRepository(
+      JSON.stringify({
+        messages: [
+          {
+            message: {
+              ...storedMessage("parent", "assistant"),
+              content: [
+                {
+                  ...toolCall,
+                  messages: [
+                    null,
+                    { id: "missing-shell" },
+                    {
+                      ...storedMessage("nested", "assistant"),
+                      content: [null, { type: "text", text: "nested" }],
+                    },
+                  ],
+                },
+                { ...toolCall, toolCallId: "call-2", messages: "invalid" },
+              ],
+            },
+            parentId: null,
+          },
+        ],
+      }),
+    );
+
+    expect(repo.messages[0]?.message.content).toEqual([
+      {
+        ...toolCall,
+        messages: [
+          {
+            ...storedMessage("nested", "assistant"),
+            content: [{ type: "text", text: "nested" }],
+            createdAt: new Date("2026-01-01T00:00:00.000Z"),
+            metadata: {
+              unstable_state: null,
+              unstable_annotations: [],
+              unstable_data: [],
+              steps: [],
+              custom: {},
+            },
+          },
+        ],
+      },
+      { ...toolCall, toolCallId: "call-2" },
+    ]);
+  });
+
+  it("keeps a system message when exactly one readable part remains", () => {
+    const repo = parseStoredMessageRepository(
+      JSON.stringify({
+        messages: [
+          {
+            message: {
+              ...storedMessage("unreadable", "system"),
+              content: [null],
+            },
+            parentId: null,
+          },
+          {
+            message: {
+              ...storedMessage("non-text", "system"),
+              content: [
+                { type: "text" },
+                { type: "image", image: "https://example.com/a.png" },
+              ],
+            },
+            parentId: null,
+          },
+          {
+            message: {
+              ...storedMessage("recovered", "system"),
+              content: [null, { type: "text", text: "Be brief." }],
+            },
+            parentId: null,
+          },
+        ],
+      }),
+    );
+
+    expect(
+      repo.messages.map(({ message }) => [message.id, message.content]),
+    ).toEqual([
+      ["non-text", [{ type: "image", image: "https://example.com/a.png" }]],
+      ["recovered", [{ type: "text", text: "Be brief." }]],
+    ]);
+  });
+
+  it("stops parsing nested tool call messages past the depth limit", () => {
+    let stored: unknown = storedMessage("leaf", "assistant");
+    for (let level = 0; level < 150; level += 1) {
+      stored = {
+        ...storedMessage(`level-${level}`, "assistant"),
+        content: [
+          {
+            type: "tool-call",
+            toolCallId: `call-${level}`,
+            toolName: "delegate",
+            args: {},
+            argsText: "{}",
+            messages: [stored],
+          },
+        ],
+      };
+    }
+
+    const repo = parseStoredMessageRepository(
+      JSON.stringify({ messages: [{ message: stored, parentId: null }] }),
+    );
+
+    let message = repo.messages[0]?.message;
+    let depth = 0;
+    while (message?.role === "assistant") {
+      const part = message.content[0];
+      const nested =
+        part?.type === "tool-call" ? part.messages?.[0] : undefined;
+      if (!nested) break;
+      message = nested;
+      depth += 1;
+    }
+    expect(depth).toBe(100);
+  });
+
   it("skips messages whose parent is missing, skipped, or appears later", () => {
     const repo = parseStoredMessageRepository(
       JSON.stringify({

package/src/react/adapters/LocalStorageThreadListAdapter.tsx

@@ -9,12 +9,15 @@ import {
 } from "react";
 import { useAui } from "@assistant-ui/store";
 import type {
+  CompleteAttachment,
   RemoteThreadInitializeResponse,
   RemoteThreadListAdapter,
   RemoteThreadListResponse,
   RemoteThreadMetadata,
+  ThreadAssistantMessagePart,
   ThreadHistoryAdapter,
   ThreadMessage,
+  ThreadUserMessagePart,
   RunConfig,
 } from "../../index";
 import type {
@@ -120,7 +123,91 @@ const parseDate = (value: unknown): Date | null => {
 const isMessageRole = (value: unknown): value is ThreadMessage["role"] =>
   value === "system" || value === "user" || value === "assistant";
 
-const parseStoredThreadMessage = (value: unknown): ThreadMessage | null => {
+const MAX_STORED_MESSAGE_DEPTH = 100;
+
+const storedPartGuards = {
+  text: (part) => typeof part.text === "string",
+  reasoning: (part) =>
+    typeof part.text === "string" || typeof part.unstable_summary === "string",
+  image: (part) => typeof part.image === "string",
+  file: (part) =>
+    typeof part.data === "string" && typeof part.mimeType === "string",
+  audio: (part) =>
+    isRecord(part.audio) &&
+    typeof part.audio.data === "string" &&
+    typeof part.audio.format === "string",
+  data: (part) => typeof part.name === "string",
+  source: (part) =>
+    typeof part.id === "string" &&
+    (part.sourceType === "url"
+      ? typeof part.url === "string"
+      : part.sourceType === "document" &&
+        typeof part.title === "string" &&
+        typeof part.mediaType === "string"),
+  "generative-ui": (part) => isRecord(part.spec),
+  "tool-call": (part) =>
+    typeof part.toolCallId === "string" &&
+    typeof part.toolName === "string" &&
+    isRecord(part.args) &&
+    typeof part.argsText === "string",
+} satisfies Record<
+  (ThreadUserMessagePart | ThreadAssistantMessagePart)["type"],
+  (part: Record<string, unknown>) => boolean
+>;
+
+const isStoredMessagePart = (
+  value: unknown,
+): value is Record<string, unknown> & { type: string } =>
+  isRecord(value) &&
+  typeof value.type === "string" &&
+  (!Object.hasOwn(storedPartGuards, value.type) ||
+    storedPartGuards[value.type as keyof typeof storedPartGuards](value));
+
+const parseStoredMessageParts = (
+  content: unknown[],
+  depth: number,
+): unknown[] =>
+  content.flatMap((part) => {
+    if (!isStoredMessagePart(part)) return [];
+    if (part.type !== "tool-call" || part.messages === undefined) return [part];
+
+    const { messages, ...toolCall } = part;
+    if (!Array.isArray(messages)) return [toolCall];
+    return [
+      {
+        ...toolCall,
+        messages: messages.flatMap((item) => {
+          const message = parseStoredThreadMessage(item, depth + 1);
+          return message ? [message] : [];
+        }),
+      },
+    ];
+  });
+
+const parseStoredAttachment = (value: unknown): CompleteAttachment | null => {
+  if (
+    !isRecord(value) ||
+    typeof value.id !== "string" ||
+    typeof value.type !== "string" ||
+    typeof value.name !== "string" ||
+    !isRecord(value.status) ||
+    value.status.type !== "complete" ||
+    !Array.isArray(value.content)
+  ) {
+    return null;
+  }
+
+  return {
+    ...value,
+    content: value.content.filter(isStoredMessagePart),
+  } as CompleteAttachment;
+};
+
+const parseStoredThreadMessage = (
+  value: unknown,
+  depth: number,
+): ThreadMessage | null => {
+  if (depth > MAX_STORED_MESSAGE_DEPTH) return null;
   if (!isRecord(value) || typeof value.id !== "string") return null;
   if (!isMessageRole(value.role)) return null;
   if (!Array.isArray(value.content)) return null;
@@ -143,7 +230,10 @@ const parseStoredThreadMessage = (value: unknown): ThreadMessage | null => {
     return {
       id: value.id,
       role: "assistant",
-      content: value.content as StoredAssistantMessage["content"],
+      content: parseStoredMessageParts(
+        value.content,
+        depth,
+      ) as StoredAssistantMessage["content"],
       status: status as StoredAssistantMessage["status"],
       createdAt,
       metadata: {
@@ -185,9 +275,15 @@ const parseStoredThreadMessage = (value: unknown): ThreadMessage | null => {
     return {
       id: value.id,
       role: "user",
-      content: value.content as StoredUserMessage["content"],
+      content: parseStoredMessageParts(
+        value.content,
+        depth,
+      ) as StoredUserMessage["content"],
       attachments: Array.isArray(value.attachments)
-        ? (value.attachments as StoredUserMessage["attachments"])
+        ? value.attachments.flatMap((item) => {
+            const attachment = parseStoredAttachment(item);
+            return attachment ? [attachment] : [];
+          })
         : [],
       createdAt,
       metadata: {
@@ -196,12 +292,13 @@ const parseStoredThreadMessage = (value: unknown): ThreadMessage | null => {
     };
   }
 
-  if (value.content.length !== 1) return null;
+  const content = parseStoredMessageParts(value.content, depth);
+  if (content.length !== 1) return null;
 
   return {
     id: value.id,
     role: "system",
-    content: [value.content[0] as StoredSystemMessage["content"][0]],
+    content: [content[0] as StoredSystemMessage["content"][0]],
     createdAt,
     metadata: {
       custom: metadata.custom,
@@ -226,7 +323,7 @@ const parseStoredMessageRepositoryItem = (
 ): ExportedMessageRepositoryItem | null => {
   if (!isRecord(value)) return null;
 
-  const message = parseStoredThreadMessage(value.message);
+  const message = parseStoredThreadMessage(value.message, 0);
   if (!message) return null;
 
   const parentId = value.parentId;

package/src/react/client/DataRenderers.test.tsx

@@ -0,0 +1,45 @@
+// @vitest-environment jsdom
+
+import { act, cleanup, render } from "@testing-library/react";
+import { useAui } from "@assistant-ui/store";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { DataRenderers } from "./DataRenderers";
+
+type AnyClient = Record<string, any>;
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("DataRenderers", () => {
+  it.each(["__proto__", "constructor"])(
+    "registers and removes a renderer named %s",
+    async (name) => {
+      let aui!: AnyClient;
+      const Harness = () => {
+        aui = useAui({ dataRenderers: DataRenderers() } as never);
+        return null;
+      };
+      render(<Harness />);
+
+      let remove!: () => void;
+      await act(async () => {
+        remove = aui.dataRenderers().setDataUI(name, () => null);
+        await vi.waitFor(() => {
+          const renderers = aui.dataRenderers().getState().renderers;
+          expect(Object.hasOwn(renderers, name)).toBe(true);
+          expect(renderers[name]).toHaveLength(1);
+        });
+      });
+
+      await act(async () => {
+        remove();
+        await vi.waitFor(() =>
+          expect(
+            Object.hasOwn(aui.dataRenderers().getState().renderers, name),
+          ).toBe(false),
+        );
+      });
+    },
+  );
+});

package/src/react/client/DataRenderers.ts

@@ -3,6 +3,7 @@ import { resource } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
 import type { DataRenderersState } from "../types/scopes/dataRenderers";
 import type { DataMessagePartComponent } from "../types/MessagePartComponentTypes";
+import { nullProtoRecord } from "../../utils/record";
 
 /**
  * Registers renderers for `data` message parts.
@@ -13,30 +14,33 @@ import type { DataMessagePartComponent } from "../types/MessagePartComponentType
  */
 const useDataRenderers = (): ClientOutput<"dataRenderers"> => {
   const [state, setState] = useState<DataRenderersState>(() => ({
-    renderers: {},
+    renderers: nullProtoRecord(),
     fallbacks: [],
   }));
 
   const setDataUI = useCallback(
     (name: string, render: DataMessagePartComponent) => {
       setState((prev) => {
+        const renderers = nullProtoRecord(prev.renderers);
+        renderers[name] = [...(renderers[name] ?? []), render];
         return {
           ...prev,
-          renderers: {
-            ...prev.renderers,
-            [name]: [...(prev.renderers[name] ?? []), render],
-          },
+          renderers,
         };
       });
 
       return () => {
         setState((prev) => {
+          const renderers = nullProtoRecord(prev.renderers);
+          const remaining = renderers[name]?.filter((r) => r !== render) ?? [];
+          if (remaining.length > 0) {
+            renderers[name] = remaining;
+          } else {
+            delete renderers[name];
+          }
           return {
             ...prev,
-            renderers: {
-              ...prev.renderers,
-              [name]: prev.renderers[name]?.filter((r) => r !== render) ?? [],
-            },
+            renderers,
           };
         });
       };

package/src/react/client/InMemoryThreadList.ts

@@ -209,6 +209,7 @@ const useInMemoryThreadList = (
       mainThreadId,
       newThreadId: null,
       isLoading: false,
+      loadError: undefined,
       isLoadingMore: false,
       hasMore: false,
       threadIds: regularThreads.map((t) => t.id),

package/src/react/client/Interactables.test.ts

@@ -10,7 +10,12 @@ import type { ThreadMessage } from "../../types/message";
 const clientHolder: { client: unknown } = { client: null };
 const clientListeners = new Set<() => void>();
 let registeredModelContextProvider:
-  | { subscribe?: (callback: () => void) => () => void }
+  | {
+      getModelContext?: () => {
+        tools?: Record<string, { parameters?: unknown }>;
+      };
+      subscribe?: (callback: () => void) => () => void;
+    }
   | undefined;
 
 const replaceClient = (client: unknown) => {
@@ -210,6 +215,34 @@ describe("Interactables registration", () => {
     expect(stateOf(root, "n1")).toEqual({ v: 7 });
   });
 
+  // `definitions` is read by bare key with ids that reach the runtime from
+  // model tool calls, so it must stay prototype-free through every transition.
+  it.each(["__proto__", "constructor", "toString"])(
+    "registers, updates and unregisters an interactable named %s",
+    (id) => {
+      root = mount();
+      const unregister = root.getValue().register(reg(id));
+      expect(stateOf(root, id)).toEqual({ v: 0 });
+
+      root.getValue().setState(id, () => ({ v: 1 }));
+      expect(stateOf(root, id)).toEqual({ v: 1 });
+      expect(Object.keys(root.getValue().getState().definitions)).toEqual([id]);
+
+      unregister();
+      expect(Object.keys(root.getValue().getState().definitions)).toEqual([]);
+    },
+  );
+
+  it("keeps the state records prototype-free", () => {
+    root = mount();
+    root.getValue().register(reg("n1"));
+    root.getValue().setState("n1", () => ({ v: 1 }));
+
+    const state = root.getValue().getState();
+    expect(Object.getPrototypeOf(state.definitions)).toBeNull();
+    expect(Object.getPrototypeOf(state.persistence)).toBeNull();
+  });
+
   it("restores detached state when an instance re-registers in-session", async () => {
     root = mount();
     const unregister = root.getValue().register(reg("n1"));
@@ -293,6 +326,44 @@ describe("Interactables registration", () => {
     expect(stateOf(root, "n1")).toBeUndefined();
   });
 
+  it("refreshes cached tool parameters while another anchor remains", async () => {
+    const schemaA = {
+      type: "object" as const,
+      properties: { first: { type: "string" } },
+    };
+    const schemaB = {
+      type: "object" as const,
+      properties: { second: { type: "number" } },
+    };
+    root = mount({ threadMessages: [createCall("n1")] });
+    const first = root.getValue().register(reg("n1", { stateSchema: schemaA }));
+    const second = root
+      .getValue()
+      .register(reg("n1", { stateSchema: schemaA }));
+    await flushMicrotasks();
+
+    first();
+    const replacement = root
+      .getValue()
+      .register(reg("n1", { stateSchema: schemaB }));
+
+    const parameters =
+      registeredModelContextProvider?.getModelContext?.().tools?.update_note
+        ?.parameters;
+    expect(parameters).toMatchObject({
+      properties: {
+        id: { type: "string" },
+        second: { type: "number" },
+      },
+    });
+    expect(parameters).not.toMatchObject({
+      properties: { first: expect.anything() },
+    });
+
+    second();
+    replacement();
+  });
+
   it("installs the update tool UI once per name and removes it with the last anchor", () => {
     const removeToolUI = vi.fn();
     const setToolUI = vi.fn(() => removeToolUI);