@assistant-ui/core 0.3.18 → 0.3.20

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) => {
@@ -142,7 +147,10 @@ const reg = (
   id,
   name: "note",
   description: "a note",
-  stateSchema: { type: "object", properties: {} } as never,
+  stateSchema: {
+    type: "object",
+    properties: {},
+  } satisfies Unstable_InteractableRegistration["stateSchema"],
   initialState: { v: 0 },
   ...overrides,
 });
@@ -321,6 +329,44 @@ describe("Interactables registration", () => {
     expect(stateOf(root, "n1")).toBeUndefined();
   });
 
+  it("refreshes cached tool parameters while another anchor remains", async () => {
+    const schemaA = {
+      type: "object",
+      properties: { first: { type: "string" } },
+    } satisfies Unstable_InteractableRegistration["stateSchema"];
+    const schemaB = {
+      type: "object",
+      properties: { second: { type: "number" } },
+    } satisfies Unstable_InteractableRegistration["stateSchema"];
+    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);
@@ -473,7 +519,9 @@ describe("Interactables persistence save", () => {
 
   it("keeps edits queued during an in-flight flush with the outgoing adapter", async () => {
     const saveResolvers: Array<() => void> = [];
-    const firstSave = vi.fn(
+    const firstSave = vi.fn<
+      (state: Unstable_InteractablePersistedState) => Promise<void>
+    >(
       () =>
         new Promise<void>((resolve) => {
           saveResolvers.push(resolve);
@@ -504,7 +552,7 @@ describe("Interactables persistence save", () => {
     await flushMicrotasks();
     expect(flushed).toBe(false);
     expect(firstSave).toHaveBeenCalledTimes(2);
-    expect(firstSave.mock.calls[1]![0]).toEqual({
+    expect(firstSave.mock.calls[1]?.[0]).toEqual({
       n1: { name: "note", state: { v: 2 } },
     });
     expect(secondSave).not.toHaveBeenCalled();

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);

package/src/react/client/RemoteThreadList.concurrent.test.tsx

@@ -220,9 +220,15 @@ describe("RemoteThreadList concurrent rendering", () => {
     const unsubscribe = client.on(
       "threads.selectionChanged" as never,
       (() => {
-        selectionToolIds.push(
-          Object.keys(client.thread.getModelContext().tools)[0]!,
-        );
+        const tools = client.thread.getModelContext().tools;
+        if (tools === undefined) {
+          throw new Error("Expected thread model context tools");
+        }
+        const toolId = Object.keys(tools)[0];
+        if (toolId === undefined) {
+          throw new Error("Expected thread model context tool");
+        }
+        selectionToolIds.push(toolId);
       }) as never,
     );
 

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

@@ -8,7 +8,10 @@ import {
   type AssistantConfigSource,
 } from "@assistant-ui/store/client";
 import type { ThreadHistoryAdapter } from "../../adapters/thread-history";
-import type { RemoteThreadListAdapter } from "../../runtimes/remote-thread-list/types";
+import type {
+  RemoteThreadListAdapter,
+  RemoteThreadMetadata,
+} from "../../runtimes/remote-thread-list/types";
 import {
   useRuntimeAdapters,
   type RuntimeAdapters,
@@ -118,8 +121,9 @@ const mountList = (
   refetch?: () => Promise<void>,
   onSwitchToThread?: (id: string) => void,
   onDelete?: (id: string) => void,
+  providedOnThreadIdChange?: (id: string | undefined) => void,
 ) => {
-  const onThreadIdChange = vi.fn();
+  const onThreadIdChange = providedOnThreadIdChange ?? vi.fn();
   const handle = createAssistantClient(
     AuiConfig({
       threads: RemoteThreadList({
@@ -827,11 +831,7 @@ describe("RemoteThreadList", () => {
   });
 
   const deleteDuringAdapterSwap = async (
-    replacementThreads: readonly {
-      status: "regular";
-      remoteId: string;
-      title: string;
-    }[],
+    replacementThreads: RemoteThreadMetadata[],
   ) => {
     const removal = deferred<void>();
     const onDelete = vi.fn();
@@ -1929,4 +1929,43 @@ describe("RemoteThreadList", () => {
     });
     handle.destroy();
   });
+
+  it("keeps a completed switch when onThreadIdChange throws", async () => {
+    const callbackError = new Error("host callback failed");
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const onThreadIdChange = vi.fn(() => {
+      throw callbackError;
+    });
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+    });
+    const { handle } = mountList(
+      adapter,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      onThreadIdChange,
+    );
+    const threads = handle.getClient().threads;
+    try {
+      await threads.getLoadThreadsPromise();
+
+      flushTapSync(() => threads.switchToThread("t1"));
+
+      await vi.waitFor(() => {
+        expect(handle.getClient().threads.getState().mainThreadId).toBe("t1");
+        expect(onThreadIdChange).toHaveBeenCalledExactlyOnceWith("t1");
+        expect(errorSpy).toHaveBeenCalledWith(
+          "[assistant-ui] onThreadIdChange callback threw an error",
+          callbackError,
+        );
+      });
+    } finally {
+      handle.destroy();
+      errorSpy.mockRestore();
+    }
+  });
 });

package/src/react/client/RemoteThreadList.ts

@@ -57,6 +57,7 @@ import {
   startThreadTitleRename,
   type ThreadTitleState,
 } from "../../runtimes/remote-thread-list/title-generation";
+import { invokeUserCallback } from "../../utils/invoke-user-callback";
 
 const RESOLVED_PROMISE = Promise.resolve();
 
@@ -550,7 +551,14 @@ const useRemoteThreadList = (
     (remoteId: string | undefined, emit: boolean) => {
       if (session.lastNotifiedRemoteId === remoteId) return;
       session.lastNotifiedRemoteId = remoteId;
-      if (emit) session.onThreadIdChange?.(remoteId);
+      if (emit) {
+        invokeUserCallback(
+          "assistant-ui",
+          "onThreadIdChange",
+          session.onThreadIdChange,
+          remoteId,
+        );
+      }
     },
     [session],
   );
@@ -1255,7 +1263,12 @@ const useRemoteThreadList = (
   useEffect(() => {
     if (session.lastNotifiedRemoteId === mainRemoteId) return;
     session.lastNotifiedRemoteId = mainRemoteId;
-    onThreadIdChange?.(mainRemoteId);
+    invokeUserCallback(
+      "assistant-ui",
+      "onThreadIdChange",
+      onThreadIdChange,
+      mainRemoteId,
+    );
   }, [mainRemoteId, onThreadIdChange, session]);
 
   useEffect(() => {

package/src/react/client/interactable-model-context.test.ts

@@ -241,6 +241,50 @@ describe("buildInteractableModelContext", () => {
       expect(mockGenerateId).toHaveBeenCalledOnce();
     });
 
+    it.each(["__proto__", "toString"])(
+      "mints ids for items in a prototype-named array field %s",
+      async (field) => {
+        const itemSchema = {
+          type: "object" as const,
+          properties: {
+            id: { type: "string" as const },
+            title: { type: "string" as const },
+          },
+          required: ["id", "title"],
+        };
+        const schema = {
+          type: "object" as const,
+          properties: Object.fromEntries([
+            [field, { type: "array" as const, items: itemSchema }],
+          ]),
+        };
+        const state = Object.fromEntries([[field, []]]);
+        const defs = { b1: def("b1", "taskBoard", state) };
+        const { ctx } = build(defs, new Map([["b1", schema]]));
+        const args = Object.fromEntries([
+          ["id", "b1"],
+          [field, { add: [{ title: "Write tests" }] }],
+        ]);
+
+        const result = (await ctx!.tools["update_taskBoard"]!.execute!(
+          args,
+          {} as never,
+        )) as {
+          addedItemIds: Record<string, string[]>;
+        };
+
+        expect(Object.getPrototypeOf(result.addedItemIds)).toBe(
+          Object.prototype,
+        );
+        expect(Object.hasOwn(result.addedItemIds, field)).toBe(true);
+        expect(result.addedItemIds[field]).toEqual(["generated-id"]);
+        expect(Object.hasOwn(defs.b1.state as object, field)).toBe(true);
+        expect((defs.b1.state as Record<string, unknown>)[field]).toEqual([
+          { title: "Write tests", id: "generated-id" },
+        ]);
+      },
+    );
+
     it("rejects an unknown id and lists valid ids", async () => {
       const defs = { n1: def("n1", "note"), n2: def("n2", "note") };
       const { ctx, setDefState } = build(defs);

package/src/react/client/interactable-model-context.ts

@@ -8,6 +8,7 @@ import {
 } from "../../model-context/interactable-composer-metadata";
 import { generateId } from "../../utils/id";
 import { isRecord } from "../../utils/json/is-json";
+import { nullProtoRecord } from "../../utils/record";
 
 export type PartialJSONSchema = ReturnType<typeof toJSONSchema>;
 
@@ -243,7 +244,7 @@ export function buildInteractableModelContext(
         }
         const baseline = streamBaselines.get(toolCallId);
         streamBaselines.delete(toolCallId);
-        const addedItemIds: Record<string, string[]> = {};
+        const addedItemIds = nullProtoRecord<string[]>();
         setDefState(target.id, (prev) =>
           shallowMergeInteractableState(prev, partial, {
             arrayBaseline:
@@ -264,7 +265,7 @@ export function buildInteractableModelContext(
           addedItemIds?: Record<string, string[]>;
         } = { success: true, id: target.id };
         if (Object.keys(addedItemIds).length > 0) {
-          result.addedItemIds = addedItemIds;
+          result.addedItemIds = { ...addedItemIds };
         }
         return result;
       },

package/src/react/index.ts

@@ -217,8 +217,12 @@ export { useExternalStoreSharedOptions } from "./runtimes/useExternalStoreShared
 export {
   useExternalMessageConverter,
   convertExternalMessages,
+  createExternalMessageConversionCache,
+} from "./runtimes/external-message-converter";
+export type {
+  ExternalMessageConversionCache,
+  JoinStrategy,
 } from "./runtimes/external-message-converter";
-export type { JoinStrategy } from "./runtimes/external-message-converter";
 export { createMessageConverter } from "./runtimes/createMessageConverter";
 export {
   useStreamingTiming,

package/src/react/interactables-legacy/Interactables.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { createTapRoot, flushTapSync, useResource } from "@assistant-ui/tap";
 import type {
+  InteractablePersistedState,
   InteractablePersistenceAdapter,
   InteractableRegistration,
 } from "./scopes";
@@ -89,7 +90,10 @@ const reg = (id: string): InteractableRegistration => ({
   id,
   name: "note",
   description: "a note",
-  stateSchema: { type: "object", properties: {} } as never,
+  stateSchema: {
+    type: "object",
+    properties: {},
+  } satisfies InteractableRegistration["stateSchema"],
   initialState: { v: 0 },
 });
 
@@ -154,7 +158,9 @@ describe("legacy Interactables persistence", () => {
 
   it("keeps edits queued during an in-flight flush with the outgoing adapter", async () => {
     const saveResolvers: Array<() => void> = [];
-    const firstSave = vi.fn(
+    const firstSave = vi.fn<
+      (state: InteractablePersistedState) => Promise<void>
+    >(
       () =>
         new Promise<void>((resolve) => {
           saveResolvers.push(resolve);
@@ -177,7 +183,7 @@ describe("legacy Interactables persistence", () => {
     saveResolvers[0]!();
     await flushMicrotasks();
     expect(firstSave).toHaveBeenCalledTimes(2);
-    expect(firstSave.mock.calls[1]![0]).toEqual({
+    expect(firstSave.mock.calls[1]?.[0]).toEqual({
       n1: { name: "note", state: { v: 2 } },
     });
     expect(firstSave.mock.calls.at(-1)?.[0]).toEqual({

package/src/react/interactables-legacy/useAssistantInteractable.test.tsx

@@ -0,0 +1,150 @@
+// @vitest-environment jsdom
+
+import { cleanup, renderHook, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { InteractableStateSchema } from "./scopes";
+
+type JsonSchema = Exclude<InteractableStateSchema, { "~standard": unknown }>;
+type StandardSchemaWithJsonSchema = Extract<
+  InteractableStateSchema,
+  { "~standard": unknown }
+> & {
+  "~standard": {
+    jsonSchema: { input: () => JsonSchema; output: () => JsonSchema };
+  };
+};
+
+const mocks = vi.hoisted(() => {
+  const unregister = vi.fn();
+  const register = vi.fn(() => unregister);
+  return {
+    register,
+    unregister,
+    aui: { interactables: { register } },
+  };
+});
+
+vi.mock("@assistant-ui/store", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@assistant-ui/store")>()),
+  useAui: () => mocks.aui,
+}));
+
+import { useAssistantInteractable } from "./useAssistantInteractable";
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe("useAssistantInteractable", () => {
+  it("refreshes the registration when its JSON schema changes", async () => {
+    const schemaA = {
+      type: "object",
+      properties: { first: { type: "string" } },
+    } satisfies InteractableStateSchema;
+    const schemaB = {
+      type: "object",
+      properties: { second: { type: "number" } },
+    } satisfies InteractableStateSchema;
+    const initialA = { first: "one" };
+    const initialB = { second: 2 };
+
+    const hook = renderHook<
+      unknown,
+      { stateSchema: InteractableStateSchema; initialState: unknown }
+    >(
+      ({ stateSchema, initialState }) =>
+        useAssistantInteractable("panel", {
+          id: "panel-1",
+          description: "A panel",
+          stateSchema,
+          initialState,
+        }),
+      { initialProps: { stateSchema: schemaA, initialState: initialA } },
+    );
+    await waitFor(() => expect(mocks.register).toHaveBeenCalledTimes(1));
+
+    hook.rerender({ stateSchema: schemaB, initialState: initialB });
+
+    await waitFor(() => expect(mocks.register).toHaveBeenCalledTimes(2));
+    expect(mocks.unregister).toHaveBeenCalledTimes(1);
+    expect(mocks.register).toHaveBeenLastCalledWith(
+      expect.objectContaining({ stateSchema: schemaB, initialState: initialB }),
+    );
+
+    hook.rerender({
+      stateSchema: {
+        type: "object",
+        properties: { second: { type: "number" } },
+      },
+      initialState: { second: 3 },
+    });
+    expect(mocks.register).toHaveBeenCalledTimes(2);
+  });
+
+  it("stabilizes equivalent rebuilt standard schemas", async () => {
+    const createSchema = (property: string): StandardSchemaWithJsonSchema => ({
+      "~standard": {
+        version: 1,
+        vendor: "test",
+        validate: () => ({ value: {} }),
+        jsonSchema: {
+          input: () => ({
+            type: "object",
+            properties: { [property]: { type: "string" } },
+          }),
+          output: () => ({ type: "object" }),
+        },
+      },
+    });
+    const firstSchema = createSchema("value");
+
+    const hook = renderHook<unknown, { stateSchema: InteractableStateSchema }>(
+      ({ stateSchema }) =>
+        useAssistantInteractable("panel", {
+          id: "panel-1",
+          description: "A panel",
+          stateSchema,
+          initialState: {},
+        }),
+      { initialProps: { stateSchema: firstSchema } },
+    );
+    await waitFor(() => expect(mocks.register).toHaveBeenCalledTimes(1));
+
+    hook.rerender({ stateSchema: createSchema("value") });
+    expect(mocks.register).toHaveBeenCalledTimes(1);
+
+    const changedSchema = createSchema("other");
+    hook.rerender({ stateSchema: changedSchema });
+    await waitFor(() => expect(mocks.register).toHaveBeenCalledTimes(2));
+    expect(mocks.register).toHaveBeenLastCalledWith(
+      expect.objectContaining({ stateSchema: changedSchema }),
+    );
+  });
+
+  it("keeps unsupported standard schemas from failing during render", async () => {
+    const createSchema = () =>
+      ({
+        "~standard": {
+          version: 1 as const,
+          vendor: "test",
+          validate: () => ({ value: {} }),
+        },
+      }) satisfies InteractableStateSchema;
+
+    const hook = renderHook<unknown, { stateSchema: InteractableStateSchema }>(
+      ({ stateSchema }) =>
+        useAssistantInteractable("panel", {
+          id: "panel-1",
+          description: "A panel",
+          stateSchema,
+          initialState: {},
+        }),
+      { initialProps: { stateSchema: createSchema() } },
+    );
+    await waitFor(() => expect(mocks.register).toHaveBeenCalledTimes(1));
+
+    hook.rerender({ stateSchema: createSchema() });
+    expect(mocks.register).toHaveBeenCalledTimes(1);
+  });
+});

package/src/react/interactables-legacy/useAssistantInteractable.ts

@@ -1,5 +1,6 @@
 import { useEffect, useId, useRef } from "react";
 import { useAui } from "@assistant-ui/store";
+import { useJSONSchemaDependency } from "../utils/useJSONSchemaDependency";
 import type { InteractableStateSchema } from "./scopes";
 
 /**
@@ -38,6 +39,7 @@ export const useAssistantInteractable = (
 
   const stateSchemaRef = useRef(config.stateSchema);
   stateSchemaRef.current = config.stateSchema;
+  const normalizedStateSchema = useJSONSchemaDependency(config.stateSchema);
   const initialStateRef = useRef(config.initialState);
   initialStateRef.current = config.initialState;
 
@@ -50,7 +52,14 @@ export const useAssistantInteractable = (
       initialState: initialStateRef.current,
       selected: config.selected,
     });
-  }, [aui, id, name, config.description, config.selected]);
+  }, [
+    aui,
+    id,
+    name,
+    config.description,
+    normalizedStateSchema,
+    config.selected,
+  ]);
 
   return id;
 };