@assistant-ui/core 0.3.16 → 0.3.18

package/src/react/RuntimeAdapter.test.ts

@@ -69,6 +69,40 @@ describe("RuntimeAdapter via the neutral store entry", () => {
     handle.destroy();
   });
 
+  it("emits composer.send for a thread.append, flagging a suggestion", async () => {
+    const { runtime, onNew } = createRuntime({
+      suggestions: [{ prompt: "hi there" }],
+    });
+    const handle = createAssistantClient(
+      AuiConfig({ threads: RuntimeAdapter(runtime) }),
+    );
+    handle.subscribe(() => {});
+    const aui = handle.getClient();
+    const sent = vi.fn();
+    aui.on({ scope: "thread", event: "composer.send" }, sent);
+
+    flushTapSync(() =>
+      aui.thread.append({ content: [{ type: "text", text: "hi there" }] }),
+    );
+    flushTapSync(() => aui.thread.append("plain text"));
+    await new Promise((resolve) => setTimeout(resolve));
+
+    expect(onNew).toHaveBeenCalledTimes(2);
+    expect(sent).toHaveBeenCalledTimes(2);
+    expect(sent.mock.calls[0]![0]).toMatchObject({
+      chars: 8,
+      attachments: 0,
+      suggestion: true,
+    });
+    expect(sent.mock.calls[1]![0]).toMatchObject({
+      chars: 10,
+      attachments: 0,
+    });
+    expect(sent.mock.calls[1]![0]).not.toHaveProperty("suggestion");
+
+    handle.destroy();
+  });
+
   it("registers the client's model context on the runtime", () => {
     const { runtime } = createRuntime();
     const register = vi.spyOn(runtime, "registerModelContextProvider");

package/src/react/adapters/LocalStorageThreadListAdapter.tsx

@@ -21,6 +21,7 @@ import type {
   ExportedMessageRepository,
   ExportedMessageRepositoryItem,
 } from "../../internal";
+import { isRecord } from "../../utils/json/is-json";
 import {
   RuntimeAdapterProvider,
   type RuntimeAdapters,
@@ -82,9 +83,6 @@ type StoredSystemMessage = Extract<ThreadMessage, { role: "system" }>;
 type StoredUserMessage = Extract<ThreadMessage, { role: "user" }>;
 type StoredAssistantMessage = Extract<ThreadMessage, { role: "assistant" }>;
 
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value);
-
 const parseJSON = (raw: string | null): unknown => {
   if (!raw) return undefined;
   try {

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

@@ -210,6 +210,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"));

package/src/react/client/Interactables.ts

@@ -25,6 +25,7 @@ import {
 } from "../../model-context/interactable-composer-metadata";
 import { notifySubscribers as notifyStateSubscribers } from "../../subscribable/subscribable";
 import { useInteractablePersistenceQueue } from "../interactables-shared/useInteractablePersistenceQueue";
+import { nullProtoRecord } from "../../utils/record";
 
 type RestorePersistedStateOptions = {
   stash: Map<string, unknown>;
@@ -77,8 +78,8 @@ const useInteractablesResource = ({
   persistence,
 }: Unstable_InteractablesConfig = {}): ClientOutput<"unstable_interactables"> => {
   const [state, setState] = useState<Unstable_InteractablesState>(() => ({
-    definitions: {},
-    persistence: {},
+    definitions: nullProtoRecord(),
+    persistence: nullProtoRecord(),
   }));
 
   const clientRef = useAssistantClientRef();
@@ -123,7 +124,8 @@ const useInteractablesResource = ({
   );
 
   const exportState = useCallback((): Unstable_InteractablePersistedState => {
-    const result: Unstable_InteractablePersistedState = {};
+    const result =
+      nullProtoRecord<Unstable_InteractablePersistedState[string]>();
     for (const [id, def] of Object.entries(stateRef.current.definitions)) {
       if (def.scope === "thread") continue; // thread items persist via snapshot, not the adapter
       result[id] = { name: def.name, state: def.state };
@@ -167,7 +169,7 @@ const useInteractablesResource = ({
       }
       setStateAndRef((prev) => {
         let changed = false;
-        const definitions = { ...prev.definitions };
+        const definitions = nullProtoRecord(prev.definitions);
         for (const [id, entry] of Object.entries(saved)) {
           const def = definitions[id];
           if (!def || !shouldApply(id, def)) continue;
@@ -260,10 +262,9 @@ const useInteractablesResource = ({
         if (!existing) return prev;
         return {
           ...prev,
-          definitions: {
-            ...prev.definitions,
+          definitions: nullProtoRecord(prev.definitions, {
             [id]: { ...existing, state: updater(existing.state) },
-          },
+          }),
         };
       });
       if (stateRef.current.definitions[id]?.scope !== "thread") {
@@ -450,8 +451,7 @@ const useInteractablesResource = ({
 
       setStateAndRef((prev) => ({
         ...prev,
-        definitions: {
-          ...prev.definitions,
+        definitions: nullProtoRecord(prev.definitions, {
           [def.id]: {
             id: def.id,
             name: def.name,
@@ -466,7 +466,7 @@ const useInteractablesResource = ({
               loaded ??
               def.initialState,
           },
-        },
+        }),
       }));
 
       return () => {
@@ -498,9 +498,11 @@ const useInteractablesResource = ({
             }
           }
           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 };
         });
       };
     },