@assistant-ui/core 0.3.18 → 0.3.19

package/src/model-context/interactable-composer-metadata.test.ts

@@ -104,6 +104,18 @@ describe("interactableToolName", () => {
 });
 
 describe("shallowMergeInteractableState", () => {
+  it("adds prototype-named fields as own properties", () => {
+    const value = { enabled: true };
+    const result = shallowMergeInteractableState(
+      { title: "Example" },
+      Object.fromEntries([["__proto__", value]]),
+    ) as Record<string, unknown>;
+
+    expect(Object.getPrototypeOf(result)).toBe(Object.prototype);
+    expect(Object.hasOwn(result, "__proto__")).toBe(true);
+    expect(result["__proto__"]).toBe(value);
+  });
+
   it("applies array operations from a baseline", () => {
     const prev = {
       tasks: [
@@ -453,6 +465,24 @@ describe("gateInteractableComposerMetadata", () => {
     expect(gated?.interactables).toEqual([entry("a", { v: 1 })]);
   });
 
+  it.each(["__proto__", "toString"])(
+    "treats a removed prototype-named field %s as a full snapshot",
+    (field) => {
+      const known = Object.fromEntries([
+        [field, { enabled: true }],
+        ["title", "draft"],
+        ["stable", true],
+      ]);
+      const current = { title: "edited", stable: true };
+      const meta = { interactables: [entry("a", current)] };
+      const history = [userMsg([entry("a", known)])];
+
+      const gated = gateInteractableComposerMetadata(meta, history);
+
+      expect(gated?.interactables).toEqual([entry("a", current)]);
+    },
+  );
+
   it("omits an interactable the model already knows via its own update_* call", () => {
     const meta = { interactables: [entry("a", { v: 2 }, "note")] };
     const history = [

package/src/model-context/interactable-composer-metadata.ts

@@ -149,7 +149,7 @@ export function shallowMergeInteractableState(
   const baseline = isRecord(options?.arrayBaseline)
     ? options.arrayBaseline
     : prev;
-  const next = { ...prev };
+  const next = Object.entries(prev);
   for (const [key, value] of Object.entries(partial)) {
     const baseValue = baseline[key];
     if (Array.isArray(baseValue) && isRecord(value)) {
@@ -158,12 +158,12 @@ export function shallowMergeInteractableState(
         (options.idKeyedFields === undefined || options.idKeyedFields.has(key))
           ? () => options.idFactory?.(key)
           : undefined;
-      next[key] = applyArrayUpdate(baseValue, value, mintId);
+      next.push([key, applyArrayUpdate(baseValue, value, mintId)]);
     } else {
-      next[key] = value;
+      next.push([key, value]);
     }
   }
-  return next;
+  return Object.fromEntries(next);
 }
 
 /**
@@ -179,17 +179,17 @@ function shallowDiffInteractableState(
 ): Record<string, unknown> | undefined {
   if (!isRecord(known) || !isRecord(next)) return undefined;
   for (const key of Object.keys(known)) {
-    if (!(key in next)) return undefined;
+    if (!Object.hasOwn(next, key)) return undefined;
   }
-  const diff: Record<string, unknown> = {};
+  const diff: [string, unknown][] = [];
   for (const [key, value] of Object.entries(next)) {
-    if (!(key in known) || !isJSONValueEqual(known[key], value)) {
-      diff[key] = value;
+    if (!Object.hasOwn(known, key) || !isJSONValueEqual(known[key], value)) {
+      diff.push([key, value]);
     }
   }
-  const changed = Object.keys(diff).length;
+  const changed = diff.length;
   if (changed === 0 || changed === Object.keys(next).length) return undefined;
-  return diff;
+  return Object.fromEntries(diff);
 }
 
 type ToolCallLikePart = {

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/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) => {
@@ -321,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);

package/src/react/client/Interactables.ts

@@ -88,6 +88,9 @@ const useInteractablesResource = ({
 
   const subscribersRef = useRef(new Set<() => void>());
   const partialSchemaCacheRef = useRef(new Map<string, PartialJSONSchema>());
+  const partialSchemaSourceRef = useRef(
+    new Map<string, Unstable_InteractableRegistration["stateSchema"]>(),
+  );
   const streamBaselinesRef = useRef(
     new Map<string, { targetId: string; state: unknown }>(),
   );
@@ -409,7 +412,9 @@ const useInteractablesResource = ({
       }
 
       // The same id re-registers once per anchor (its create call + each update_*).
-      if (!partialSchemaCacheRef.current.has(def.id)) {
+      if (partialSchemaSourceRef.current.get(def.id) !== def.stateSchema) {
+        partialSchemaSourceRef.current.set(def.id, def.stateSchema);
+        partialSchemaCacheRef.current.delete(def.id);
         try {
           const jsonSchema = toJSONSchema(def.stateSchema);
           partialSchemaCacheRef.current.set(
@@ -497,6 +502,7 @@ const useInteractablesResource = ({
               detachedAppStateRef.current.set(def.id, existing.state);
             }
           }
+          partialSchemaSourceRef.current.delete(def.id);
           partialSchemaCacheRef.current.delete(def.id);
           const definitions = nullProtoRecord(prev.definitions);
           const persistence = nullProtoRecord(prev.persistence);