@assistant-ui/core 0.3.17 → 0.3.19

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();
@@ -87,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 }>(),
   );
@@ -123,7 +127,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 +172,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 +265,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") {
@@ -408,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(
@@ -450,8 +456,7 @@ const useInteractablesResource = ({
 
       setStateAndRef((prev) => ({
         ...prev,
-        definitions: {
-          ...prev.definitions,
+        definitions: nullProtoRecord(prev.definitions, {
           [def.id]: {
             id: def.id,
             name: def.name,
@@ -466,7 +471,7 @@ const useInteractablesResource = ({
               loaded ??
               def.initialState,
           },
-        },
+        }),
       }));
 
       return () => {
@@ -497,10 +502,13 @@ const useInteractablesResource = ({
               detachedAppStateRef.current.set(def.id, existing.state);
             }
           }
+          partialSchemaSourceRef.current.delete(def.id);
           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/client/RemoteThreadList.background.test.ts

@@ -88,15 +88,16 @@ const makeAdapter = (
   ...overrides,
 });
 
-const mountBackgroundList = (
+const mountThreadList = (
   adapter: RemoteThreadListAdapter,
   tracker: Tracker,
+  backgroundThreads = true,
 ) => {
   const handle = createAssistantClient(
     AuiConfig({
       threads: RemoteThreadList({
         adapter,
-        backgroundThreads: true,
+        backgroundThreads,
         thread: (id) =>
           withKey(id, TrackedThread({ threadId: id, tracker }) as never),
       }),
@@ -112,7 +113,148 @@ const createTracker = (): Tracker => ({
   running: new Set(),
 });
 
+const deferred = <T>() => {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((resolvePromise) => {
+    resolve = resolvePromise;
+  });
+  return { promise, resolve };
+};
+
 describe("RemoteThreadList backgroundThreads", () => {
+  it("keeps the running initialized body when its listed duplicate is selected", async () => {
+    const list = deferred<{
+      threads: [
+        {
+          status: "regular";
+          remoteId: string;
+          externalId: string;
+          title: string;
+        },
+      ];
+    }>();
+    const initialize = deferred<{
+      remoteId: string;
+      externalId: undefined;
+    }>();
+    const adapter = makeAdapter({
+      list: vi.fn(() => list.promise),
+      initialize: vi.fn(() => initialize.promise),
+    });
+    const tracker = createTracker();
+    const handle = mountThreadList(adapter, tracker);
+    const aui = handle.getClient();
+    const loadPromise = aui.threads.getLoadThreadsPromise();
+    const localId = aui.threads.getState().mainThreadId;
+    tracker.running.add(localId);
+    const initializePromise = aui.threads.item("main").initialize();
+
+    list.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "remote-1",
+          externalId: "remote-1",
+          title: "Listed thread",
+        },
+      ],
+    });
+    await loadPromise;
+    flushTapSync(() => aui.threads.switchToThread("remote-1"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("remote-1");
+      expect(tracker.alive.has("remote-1")).toBe(true);
+    });
+    const localMountCount = tracker.mounts.filter(
+      (id) => id === localId,
+    ).length;
+
+    initialize.resolve({ remoteId: "remote-1", externalId: undefined });
+    await initializePromise;
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe(localId);
+      expect(aui.threads.getState().threadIds).toEqual([localId]);
+      expect(tracker.alive.has(localId)).toBe(true);
+      expect(tracker.alive.has("remote-1")).toBe(false);
+    });
+
+    expect(aui.threads.item({ id: "remote-1" }).getState().id).toBe(localId);
+    expect(aui.threads.item("main").getState().id).toBe(localId);
+    expect(aui.threads.item("main").getState().externalId).toBe("remote-1");
+    expect(aui.threads.item("main").getState().title).toBe("Listed thread");
+    expect(aui.threads.item("main").getState().isRunning).toBe(true);
+    expect(tracker.mounts.filter((id) => id === localId)).toHaveLength(
+      localMountCount,
+    );
+    handle.destroy();
+  });
+
+  it("keeps the mounted listed body when an unmounted initialization completes", async () => {
+    const list = deferred<{
+      threads: [
+        {
+          status: "regular";
+          remoteId: string;
+          externalId: string;
+          title: string;
+        },
+      ];
+    }>();
+    const initialize = deferred<{
+      remoteId: string;
+      externalId: undefined;
+    }>();
+    const adapter = makeAdapter({
+      list: vi.fn(() => list.promise),
+      initialize: vi.fn(() => initialize.promise),
+    });
+    const tracker = createTracker();
+    const handle = mountThreadList(adapter, tracker, false);
+    const aui = handle.getClient();
+    const loadPromise = aui.threads.getLoadThreadsPromise();
+    const localId = aui.threads.getState().mainThreadId;
+    const initializePromise = aui.threads.item("main").initialize();
+
+    list.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "remote-1",
+          externalId: "external-1",
+          title: "Listed thread",
+        },
+      ],
+    });
+    await loadPromise;
+    flushTapSync(() => aui.threads.switchToThread("remote-1"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("remote-1");
+      expect(tracker.alive.has(localId)).toBe(false);
+      expect(tracker.alive.has("remote-1")).toBe(true);
+    });
+    const listedMountCount = tracker.mounts.filter(
+      (id) => id === "remote-1",
+    ).length;
+
+    initialize.resolve({ remoteId: "remote-1", externalId: undefined });
+    await initializePromise;
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("remote-1");
+      expect(aui.threads.getState().threadIds).toEqual(["remote-1"]);
+      expect(tracker.alive.has("remote-1")).toBe(true);
+    });
+
+    expect(aui.threads.item("main").getState()).toMatchObject({
+      id: "remote-1",
+      externalId: "external-1",
+      title: "Listed thread",
+    });
+    expect(tracker.mounts.filter((id) => id === "remote-1")).toHaveLength(
+      listedMountCount,
+    );
+    handle.destroy();
+  });
+
   it("keeps a switched-away thread mounted with live isRunning", async () => {
     const adapter = makeAdapter({
       list: vi.fn(async () => ({
@@ -120,7 +262,7 @@ describe("RemoteThreadList backgroundThreads", () => {
       })),
     });
     const tracker = createTracker();
-    const handle = mountBackgroundList(adapter, tracker);
+    const handle = mountThreadList(adapter, tracker);
     const aui = handle.getClient();
     await aui.threads.getLoadThreadsPromise();
     await vi.waitFor(() => {
@@ -164,7 +306,7 @@ describe("RemoteThreadList backgroundThreads", () => {
       })),
     });
     const tracker = createTracker();
-    const handle = mountBackgroundList(adapter, tracker);
+    const handle = mountThreadList(adapter, tracker);
     const aui = handle.getClient();
     await aui.threads.getLoadThreadsPromise();
     await vi.waitFor(() => {
@@ -260,7 +402,7 @@ describe("RemoteThreadList backgroundThreads", () => {
     });
     const tracker = createTracker();
     tracker.messagesOf = () => [{ status: { type: "complete" } }];
-    const handle = mountBackgroundList(adapter, tracker);
+    const handle = mountThreadList(adapter, tracker);
     const aui = handle.getClient();
     await aui.threads.getLoadThreadsPromise();
     await vi.waitFor(() => {
@@ -350,7 +492,7 @@ describe("RemoteThreadList backgroundThreads", () => {
       list: vi.fn(async () => ({ threads: listed })),
     });
     const tracker = createTracker();
-    const handle = mountBackgroundList(adapter, tracker);
+    const handle = mountThreadList(adapter, tracker);
     const aui = handle.getClient();
     await aui.threads.getLoadThreadsPromise();
     const localId = aui.threads.getState().mainThreadId;

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

@@ -1,6 +1,6 @@
 // @vitest-environment jsdom
 
-import { createRef, startTransition, Suspense } from "react";
+import { createRef, startTransition, Suspense, useLayoutEffect } from "react";
 import { act, render, waitFor } from "@testing-library/react";
 import { resource, withKey } from "@assistant-ui/tap";
 import {
@@ -68,6 +68,47 @@ const makeAdapter = (): RemoteThreadListAdapter => ({
 });
 
 describe("RemoteThreadList concurrent rendering", () => {
+  it("reloads through the committed adapter from a descendant layout effect", async () => {
+    const adapterA = makeAdapter();
+    const adapterB = makeAdapter();
+
+    const ReloadOnSwap = ({ workspace }: { workspace: string }) => {
+      const aui = useAui();
+      useLayoutEffect(() => {
+        if (workspace === "A") return;
+        void aui.threads.reload();
+      }, [aui, workspace]);
+      return null;
+    };
+    const App = ({
+      adapter,
+      workspace,
+    }: {
+      adapter: RemoteThreadListAdapter;
+      workspace: string;
+    }) => (
+      <AuiProvider
+        config={AuiConfig({
+          threads: RemoteThreadList({
+            adapter,
+            thread: () => StubThread() as never,
+          }),
+        })}
+      >
+        <ReloadOnSwap workspace={workspace} />
+      </AuiProvider>
+    );
+
+    const view = render(<App adapter={adapterA} workspace="A" />);
+    await waitFor(() => expect(adapterA.list).toHaveBeenCalledOnce());
+
+    act(() => {
+      view.rerender(<App adapter={adapterB} workspace="B" />);
+    });
+    await waitFor(() => expect(adapterB.list).toHaveBeenCalled());
+    expect(adapterA.list).toHaveBeenCalledOnce();
+  });
+
   it("keeps actions scoped to the committed adapter", async () => {
     const adapterA = makeAdapter();
     const adapterB = makeAdapter();