@assistant-ui/core 0.3.17 → 0.3.18

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/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/runtimes/RemoteThreadListHookInstanceManager.destroy.test.tsx

@@ -0,0 +1,172 @@
+import { describe, expect, it } from "vitest";
+import type { ThreadListRuntimeCore } from "../../runtime/interfaces/thread-list-runtime-core";
+import type { ThreadRuntimeCore } from "../../runtime/interfaces/thread-runtime-core";
+import { RemoteThreadListHookInstanceManager } from "./RemoteThreadListHookInstanceManager";
+
+const makeManager = () =>
+  new RemoteThreadListHookInstanceManager(
+    () => ({}) as never,
+    {} as ThreadListRuntimeCore,
+  );
+
+// No AdapterSink attaches a runtime here, so the start and restart promises
+// stay pending or reject on stop; neither is what these tests are about.
+const start = (manager: RemoteThreadListHookInstanceManager, id: string) => {
+  manager.startThreadRuntime(id).catch(() => {});
+};
+const restart = (manager: RemoteThreadListHookInstanceManager, id: string) => {
+  manager.__internal_restartThreadRuntime(id).catch(() => {});
+};
+
+const publishedSignal = (
+  manager: RemoteThreadListHookInstanceManager,
+  id: string,
+) => {
+  const { hostStore } = manager as unknown as {
+    hostStore: {
+      getState: () => {
+        threads: readonly { id: string; destroySignal: AbortSignal }[];
+      };
+    };
+  };
+  return hostStore.getState().threads.find((thread) => thread.id === id)
+    ?.destroySignal;
+};
+
+describe("RemoteThreadListHookInstanceManager destroy signal", () => {
+  it("publishes a live signal for each started thread", () => {
+    const manager = makeManager();
+    start(manager, "thread-1");
+
+    expect(publishedSignal(manager, "thread-1")?.aborted).toBe(false);
+  });
+
+  it("aborts the thread's signal when its runtime stops", () => {
+    const manager = makeManager();
+    start(manager, "thread-1");
+    const signal = publishedSignal(manager, "thread-1")!;
+
+    manager.stopThreadRuntime("thread-1");
+
+    expect(signal.aborted).toBe(true);
+  });
+
+  it("leaves sibling threads untouched when one stops", () => {
+    const manager = makeManager();
+    start(manager, "thread-1");
+    start(manager, "thread-2");
+    const sibling = publishedSignal(manager, "thread-2")!;
+
+    manager.stopThreadRuntime("thread-1");
+
+    expect(sibling.aborted).toBe(false);
+  });
+
+  it("hands the next generation a fresh signal on restart", () => {
+    const manager = makeManager();
+    start(manager, "thread-1");
+    const first = publishedSignal(manager, "thread-1")!;
+
+    restart(manager, "thread-1");
+    const second = publishedSignal(manager, "thread-1")!;
+
+    expect(first.aborted).toBe(true);
+    expect(second).not.toBe(first);
+    expect(second.aborted).toBe(false);
+  });
+
+  it("aborts every thread when the manager is disposed", () => {
+    const manager = makeManager();
+    start(manager, "thread-1");
+    start(manager, "thread-2");
+    const signals = [
+      publishedSignal(manager, "thread-1")!,
+      publishedSignal(manager, "thread-2")!,
+    ];
+
+    manager.__internal_dispose();
+
+    expect(signals.map((signal) => signal.aborted)).toEqual([true, true]);
+  });
+});
+
+const makeRunningRuntime = () => {
+  const subscribers = new Set<() => void>();
+  const eventListeners = new Map<string, Set<() => void>>();
+  const runtime = {
+    isRunning: true,
+    messages: [],
+    subscribe: (callback: () => void) => {
+      subscribers.add(callback);
+      return () => subscribers.delete(callback);
+    },
+    unstable_on: (event: string, callback: () => void) => {
+      let listeners = eventListeners.get(event);
+      if (!listeners) {
+        listeners = new Set();
+        eventListeners.set(event, listeners);
+      }
+      listeners.add(callback);
+      return () => listeners.delete(callback);
+    },
+  } as unknown as ThreadRuntimeCore & { isRunning: boolean };
+
+  return {
+    runtime,
+    // what a stopOnClientDestroy consumer does when the destroy signal fires
+    stop: () => {
+      runtime.isRunning = false;
+      for (const callback of eventListeners.get("runEnd") ?? []) callback();
+      for (const callback of subscribers) callback();
+    },
+  };
+};
+
+const publish = (
+  manager: RemoteThreadListHookInstanceManager,
+  threadId: string,
+  runtime: ThreadRuntimeCore,
+) => {
+  const internals = manager as unknown as {
+    instances: Map<string, { generation: number }>;
+    _publishThreadRuntime: (
+      threadId: string,
+      runtime: ThreadRuntimeCore,
+      generation: number,
+    ) => void;
+  };
+  internals._publishThreadRuntime(
+    threadId,
+    runtime,
+    internals.instances.get(threadId)!.generation,
+  );
+};
+
+describe("RemoteThreadListHookInstanceManager restart teardown", () => {
+  it("keeps the outgoing generation's terminal events off the thread's subscribers", () => {
+    const manager = makeManager();
+    start(manager, "thread-1");
+    const { runtime, stop } = makeRunningRuntime();
+    publish(manager, "thread-1", runtime);
+
+    const signal = publishedSignal(manager, "thread-1")!;
+    signal.addEventListener("abort", stop, { once: true });
+
+    const events: string[] = [];
+    manager.__internal_subscribeThreadEvents((event) =>
+      events.push(event.type),
+    );
+    const runningChanges: boolean[] = [];
+    manager.__internal_subscribeRunningChanged(() =>
+      runningChanges.push(manager.__internal_isThreadRunning("thread-1")),
+    );
+    expect(manager.__internal_isThreadRunning("thread-1")).toBe(true);
+
+    restart(manager, "thread-1");
+
+    expect(signal.aborted).toBe(true);
+    expect(events).toEqual([]);
+    expect(runningChanges).toEqual([]);
+    expect(manager.__internal_isThreadRunning("thread-1")).toBe(true);
+  });
+});

package/src/react/runtimes/RemoteThreadListHookInstanceManager.running.test.tsx

@@ -155,6 +155,39 @@ describe("RemoteThreadListHookInstanceManager run tracking", () => {
     expect(onChange).toHaveBeenCalledTimes(2);
   });
 
+  it("notifies every running subscriber when one throws", () => {
+    const manager = makeManager();
+    start(manager, "thread-1");
+    const thread = makeRuntime({ isRunning: false });
+    publish(manager, "thread-1", thread.runtime);
+    const error = new Error("listener failed");
+    manager.__internal_subscribeRunningChanged(() => {
+      throw error;
+    });
+    const laterSubscriber = vi.fn();
+    manager.__internal_subscribeRunningChanged(laterSubscriber);
+
+    expect(() => thread.setRunning(true)).toThrow(error);
+    expect(laterSubscriber).toHaveBeenCalledOnce();
+  });
+
+  it("notifies every replacement subscriber when one throws", () => {
+    const manager = makeManager();
+    start(manager, "thread-1");
+    publish(manager, "thread-1", makeRuntime().runtime);
+    const error = new Error("listener failed");
+    manager.__internal_subscribeRuntimeReplaced(() => {
+      throw error;
+    });
+    const laterSubscriber = vi.fn();
+    manager.__internal_subscribeRuntimeReplaced(laterSubscriber);
+
+    expect(() => publish(manager, "thread-1", makeRuntime().runtime)).toThrow(
+      error,
+    );
+    expect(laterSubscriber).toHaveBeenCalledOnce();
+  });
+
   it("moves tracking to the runtime a restart publishes", () => {
     const manager = makeManager();
     start(manager, "thread-1");

package/src/react/runtimes/RemoteThreadListHookInstanceManager.test.tsx

@@ -37,13 +37,19 @@ describe("RemoteThreadListHookInstanceManager", () => {
     const internals = manager as unknown as {
       instances: Map<
         string,
-        { runtime: typeof runtime; generation: number; isRunning: boolean }
+        {
+          runtime: typeof runtime;
+          generation: number;
+          isRunning: boolean;
+          destroy: AbortController;
+        }
       >;
     };
     internals.instances.set("thread-1", {
       runtime,
       generation: 0,
       isRunning: false,
+      destroy: new AbortController(),
     });
 
     const appendPromise = runtime.append({

package/src/react/runtimes/RemoteThreadListHookInstanceManager.tsx

@@ -24,6 +24,7 @@ import type {
 import type { Unsubscribe } from "../../types/unsubscribe";
 import {
   BaseSubscribable,
+  notifySubscribers,
   WritableSubscribable,
 } from "../../subscribable/subscribable";
 import { useSubscribable } from "../../store/runtime-clients/useSubscribable";
@@ -53,6 +54,9 @@ type RemoteThreadListHookInstance = {
   generation: number;
   isRunning: boolean;
   unsubscribeRunning?: Unsubscribe | undefined;
+  // Permanent teardown of the thread's runtime, aborted when the thread is
+  // stopped or its runtime restarted. A soft unmount leaves it armed.
+  destroy: AbortController;
 };
 
 type AdapterSnapshot = {
@@ -61,7 +65,11 @@ type AdapterSnapshot = {
 };
 
 type HostSnapshot = {
-  threads: readonly { id: string; generation: number }[];
+  threads: readonly {
+    id: string;
+    generation: number;
+    destroySignal: AbortSignal;
+  }[];
   hookEpoch: number;
 };
 
@@ -129,6 +137,7 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
       this.instances.set(threadId, {
         generation,
         isRunning: false,
+        destroy: new AbortController(),
       });
       this._syncHostThreads();
     }
@@ -141,6 +150,14 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     if (!instance) return this.startThreadRuntime(threadId);
 
     if (instance.runtime) invalidateThreadRuntime(instance.runtime);
+    // Detach before aborting, as stopThreadRuntime does: the abort runs the
+    // destroy listeners synchronously, and a listener that stops the outgoing
+    // runtime would otherwise emit that generation's terminal events through
+    // the subscription the next generation is about to reuse.
+    instance.unsubscribeRunning?.();
+    instance.unsubscribeRunning = undefined;
+    instance.destroy.abort();
+    instance.destroy = new AbortController();
     instance.generation = this.nextGeneration++;
     this._syncHostThreads();
     this._notifySubscribers();
@@ -202,7 +219,7 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     }
     this._notifySubscribers();
     if (previousRuntime !== undefined && previousRuntime !== runtime) {
-      for (const callback of this.replacedSubscribers) callback();
+      notifySubscribers(this.replacedSubscribers);
     }
   }
 
@@ -254,13 +271,14 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
   ) {
     if (instance.isRunning === isRunning) return;
     instance.isRunning = isRunning;
-    for (const callback of this.runningSubscribers) callback();
+    notifySubscribers(this.runningSubscribers);
   }
 
   public stopThreadRuntime(threadId: string) {
     const instance = this.instances.get(threadId);
     if (instance?.runtime) invalidateThreadRuntime(instance.runtime);
     instance?.unsubscribeRunning?.();
+    instance?.destroy.abort();
     this.instances.delete(threadId);
     this.pendingThreadAdapters.delete(threadId);
     this._syncHostThreads();
@@ -302,7 +320,11 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     this.hostStore.setState({
       ...host,
       threads: Array.from(this.instances.entries()).map(
-        ([id, { generation }]) => ({ id, generation }),
+        ([id, { generation, destroy }]) => ({
+          id,
+          generation,
+          destroySignal: destroy.signal,
+        }),
       ),
     });
   }
@@ -312,7 +334,7 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     const adapters = useSubscribable(this.adapterStore);
     const runtimeHook = this.runtimeHook;
     return useResources(
-      threads.map(({ id, generation }) => {
+      threads.map(({ id, generation, destroySignal }) => {
         const threadAdapters = this.pendingThreadAdapters.has(id)
           ? this.pendingThreadAdapters.get(id)!
           : (adapters.threadAdapters.get(id) ?? adapters.defaultAdapters);
@@ -326,6 +348,7 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
             parentClient,
             adapters: threadAdapters,
             publish: this._publish,
+            destroySignal,
           }),
         );
       }),

package/src/react/runtimes/RemoteThreadListThreadListRuntimeCore.load-error.test.ts

@@ -0,0 +1,132 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { RemoteThreadListResponse } from "../../runtimes/remote-thread-list/types";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+} from "../../tests/remote-thread-list-test-helpers";
+
+const loadedThread = {
+  status: "regular" as const,
+  remoteId: "thread-1",
+  externalId: "thread-1",
+  title: "Thread 1",
+};
+
+describe("RemoteThreadListThreadListRuntimeCore load errors", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("keeps loaded threads and reports a later load failure", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const error = new Error("network error");
+    const list = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockResolvedValueOnce({ threads: [loadedThread] })
+      .mockRejectedValueOnce(error);
+    const core = createCore(makeAdapter({ list }));
+
+    await core.getLoadThreadsPromise();
+    await core.reload();
+
+    expect(core.threadIds).toEqual(["thread-1"]);
+    expect(core.loadError).toBe(error);
+    expect(core.isLoading).toBe(false);
+  });
+
+  it("removes the previous adapter's threads when its replacement load fails", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const error = new Error("replacement failed");
+    const core = createCore(
+      makeAdapter({
+        list: vi.fn(async () => ({ threads: [loadedThread] })),
+      }),
+    );
+    await core.getLoadThreadsPromise();
+
+    const replacement = makeAdapter({
+      list: vi.fn(async () => {
+        throw error;
+      }),
+    });
+    core.__internal_setOptions({
+      adapter: replacement,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(core.threadIds).toEqual([]);
+    expect(core.archivedThreadIds).toEqual([]);
+    expect(core.getItemById("thread-1")).toBeUndefined();
+    expect(core.loadError).toBe(error);
+  });
+
+  it("clears the previous adapter's error before loading its replacement", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const error = new Error("network error");
+    const core = createCore(
+      makeAdapter({
+        list: vi.fn(async () => {
+          throw error;
+        }),
+      }),
+    );
+    await core.getLoadThreadsPromise();
+    expect(core.loadError).toBe(error);
+
+    const replacementLoad = deferred<RemoteThreadListResponse>();
+    const replacementList = vi.fn(() => replacementLoad.promise);
+    core.__internal_setOptions({
+      adapter: makeAdapter({ list: replacementList }),
+      runtimeHook: () => ({}) as never,
+    });
+
+    expect(replacementList).not.toHaveBeenCalled();
+    expect(core.loadError).toBeUndefined();
+
+    const loadPromise = core.getLoadThreadsPromise();
+    replacementLoad.resolve({ threads: [] });
+    await loadPromise;
+  });
+
+  it("clears the error when a reload resolves", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const error = new Error("network error");
+    const list = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockRejectedValueOnce(error)
+      .mockResolvedValueOnce({ threads: [loadedThread] });
+    const core = createCore(makeAdapter({ list }));
+
+    await core.getLoadThreadsPromise();
+    expect(core.loadError).toBe(error);
+
+    await core.reload();
+
+    expect(core.loadError).toBeUndefined();
+    expect(core.threadIds).toEqual(["thread-1"]);
+  });
+
+  it("clears the error while a later load is in progress", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const error = new Error("network error");
+    const retry = deferred<RemoteThreadListResponse>();
+    const list = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockRejectedValueOnce(error)
+      .mockReturnValueOnce(retry.promise);
+    const core = createCore(makeAdapter({ list }));
+
+    await core.getLoadThreadsPromise();
+    expect(core.loadError).toBe(error);
+
+    const retryPromise = core.reload();
+
+    expect(core.isLoading).toBe(true);
+    expect(core.loadError).toBeUndefined();
+
+    retry.resolve({ threads: [] });
+    await retryPromise;
+  });
+});

package/src/react/runtimes/RemoteThreadListThreadListRuntimeCore.switch-delete.test.ts

@@ -120,6 +120,111 @@ describe("RemoteThreadListThreadListRuntimeCore switch/delete ordering", () => {
     expect(core.getItemById(core.mainThreadId!)).toBeDefined();
   });
 
+  it("preserves thread cleanup state when remote deletion fails", async () => {
+    const error = new Error("delete failed");
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          {
+            status: "regular" as const,
+            remoteId: "thread-b",
+            externalId: "thread-b",
+            title: "Thread B",
+          },
+        ],
+      })),
+      delete: vi.fn(async () => {
+        throw error;
+      }),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+    const data = core.getItemById("thread-b")!;
+    const internals = core as unknown as {
+      _hookManager: { stopThreadRuntime: (id: string) => void };
+      _titleStates: Map<string, unknown>;
+    };
+    const stopThreadRuntime = vi.spyOn(
+      internals._hookManager,
+      "stopThreadRuntime",
+    );
+    const titleState = {};
+    internals._titleStates.set(data.id, titleState);
+
+    await expect(core.delete(data.id)).rejects.toBe(error);
+
+    expect(core.getItemById(data.id)).toBeDefined();
+    expect(stopThreadRuntime).not.toHaveBeenCalled();
+    expect(internals._titleStates.get(data.id)).toBe(titleState);
+  });
+
+  it("clears the deleted thread's title state on successful deletion", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          {
+            status: "regular" as const,
+            remoteId: "thread-b",
+            externalId: "thread-b",
+            title: "Thread B",
+          },
+        ],
+      })),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+    const data = core.getItemById("thread-b")!;
+    const internals = core as unknown as {
+      _titleStates: Map<string, unknown>;
+    };
+    internals._titleStates.set(data.id, {});
+
+    await core.delete(data.id);
+
+    expect(core.getItemById(data.id)).toBeUndefined();
+    expect(internals._titleStates.has(data.id)).toBe(false);
+  });
+
+  it("stops the thread runtime when the adapter changes during a successful deletion", async () => {
+    const removal = deferred<void>();
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          {
+            status: "regular" as const,
+            remoteId: "thread-b",
+            externalId: "thread-b",
+            title: "Thread B",
+          },
+        ],
+      })),
+      delete: vi.fn(() => removal.promise),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+    const internals = core as unknown as {
+      _hookManager: { stopThreadRuntime: (id: string) => void };
+    };
+    const stopThreadRuntime = vi.spyOn(
+      internals._hookManager,
+      "stopThreadRuntime",
+    );
+
+    const deletion = core.delete("thread-b");
+    await vi.waitFor(() => {
+      expect(adapter.delete).toHaveBeenCalledWith("thread-b");
+    });
+    core.__internal_setOptions({
+      adapter: makeAdapter(),
+      runtimeHook: () => ({}) as never,
+    });
+    removal.resolve();
+    await deletion;
+
+    expect(core.getItemById("thread-b")).toBeUndefined();
+    expect(stopThreadRuntime).toHaveBeenCalledWith("thread-b");
+  });
+
   it("does not unarchive again when the target became regular during initialization", async () => {
     const initialization = deferred<{
       remoteId: string;