@assistant-ui/core 0.3.17 → 0.3.19

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;