@assistant-ui/core 0.3.17 → 0.3.19

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

@@ -18,11 +18,12 @@ import { ModelContext } from "../../store";
 import { buildInteractableModelContext } from "./interactable-model-context";
 import { notifySubscribers as notifyStateSubscribers } from "../../subscribable/subscribable";
 import { useInteractablePersistenceQueue } from "../interactables-shared/useInteractablePersistenceQueue";
+import { nullProtoRecord } from "../../utils/record";
 
 const useInteractables = (): ClientOutput<"interactables"> => {
   const [state, setState] = useState<InteractablesState>(() => ({
-    definitions: {},
-    persistence: {},
+    definitions: nullProtoRecord(),
+    persistence: nullProtoRecord(),
   }));
 
   const clientRef = useAssistantClientRef();
@@ -49,7 +50,7 @@ const useInteractables = (): ClientOutput<"interactables"> => {
   );
 
   const exportState = useCallback((): InteractablePersistedState => {
-    const result: InteractablePersistedState = {};
+    const result = nullProtoRecord<InteractablePersistedState[string]>();
     for (const [id, def] of Object.entries(stateRef.current.definitions)) {
       result[id] = { name: def.name, state: def.state };
     }
@@ -86,7 +87,7 @@ const useInteractables = (): ClientOutput<"interactables"> => {
       }
       setStateAndRef((prev) => {
         let changed = false;
-        const definitions = { ...prev.definitions };
+        const definitions = nullProtoRecord(prev.definitions);
         for (const [id, entry] of Object.entries(saved)) {
           if (definitions[id]) {
             definitions[id] = { ...definitions[id], state: entry.state };
@@ -114,10 +115,9 @@ const useInteractables = (): ClientOutput<"interactables"> => {
         if (!existing) return prev;
         return {
           ...prev,
-          definitions: {
-            ...prev.definitions,
+          definitions: nullProtoRecord(prev.definitions, {
             [id]: { ...existing, state: updater(existing.state) },
-          },
+          }),
         };
       });
       if (stateRef.current.definitions[id]) schedulePersistence(id);
@@ -132,10 +132,9 @@ const useInteractables = (): ClientOutput<"interactables"> => {
         if (!existing) return prev;
         return {
           ...prev,
-          definitions: {
-            ...prev.definitions,
+          definitions: nullProtoRecord(prev.definitions, {
             [id]: { ...existing, selected },
-          },
+          }),
         };
       });
     },
@@ -194,8 +193,7 @@ const useInteractables = (): ClientOutput<"interactables"> => {
 
       setStateAndRef((prev) => ({
         ...prev,
-        definitions: {
-          ...prev.definitions,
+        definitions: nullProtoRecord(prev.definitions, {
           [def.id]: {
             id: def.id,
             name: def.name,
@@ -205,7 +203,7 @@ const useInteractables = (): ClientOutput<"interactables"> => {
               prev.definitions[def.id]?.state ?? detached ?? def.initialState,
             selected: def.selected,
           },
-        },
+        }),
       }));
 
       return () => {
@@ -216,9 +214,11 @@ const useInteractables = (): ClientOutput<"interactables"> => {
             detachedStateRef.current.set(def.id, existing.state);
           }
           partialSchemaCacheRef.current.delete(def.id);
-          const { [def.id]: _, ...rest } = prev.definitions;
-          const { [def.id]: __, ...restPersistence } = prev.persistence;
-          return { ...prev, definitions: rest, persistence: restPersistence };
+          const definitions = nullProtoRecord(prev.definitions);
+          const persistence = nullProtoRecord(prev.persistence);
+          delete definitions[def.id];
+          delete persistence[def.id];
+          return { ...prev, definitions, persistence };
         });
       };
     },

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

@@ -0,0 +1,132 @@
+// @vitest-environment jsdom
+
+import { cleanup, renderHook, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+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" as const,
+      properties: { first: { type: "string" } },
+    };
+    const schemaB = {
+      type: "object" as const,
+      properties: { second: { type: "number" } },
+    };
+    const initialA = { first: "one" };
+    const initialB = { second: 2 };
+
+    const hook = renderHook(
+      ({ 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) => ({
+      "~standard": {
+        version: 1 as const,
+        vendor: "test",
+        validate: (value: unknown) => ({ value }),
+        toJSONSchema: () => ({
+          type: "object" as const,
+          properties: { [property]: { type: "string" as const } },
+        }),
+      },
+    });
+    const firstSchema = createSchema("value");
+
+    const hook = renderHook(
+      ({ 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: unknown) => ({ value }),
+      },
+    });
+
+    const hook = renderHook(
+      ({ 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;
 };

package/src/react/interactables-shared/useInteractablePersistenceQueue.ts

@@ -1,4 +1,5 @@
 import { useCallback, useRef, type RefObject } from "react";
+import { nullProtoRecord } from "../../utils/record";
 
 const PERSISTENCE_DEBOUNCE_MS = 500;
 
@@ -90,15 +91,13 @@ export const useInteractablePersistenceQueue = <State>({
       const { adapter, payload, dirtyIds, seq } = resolved;
       inFlightPersistenceRef.current += 1;
 
-      updatePersistenceStatus((prev) => ({
-        ...prev,
-        ...Object.fromEntries(
-          [...dirtyIds].map((id) => [
-            id,
-            { isPending: true, error: undefined },
-          ]),
-        ),
-      }));
+      updatePersistenceStatus((prev) => {
+        const persistence = nullProtoRecord(prev);
+        for (const id of dirtyIds) {
+          persistence[id] = { isPending: true, error: undefined };
+        }
+        return persistence;
+      });
 
       const settleBatch = (status: PersistenceStatus | undefined) => {
         const settledIds: string[] = [];
@@ -114,7 +113,7 @@ export const useInteractablePersistenceQueue = <State>({
         if (settledIds.length === 0) return;
         updatePersistenceStatus((prev) => {
           let changed = false;
-          const persistence = { ...prev };
+          const persistence = nullProtoRecord(prev);
           for (const id of settledIds) {
             if (prev[id] === undefined) continue;
             if (status === undefined) delete persistence[id];

package/src/react/model-context/makeAssistantTool.ts

@@ -8,7 +8,7 @@ import { type AssistantToolProps, useAssistantTool } from "./useAssistantTool";
  * subtree.
  *
  * @deprecated Use a toolkit with `Tools({ toolkit })` and register it via
- * `useAui({ tools: Tools({ toolkit }) })` instead. See
+ * `AuiConfig({ tools: Tools({ toolkit }) })` on the provider's `config` prop instead. See
  * https://assistant-ui.com/docs/migrations/toolkit-tools.
  */
 export type AssistantTool = FC & {
@@ -25,7 +25,7 @@ export type AssistantTool = FC & {
  * @param tool - Tool definition and name to register.
  *
  * @deprecated Use a toolkit with `Tools({ toolkit })` and register it via
- * `useAui({ tools: Tools({ toolkit }) })` instead. See
+ * `AuiConfig({ tools: Tools({ toolkit }) })` on the provider's `config` prop instead. See
  * https://assistant-ui.com/docs/migrations/toolkit-tools.
  */
 export const makeAssistantTool = <

package/src/react/model-context/useAssistantTool.ts

@@ -12,7 +12,7 @@ import {
  * Props used to register a tool from React.
  *
  * @deprecated Use a toolkit with `Tools({ toolkit })` and register it via
- * `useAui({ tools: Tools({ toolkit }) })` instead. See
+ * `AuiConfig({ tools: Tools({ toolkit }) })` on the provider's `config` prop instead. See
  * https://assistant-ui.com/docs/migrations/toolkit-tools.
  */
 export type AssistantToolProps<
@@ -39,7 +39,7 @@ export type AssistantToolProps<
  * @param tool - Tool definition and name to register.
  *
  * @deprecated Use a toolkit with `Tools({ toolkit })` and register it via
- * `useAui({ tools: Tools({ toolkit }) })` instead. See
+ * `AuiConfig({ tools: Tools({ toolkit }) })` on the provider's `config` prop instead. See
  * https://assistant-ui.com/docs/migrations/toolkit-tools.
  *
  * @example

package/src/react/model-context/useInteractable.test.tsx

@@ -0,0 +1,177 @@
+// @vitest-environment jsdom
+
+import { cleanup, renderHook, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => {
+  const unregister = vi.fn();
+  const register = vi.fn(() => unregister);
+  return {
+    register,
+    unregister,
+    aui: { unstable_interactables: { register } },
+    state: { optional: { part: undefined }, thread: { messages: [] } },
+    methods: {
+      setState: vi.fn(),
+      isPending: false,
+      error: undefined,
+      flush: vi.fn(async () => undefined),
+    },
+  };
+});
+
+vi.mock("@assistant-ui/store", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@assistant-ui/store")>()),
+  useAui: () => mocks.aui,
+  useAuiState: (selector: (state: typeof mocks.state) => unknown) =>
+    selector(mocks.state),
+}));
+
+vi.mock("./useInteractableState", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("./useInteractableState")>()),
+  unstable_useInteractableState: () => [undefined, mocks.methods],
+}));
+
+import { unstable_useInteractable } from "./useInteractable";
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe("unstable_useInteractable", () => {
+  it("refreshes the registration when its JSON schema changes", async () => {
+    const schemaA = {
+      type: "object" as const,
+      properties: { first: { type: "string" } },
+    };
+    const schemaB = {
+      type: "object" as const,
+      properties: { second: { type: "number" } },
+    };
+    const initialA = { first: "one" };
+    const initialB = { second: 2 };
+
+    const hook = renderHook(
+      ({ stateSchema, initialState }) =>
+        unstable_useInteractable("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) => ({
+      "~standard": {
+        version: 1 as const,
+        vendor: "test",
+        validate: (value: unknown) => ({ value }),
+        toJSONSchema: () => ({
+          type: "object" as const,
+          properties: { [property]: { type: "string" as const } },
+        }),
+      },
+    });
+    const firstSchema = createSchema("value");
+
+    const hook = renderHook(
+      ({ stateSchema }) =>
+        unstable_useInteractable("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: unknown) => ({ value }),
+      },
+    });
+
+    const hook = renderHook(
+      ({ stateSchema }) =>
+        unstable_useInteractable("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);
+  });
+
+  it("converts a referentially stable schema only once", async () => {
+    const toJSONSchema = vi.fn(() => ({
+      type: "object" as const,
+      properties: { value: { type: "string" as const } },
+    }));
+    const stateSchema = {
+      "~standard": {
+        version: 1 as const,
+        vendor: "test",
+        validate: (value: unknown) => ({ value }),
+        toJSONSchema,
+      },
+    };
+
+    const hook = renderHook(
+      ({ initialState }) =>
+        unstable_useInteractable("panel", {
+          id: "panel-1",
+          description: "A panel",
+          stateSchema,
+          initialState,
+        }),
+      { initialProps: { initialState: { value: "first" } } },
+    );
+    await waitFor(() => expect(mocks.register).toHaveBeenCalledTimes(1));
+
+    hook.rerender({ initialState: { value: "second" } });
+    expect(toJSONSchema).toHaveBeenCalledTimes(1);
+    expect(mocks.register).toHaveBeenCalledTimes(1);
+  });
+});

package/src/react/model-context/useInteractable.ts

@@ -10,6 +10,7 @@ import {
 } from "../../model-context/interactable-composer-metadata";
 import { unstable_useInteractableState as useInteractableState } from "./useInteractableState";
 import { useJSONEqual } from "../utils/useJSONEqual";
+import { useJSONSchemaDependency } from "../utils/useJSONSchemaDependency";
 
 /**
  * The state type described by an interactable's `stateSchema`. Resolves the
@@ -116,6 +117,7 @@ const useInteractable = <TSchema extends Unstable_InteractableStateSchema>(
 
   const stateSchemaRef = useRef(config.stateSchema);
   stateSchemaRef.current = config.stateSchema;
+  const normalizedStateSchema = useJSONSchemaDependency(config.stateSchema);
   const initialStateRef = useRef(config.initialState);
   initialStateRef.current = config.initialState;
 
@@ -138,6 +140,7 @@ const useInteractable = <TSchema extends Unstable_InteractableStateSchema>(
     id,
     name,
     config.description,
+    normalizedStateSchema,
     internalScope,
     config.updateRender,
   ]);

package/src/react/model-context/useToolArgsStatus.test.tsx

@@ -0,0 +1,30 @@
+// @vitest-environment jsdom
+
+import { renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+
+const part = vi.hoisted(() => ({
+  type: "tool-call" as const,
+  status: { type: "complete" as const },
+  args: JSON.parse('{"__proto__":"value"}') as Record<string, unknown>,
+}));
+
+vi.mock("@assistant-ui/store", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@assistant-ui/store")>();
+  return {
+    ...actual,
+    useAuiState: (selector: (state: { part: typeof part }) => unknown) =>
+      selector({ part }),
+  };
+});
+
+import { useToolArgsStatus } from "./useToolArgsStatus";
+
+describe("useToolArgsStatus", () => {
+  it("reports status for an argument named __proto__", () => {
+    const { result } = renderHook(() => useToolArgsStatus());
+
+    expect(Object.hasOwn(result.current.propStatus, "__proto__")).toBe(true);
+    expect(result.current.propStatus.__proto__).toBe("complete");
+  });
+});

package/src/react/model-context/useToolArgsStatus.ts

@@ -4,6 +4,7 @@ import {
   getPartialJsonObjectFieldState,
   getPartialJsonObjectMeta,
 } from "assistant-stream/utils";
+import { nullProtoRecord } from "../../utils/record";
 
 type PropFieldStatus = "streaming" | "complete";
 
@@ -60,7 +61,7 @@ export const useToolArgsStatus = <
     const isStreaming = statusType === "running";
     const args = part.args as Record<string, unknown>;
     const meta = getPartialJsonObjectMeta(args as Record<symbol, unknown>);
-    const propStatus: Partial<Record<string, PropFieldStatus>> = {};
+    const propStatus = nullProtoRecord<PropFieldStatus>();
 
     for (const key of Object.keys(args)) {
       if (meta) {

package/src/react/primitive-hooks/useActionBarCopy.test.ts

@@ -45,7 +45,6 @@ import { useActionBarCopy } from "./useActionBarCopy";
 
 afterEach(() => {
   cleanup();
-  vi.clearAllMocks();
   vi.useRealTimers();
   mocks.currentAui = mocks.aui;
 });

package/src/react/primitive-hooks/useSuggestionTrigger.test.ts

@@ -47,7 +47,6 @@ import { useSuggestionTrigger } from "./useSuggestionTrigger";
 
 afterEach(() => {
   cleanup();
-  vi.clearAllMocks();
   mocks.state.thread.isDisabled = false;
   mocks.state.thread.isRunning = false;
   mocks.state.thread.capabilities = { queue: false };