@assistant-ui/core 0.3.16 → 0.3.18

package/src/react/primitives/threadList/ThreadListItems.tsx

@@ -6,6 +6,7 @@ import {
   useMemo,
 } from "react";
 import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
+import { useShallowSelector } from "@assistant-ui/store/internal";
 import type { ThreadListItemState } from "../../../store/scopes/thread-list-item";
 import { ThreadListItemByIndexProvider } from "../../providers/ThreadListItemByIndexProvider";
 
@@ -64,15 +65,17 @@ const ThreadListPrimitiveItemsInner: FC<{
   archived: boolean;
   children: (value: { threadListItem: ThreadListItemState }) => ReactNode;
 }> = ({ archived, children }) => {
-  const contentLength = useAuiState((s) =>
-    archived ? s.threads.archivedThreadIds.length : s.threads.threadIds.length,
+  const threadIds = useAuiState(
+    useShallowSelector((s) =>
+      archived ? s.threads.archivedThreadIds : s.threads.threadIds,
+    ),
   );
 
   return useMemo(
     () =>
-      Array.from({ length: contentLength }, (_, index) => (
+      threadIds.map((threadId, index) => (
         <ThreadListItemByIndexProvider
-          key={index}
+          key={threadId}
           index={index}
           archived={archived}
         >
@@ -91,7 +94,7 @@ const ThreadListPrimitiveItemsInner: FC<{
           </RenderChildrenWithAccessor>
         </ThreadListItemByIndexProvider>
       )),
-    [contentLength, archived, children],
+    [threadIds, archived, children],
   );
 };
 

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

@@ -5,9 +5,12 @@ import type { ThreadMessage } from "../../types/message";
 import { RemoteThreadListHookInstanceManager } from "./RemoteThreadListHookInstanceManager";
 
 const makeRuntime = (
-  initial: Partial<Pick<ThreadRuntimeCore, "isRunning" | "messages">> = {},
+  initial: Partial<Pick<ThreadRuntimeCore, "isRunning" | "messages">> & {
+    initialized?: boolean;
+  } = {},
 ) => {
   const subscribers = new Set<() => void>();
+  const eventListeners = new Map<string, Set<() => void>>();
   const runtime = {
     isRunning: initial.isRunning,
     messages: initial.messages ?? [],
@@ -15,6 +18,23 @@ const makeRuntime = (
       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);
+      // mirrors the real core: initialize latches, so a subscriber that
+      // attaches after initialization gets a deferred replay
+      if (event === "initialize" && initial.initialized) {
+        const latched = listeners;
+        queueMicrotask(() => {
+          if (latched.has(callback)) callback();
+        });
+      }
+      return () => listeners.delete(callback);
+    },
   } as unknown as ThreadRuntimeCore & {
     isRunning: boolean | undefined;
     messages: readonly ThreadMessage[];
@@ -23,6 +43,14 @@ const makeRuntime = (
   return {
     runtime,
     subscriberCount: () => subscribers.size,
+    eventListenerCount: () =>
+      [...eventListeners.values()].reduce(
+        (total, listeners) => total + listeners.size,
+        0,
+      ),
+    emit: (event: string) => {
+      for (const callback of eventListeners.get(event) ?? []) callback();
+    },
     setRunning: (isRunning: boolean | undefined) => {
       runtime.isRunning = isRunning;
       for (const callback of subscribers) callback();
@@ -127,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");
@@ -152,6 +213,71 @@ describe("RemoteThreadListHookInstanceManager run tracking", () => {
     manager.stopThreadRuntime("thread-1");
 
     expect(thread.subscriberCount()).toBe(0);
+    expect(thread.eventListenerCount()).toBe(0);
     expect(manager.__internal_isThreadRunning("thread-1")).toBe(false);
   });
+
+  it("forwards every lifecycle event from every tracked thread with its thread id", () => {
+    const manager = makeManager();
+    const events: unknown[] = [];
+    manager.__internal_subscribeThreadEvents((event) => events.push(event));
+
+    start(manager, "thread-1");
+    start(manager, "thread-2");
+    const first = makeRuntime();
+    const second = makeRuntime();
+    publish(manager, "thread-1", first.runtime);
+    publish(manager, "thread-2", second.runtime);
+
+    second.emit("runStart");
+    first.emit("runEnd");
+    first.emit("initialize");
+    second.emit("modelContextUpdate");
+
+    expect(events).toEqual([
+      { threadId: "thread-2", type: "runStart" },
+      { threadId: "thread-1", type: "runEnd" },
+      { threadId: "thread-1", type: "initialize" },
+      { threadId: "thread-2", type: "modelContextUpdate" },
+    ]);
+  });
+
+  it("replays a latched initialize from the surviving runtime after a restart", async () => {
+    const manager = makeManager();
+    const events: unknown[] = [];
+    manager.__internal_subscribeThreadEvents((event) => events.push(event));
+
+    start(manager, "thread-1");
+    const before = makeRuntime({ initialized: true });
+    publish(manager, "thread-1", before.runtime);
+    const after = makeRuntime({ initialized: true });
+    publish(manager, "thread-1", after.runtime);
+    await new Promise<void>((resolve) => queueMicrotask(resolve));
+
+    expect(before.eventListenerCount()).toBe(0);
+    expect(events).toEqual([{ threadId: "thread-1", type: "initialize" }]);
+  });
+
+  it("stops forwarding lifecycle events from a runtime a restart replaced", () => {
+    const manager = makeManager();
+    const events: unknown[] = [];
+    manager.__internal_subscribeThreadEvents((event) => events.push(event));
+
+    start(manager, "thread-1");
+    const before = makeRuntime();
+    publish(manager, "thread-1", before.runtime);
+    const after = makeRuntime();
+    publish(manager, "thread-1", after.runtime);
+
+    before.emit("runEnd");
+    before.emit("initialize");
+    after.emit("runEnd");
+    after.emit("modelContextUpdate");
+
+    expect(before.eventListenerCount()).toBe(0);
+    expect(events).toEqual([
+      { threadId: "thread-1", type: "runEnd" },
+      { threadId: "thread-1", type: "modelContextUpdate" },
+    ]);
+  });
 });

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

@@ -10,17 +10,28 @@ import {
   type ComponentType,
   Fragment,
 } from "react";
-import { create } from "zustand";
 import { useResources, withKey } from "@assistant-ui/tap";
 import type { AssistantClient } from "@assistant-ui/store";
 import { ThreadListItemRuntimeProvider } from "../providers/ThreadListItemRuntimeProvider";
-import type { ThreadRuntimeCore } from "../../runtime/interfaces/thread-runtime-core";
-import type { ThreadListRuntimeCore } from "../../runtime/interfaces/thread-list-runtime-core";
+import type {
+  ThreadRuntimeCore,
+  ThreadRuntimeEventType,
+} from "../../runtime/interfaces/thread-runtime-core";
+import type {
+  ThreadListRuntimeCore,
+  ThreadListRuntimeEvent,
+} from "../../runtime/interfaces/thread-list-runtime-core";
 import type { Unsubscribe } from "../../types/unsubscribe";
-import { BaseSubscribable } from "../../subscribable/subscribable";
+import {
+  BaseSubscribable,
+  notifySubscribers,
+  WritableSubscribable,
+} from "../../subscribable/subscribable";
+import { useSubscribable } from "../../store/runtime-clients/useSubscribable";
 import { getThreadRuntimeCoreIsRunning } from "../../runtime/api/thread-runtime";
 import { ThreadListRuntimeImpl } from "../../runtime/api/thread-list-runtime";
 import { invalidateThreadRuntime } from "../../runtime/utils/thread-runtime-lifecycle";
+import { notifyEventListeners } from "../../utils/notify-event-listeners";
 import {
   useRuntimeAdapters,
   type RuntimeAdapters,
@@ -30,12 +41,22 @@ import {
   type RemoteThreadListHook,
 } from "./RemoteThreadResource";
 
+const THREAD_EVENTS = [
+  "runStart",
+  "runEnd",
+  "initialize",
+  "modelContextUpdate",
+] as const satisfies readonly ThreadRuntimeEventType[];
+
 type RemoteThreadListHookInstance = {
   runtime?: ThreadRuntimeCore | undefined;
   publishedGeneration?: number | undefined;
   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 = {
@@ -44,7 +65,11 @@ type AdapterSnapshot = {
 };
 
 type HostSnapshot = {
-  threads: readonly { id: string; generation: number }[];
+  threads: readonly {
+    id: string;
+    generation: number;
+    destroySignal: AbortSignal;
+  }[];
   hookEpoch: number;
 };
 
@@ -59,14 +84,14 @@ const ProviderRenderDetector: FC<{
 
 export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
   private runtimeHook: RemoteThreadListHook;
-  private readonly adapterStore = create<AdapterSnapshot>(() => ({
+  private readonly adapterStore = new WritableSubscribable<AdapterSnapshot>({
     defaultAdapters: null,
     threadAdapters: new Map(),
-  }));
-  private readonly hostStore = create<HostSnapshot>(() => ({
+  });
+  private readonly hostStore = new WritableSubscribable<HostSnapshot>({
     threads: [],
     hookEpoch: 0,
-  }));
+  });
   private readonly pendingThreadAdapters = new Map<
     string,
     RuntimeAdapters | null
@@ -112,6 +137,7 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
       this.instances.set(threadId, {
         generation,
         isRunning: false,
+        destroy: new AbortController(),
       });
       this._syncHostThreads();
     }
@@ -124,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();
@@ -148,6 +182,17 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     return () => this.runningSubscribers.delete(callback);
   }
 
+  private threadEventSubscribers = new Set<
+    (event: ThreadListRuntimeEvent) => void
+  >();
+
+  public __internal_subscribeThreadEvents(
+    callback: (event: ThreadListRuntimeEvent) => void,
+  ): Unsubscribe {
+    this.threadEventSubscribers.add(callback);
+    return () => this.threadEventSubscribers.delete(callback);
+  }
+
   private _publish = (
     threadId: string,
     runtime: ThreadRuntimeCore,
@@ -170,11 +215,11 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     instance.runtime = runtime;
     instance.publishedGeneration = generation;
     if (previousRuntime !== runtime) {
-      this._trackRunning(instance);
+      this._trackRunning(threadId, instance);
     }
     this._notifySubscribers();
     if (previousRuntime !== undefined && previousRuntime !== runtime) {
-      for (const callback of this.replacedSubscribers) callback();
+      notifySubscribers(this.replacedSubscribers);
     }
   }
 
@@ -187,7 +232,10 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     return () => this.replacedSubscribers.delete(callback);
   }
 
-  private _trackRunning(instance: RemoteThreadListHookInstance) {
+  private _trackRunning(
+    threadId: string,
+    instance: RemoteThreadListHookInstance,
+  ) {
     instance.unsubscribeRunning?.();
 
     const runtime = instance.runtime;
@@ -198,9 +246,23 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     }
 
     this._setRunning(instance, getThreadRuntimeCoreIsRunning(runtime));
-    instance.unsubscribeRunning = runtime.subscribe(() => {
-      this._setRunning(instance, getThreadRuntimeCoreIsRunning(runtime));
-    });
+    const unsubscribers = [
+      runtime.subscribe(() => {
+        this._setRunning(instance, getThreadRuntimeCoreIsRunning(runtime));
+      }),
+      ...THREAD_EVENTS.map((type) =>
+        runtime.unstable_on(type, () => {
+          notifyEventListeners(
+            this.threadEventSubscribers,
+            { threadId, type },
+            `Thread event "${type}"`,
+          );
+        }),
+      ),
+    ];
+    instance.unsubscribeRunning = () => {
+      for (const unsubscribe of unsubscribers) unsubscribe();
+    };
   }
 
   private _setRunning(
@@ -209,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();
@@ -225,16 +288,14 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
   public setRuntimeHook(newRuntimeHook: RemoteThreadListHook) {
     if (this.runtimeHook === newRuntimeHook) return;
     this.runtimeHook = newRuntimeHook;
-    this.hostStore.setState(
-      (state) => ({ ...state, hookEpoch: state.hookEpoch + 1 }),
-      true,
-    );
+    const host = this.hostStore.getState();
+    this.hostStore.setState({ ...host, hookEpoch: host.hookEpoch + 1 });
   }
 
   public __internal_setDefaultAdapters(adapters: RuntimeAdapters | null) {
     const current = this.adapterStore.getState();
     if (current.defaultAdapters === adapters) return;
-    this.adapterStore.setState({ ...current, defaultAdapters: adapters }, true);
+    this.adapterStore.setState({ ...current, defaultAdapters: adapters });
   }
 
   public __internal_setThreadAdapters(
@@ -245,7 +306,7 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     const next = new Map(current.threadAdapters);
     if (adapters === null) next.delete(threadId);
     else next.set(threadId, adapters);
-    this.adapterStore.setState({ ...current, threadAdapters: next }, true);
+    this.adapterStore.setState({ ...current, threadAdapters: next });
   }
 
   public __internal_dispose() {
@@ -255,23 +316,25 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
   }
 
   private _syncHostThreads() {
-    this.hostStore.setState(
-      (state) => ({
-        ...state,
-        threads: Array.from(this.instances.entries()).map(
-          ([id, { generation }]) => ({ id, generation }),
-        ),
-      }),
-      true,
-    );
+    const host = this.hostStore.getState();
+    this.hostStore.setState({
+      ...host,
+      threads: Array.from(this.instances.entries()).map(
+        ([id, { generation, destroy }]) => ({
+          id,
+          generation,
+          destroySignal: destroy.signal,
+        }),
+      ),
+    });
   }
 
   public __internal_useHost(parentClient: AssistantClient) {
-    const { threads, hookEpoch } = this.hostStore();
-    const adapters = this.adapterStore();
+    const { threads, hookEpoch } = useSubscribable(this.hostStore);
+    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);
@@ -285,6 +348,7 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
             parentClient,
             adapters: threadAdapters,
             publish: this._publish,
+            destroySignal,
           }),
         );
       }),
@@ -294,7 +358,7 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
   public __internal_RenderThreadRuntimes: FC<{
     provider: ComponentType<PropsWithChildren>;
   }> = ({ provider }) => {
-    this.hostStore();
+    useSubscribable(this.hostStore);
 
     return Array.from(this.instances.entries()).map(
       ([threadId, { generation }]) => (