@assistant-ui/core 0.3.16 → 0.3.17

package/src/runtimes/external-store/external-store-adapter.ts

@@ -1,4 +1,8 @@
-import type { AppendMessage, ThreadMessage } from "../../types/message";
+import type {
+  AppendMessage,
+  ThreadMessage,
+  ToolCallMessagePart,
+} from "../../types/message";
 import type { ThreadMessageLike } from "../../runtime/utils/thread-message-like";
 import type { AttachmentAdapter } from "../../adapters/attachment";
 import type {
@@ -14,7 +18,10 @@ import type {
   ResumeRunConfig,
   ThreadSuggestion,
 } from "../../runtime/interfaces/thread-runtime-core";
-import type { ExportedMessageRepository } from "../../runtime/utils/message-repository";
+import type {
+  ExportedMessageRepository,
+  MessageRepository,
+} from "../../runtime/utils/message-repository";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
 import type { ToolExecutionStatus } from "../tool-invocations/ToolInvocationTracker";
 import type { ExternalThreadQueueAdapter } from "../../runtime/queue/external-thread-queue-adapter";
@@ -105,6 +112,15 @@ type ExternalStoreAdapterBase<T> = {
   isLoading?: boolean | undefined;
   messages?: readonly T[];
   messageRepository?: ExportedMessageRepository;
+  /**
+   * An externally owned message repository instance. When provided, the
+   * thread runtime adopts it as its branch store and swaps to it atomically
+   * whenever a different instance is passed, so hosts that route multiple
+   * conversations through one runtime keep each conversation's history and
+   * branches isolated in its own instance. Omit it to keep the runtime's own
+   * repository.
+   */
+  unstable_messageRepositoryInstance?: MessageRepository | undefined;
   suggestions?: readonly ThreadSuggestion[] | undefined;
   state?: ReadonlyJSONValue | undefined;
   extras?: unknown;
@@ -207,6 +223,26 @@ type ExternalStoreAdapterBase<T> = {
    * `modelContent` populated when present.
    */
   unstable_enableToolInvocations?: boolean | undefined;
+  /**
+   * Decides whether a tool call's result is produced on the client. Only
+   * consulted when `unstable_enableToolInvocations` is `true`.
+   *
+   * A provider that runs tools itself answers its own calls, and its result
+   * arrives one or more snapshots after the call's arguments complete. In
+   * that window the call is complete and result-less, so a registered tool
+   * of the same name would otherwise execute locally and produce a result
+   * the provider never asked for. An adapter that can tell the two apart
+   * supplies this predicate; it is read once per tool call, when the call is
+   * first observed live.
+   *
+   * The predicate is also what licenses running a frontend tool while the
+   * provider's run is still open. Without it, ownership is unknown until the
+   * run ends, so a registered tool executes only once the run's outcome is
+   * known and cannot fire on a call the provider was about to answer or gate.
+   */
+  unstable_isClientToolCall?:
+    | ((toolCall: ToolCallMessagePart) => boolean)
+    | undefined;
   /**
    * Receives the current per-tool-call execution status map whenever it
    * changes. Only invoked when `unstable_enableToolInvocations` is `true`

package/src/runtimes/external-store/external-store-thread-runtime-core.ts

@@ -1,3 +1,4 @@
+import { shallowEqual } from "@assistant-ui/store/client";
 import type { AppendMessage, ThreadMessage } from "../../types/message";
 import type { Attachment } from "../../types/attachment";
 import type {
@@ -28,6 +29,7 @@ import {
   type ThreadMessageLike,
 } from "../../runtime/utils/thread-message-like";
 import { getThreadMessageText } from "../../utils/text";
+import { shallowArrayEqual } from "../../runtime/utils/external-message-conversion";
 import type {
   RuntimeCapabilities,
   ThreadRuntimeCore,
@@ -43,6 +45,7 @@ import {
   MessageRepository,
 } from "../../runtime/utils/message-repository";
 import { generateId } from "../../utils/id";
+import { walkToolCallTree } from "../../runtime/utils/tool-call-tree";
 import {
   ToolInvocationTracker,
   type ToolExecutionStatus,
@@ -57,7 +60,7 @@ import {
 const EMPTY_ARRAY: readonly ThreadSuggestion[] = Object.freeze([]);
 
 const observeAdapterCallback = (
-  name: "onAddToolResult" | "onRespondToToolApproval" | "onCancel",
+  name: "onAddToolResult" | "onCancel",
   result: Promise<void> | void,
 ) => {
   void Promise.resolve(result).catch((error) => {
@@ -68,15 +71,6 @@ const observeAdapterCallback = (
   });
 };
 
-const shallowEqual = (a: object, b: object): boolean => {
-  const aKeys = Object.keys(a);
-  if (aKeys.length !== Object.keys(b).length) return false;
-  for (const key of aKeys) {
-    if ((a as any)[key] !== (b as any)[key]) return false;
-  }
-  return true;
-};
-
 export const hasUpcomingMessage = (
   isRunning: boolean,
   messages: readonly ThreadMessage[],
@@ -154,6 +148,11 @@ export class ExternalStoreThreadRuntimeCore
   // and a delete whose confirmation races a send keeps its eviction.
   private _pendingDeleteEvictions = new Set<string>();
 
+  // Placeholder id for the upcoming assistant message, reused across snapshot
+  // passes while the same tail message awaits its response so the placeholder
+  // keeps one identity per response.
+  private _optimistic: { id: string; parentId: string | null } | null = null;
+
   private _store!: ExternalStoreAdapter<any>;
 
   private _getInitializePromise?: () => Promise<unknown> | undefined;
@@ -246,6 +245,14 @@ export class ExternalStoreThreadRuntimeCore
     const oldStore = this._store as ExternalStoreAdapter<any> | undefined;
     this._store = store;
     const isRunning = this._getEffectiveIsRunning(store);
+    const repositoryInstance = store.unstable_messageRepositoryInstance;
+    const repositoryChanged =
+      repositoryInstance !== undefined &&
+      repositoryInstance !== this.repository;
+    if (repositoryChanged) {
+      this.repository = repositoryInstance;
+      this._pendingDeleteEvictions.clear();
+    }
     if (oldStore?.queue !== store.queue) {
       this._transformedQueue = undefined;
       store.queue?.__internal_setDispatchTransform?.((message) => {
@@ -296,6 +303,7 @@ export class ExternalStoreThreadRuntimeCore
       // Handle messageRepository
       if (
         oldStore &&
+        !repositoryChanged &&
         oldStore.isRunning === store.isRunning &&
         oldStore.messageRepository === store.messageRepository &&
         previousIsRunning === isRunning
@@ -308,7 +316,11 @@ export class ExternalStoreThreadRuntimeCore
       const headId =
         store.messageRepository.headId ?? incoming.at(-1)?.message.id ?? null;
 
-      if (oldStore && oldStore.messageRepository === store.messageRepository) {
+      if (
+        oldStore &&
+        !repositoryChanged &&
+        oldStore.messageRepository === store.messageRepository
+      ) {
         this.repository.resetHead(headId);
         messages = this.repository.getMessages();
       } else {
@@ -333,6 +345,7 @@ export class ExternalStoreThreadRuntimeCore
         if (oldStore.convertMessage !== store.convertMessage) {
           this._converter = new ThreadMessageConverter();
         } else if (
+          !repositoryChanged &&
           oldStore.isRunning === store.isRunning &&
           oldStore.messages === store.messages &&
           previousIsRunning === isRunning
@@ -436,9 +449,13 @@ export class ExternalStoreThreadRuntimeCore
     // (prior placeholders, mid-run id-swap siblings); export() never persists them.
     let optimisticId: string | null = null;
     if (hasUpcomingMessage(isRunning, messages)) {
-      optimisticId = generateId();
+      const parentId = messages.at(-1)?.id ?? null;
+      if (this._optimistic?.parentId !== parentId) {
+        this._optimistic = { id: generateId(), parentId };
+      }
+      optimisticId = this._optimistic.id;
       this.repository.addOrUpdateMessage(
-        messages.at(-1)?.id ?? null,
+        parentId,
         fromThreadMessageLike(
           { role: "assistant", content: [], metadata: { isOptimistic: true } },
           optimisticId,
@@ -447,10 +464,20 @@ export class ExternalStoreThreadRuntimeCore
       );
     }
 
+    if (optimisticId === null) this._optimistic = null;
     this.repository.resetHead(optimisticId ?? messages.at(-1)?.id ?? null);
 
-    this._messages = this.repository.getMessages();
+    const messagesSnapshot = this.repository.getMessages();
+    if (
+      !this._messages ||
+      !shallowArrayEqual(this._messages, messagesSnapshot)
+    ) {
+      this._messages = messagesSnapshot;
+    }
 
+    if (repositoryChanged) {
+      this._runTrackerUpdate(() => this._toolInvocations?.reset());
+    }
     this._runTrackerUpdate(() => this._driveToolInvocations());
 
     this._notifySubscribers();
@@ -529,6 +556,7 @@ export class ExternalStoreThreadRuntimeCore
             }
           },
         },
+        (toolCall) => this._store.unstable_isClientToolCall?.(toolCall),
       );
     }
 
@@ -557,17 +585,9 @@ export class ExternalStoreThreadRuntimeCore
   private _findMessageIdForToolCall(toolCallId: string): string | undefined {
     if (this._messagesForToolCallIndex !== this._messages) {
       this._toolCallToMessageId.clear();
-      const visit = (messages: readonly ThreadMessage[]): void => {
-        for (const message of messages) {
-          if (!Array.isArray(message.content)) continue;
-          for (const part of message.content) {
-            if (!part || part.type !== "tool-call") continue;
-            this._toolCallToMessageId.set(part.toolCallId, message.id);
-            if (part.messages) visit(part.messages);
-          }
-        }
-      };
-      visit(this._messages);
+      for (const { part, messageId } of walkToolCallTree(this._messages)) {
+        this._toolCallToMessageId.set(part.toolCallId, messageId);
+      }
       this._messagesForToolCallIndex = this._messages;
     }
     return this._toolCallToMessageId.get(toolCallId);
@@ -671,7 +691,7 @@ export class ExternalStoreThreadRuntimeCore
     // user messages — matches the satellites' historical opt-in cancel
     // behavior, which is now built in.
     if (message.startRun ?? message.role === "user") {
-      await this._toolInvocations?.abort();
+      await this._toolInvocations?.abort({ discardPending: true });
     }
     if (!isThreadRuntimeGenerationCurrent(this, generation)) return;
 
@@ -772,7 +792,7 @@ export class ExternalStoreThreadRuntimeCore
     // Auto-abort in-flight client-side tool executions when a run reloads;
     // any results that land afterward would target a turn that no longer
     // exists. See `append` above for full rationale.
-    await this._toolInvocations?.abort();
+    await this._toolInvocations?.abort({ discardPending: true });
 
     await this._store.onReload(config.parentId, config);
   }
@@ -826,7 +846,7 @@ export class ExternalStoreThreadRuntimeCore
     // Abort any in-flight client-side tool executions. Fire-and-forget —
     // the abort resolves once executions settle, but we don't gate the
     // cancel on it.
-    void this._toolInvocations?.abort();
+    void this._toolInvocations?.abort({ discardPending: true });
 
     // Before the run is aborted, so the settle it produces keeps the pending
     // items instead of dispatching the next one at the moment the user
@@ -936,13 +956,16 @@ export class ExternalStoreThreadRuntimeCore
     );
   }
 
-  public respondToToolApproval(options: RespondToToolApprovalOptions) {
+  public respondToToolApproval(
+    options: RespondToToolApprovalOptions,
+  ): Promise<void> {
     if (!this._store.onRespondToToolApproval)
       throw new Error("Runtime does not support tool approvals.");
-    observeAdapterCallback(
-      "onRespondToToolApproval",
-      this._store.onRespondToToolApproval(options),
-    );
+    try {
+      return Promise.resolve(this._store.onRespondToToolApproval(options));
+    } catch (error) {
+      return Promise.reject(error);
+    }
   }
 
   public override reset(initialMessages?: readonly ThreadMessageLike[]) {

package/src/runtimes/inert/InertThreadRuntimeCore.ts

@@ -136,7 +136,7 @@ export abstract class InertThreadRuntimeCore
     throw this.error;
   }
 
-  respondToToolApproval(): void {
+  respondToToolApproval(): Promise<void> {
     throw this.error;
   }
 

package/src/runtimes/local/local-thread-runtime-core.test.ts

@@ -5,7 +5,7 @@ import type {
   ChatModelRunOptions,
   ChatModelRunResult,
 } from "../../runtime/utils/chat-model-adapter";
-import type { AppendMessage } from "../../types/message";
+import type { AppendMessage, ToolCallMessagePart } from "../../types/message";
 import type { LocalRuntimeOptionsBase } from "./local-runtime-options";
 import {
   ExportedMessageRepository,
@@ -61,7 +61,7 @@ const userMessage = (text: string): AppendMessage => ({
 
 const toolCallPart = (
   toolName: string,
-  approval?: { id: string; resolution?: "cancelled" | "expired" },
+  approval?: ToolCallMessagePart["approval"],
 ) => ({
   type: "tool-call" as const,
   toolCallId: `call-${toolName}`,
@@ -73,7 +73,7 @@ const toolCallPart = (
 
 const toolCallResult = (
   toolName: string,
-  approval?: { id: string; resolution?: "cancelled" | "expired" },
+  approval?: ToolCallMessagePart["approval"],
 ): ChatModelRunResult => ({
   content: [toolCallPart(toolName, approval)],
   status: { type: "requires-action", reason: "tool-calls" },
@@ -485,6 +485,32 @@ describe("LocalThreadRuntimeCore tool approvals", () => {
     });
   });
 
+  it("records a free-form answer alongside the decision", async () => {
+    const { thread, runs } = createApprovalThread(
+      toolCallResult("send_email", { id: "a1", display: "text" }),
+    );
+
+    await thread.append(userMessage("send an email"));
+    await flush();
+
+    await thread.respondToToolApproval({
+      approvalId: "a1",
+      approved: true,
+      text: "Quarterly update",
+    });
+    await flush();
+
+    const toolCall = runs[1]!
+      .unstable_getMessage()
+      .content.find((part) => part.type === "tool-call");
+    expect(toolCall?.approval).toEqual({
+      id: "a1",
+      display: "text",
+      approved: true,
+      text: "Quarterly update",
+    });
+  });
+
   it("treats a terminal resolution as non-pending and continues the run", async () => {
     const { thread, runs } = createApprovalThread(
       toolCallResult("deploy", { id: "a1", resolution: "expired" }),

package/src/runtimes/local/local-thread-runtime-core.ts

@@ -900,8 +900,9 @@ export class LocalThreadRuntimeCore
     approvalId,
     approved,
     optionId,
+    text,
     reason,
-  }: RespondToToolApprovalOptions) {
+  }: RespondToToolApprovalOptions): Promise<void> {
     let message = this.repository
       .getMessages()
       .findLast(
@@ -944,6 +945,7 @@ export class LocalThreadRuntimeCore
         ...targetApproval,
         approved,
         ...(optionId != null && { optionId }),
+        ...(text != null && { text }),
         ...(reason != null && { reason }),
       };
       if (approved) return { ...c, approval };
@@ -968,5 +970,7 @@ export class LocalThreadRuntimeCore
     } else {
       this._persistPausedMessage(parentId, message);
     }
+
+    return Promise.resolve();
   }
 }

package/src/runtimes/remote-thread-list/remote-thread-state.test.ts

@@ -1,9 +1,54 @@
 import { describe, expect, it } from "vitest";
 import {
+  classifyThreads,
   createEmptyRemoteThreadState,
   createThreadMappingId,
   seedNewThread,
+  updateStatusReducer,
 } from "./remote-thread-state";
+import type {
+  RemoteThreadData,
+  RemoteThreadState,
+} from "./remote-thread-state";
+
+const initializedDraft = () => {
+  const seeded = seedNewThread(createEmptyRemoteThreadState());
+  const regular = updateStatusReducer(seeded.state, seeded.id, "regular");
+  const mappingId = regular.threadIdMap[seeded.id]!;
+  const initializeTask = Promise.resolve({
+    remoteId: "remote-1",
+    externalId: "remote-1",
+  });
+  return {
+    id: seeded.id,
+    mappingId,
+    initializeTask,
+    state: {
+      ...regular,
+      threadIdMap: { ...regular.threadIdMap, "remote-1": mappingId },
+      threadData: {
+        ...regular.threadData,
+        [mappingId]: {
+          ...regular.threadData[mappingId]!,
+          remoteId: "remote-1",
+          externalId: "remote-1",
+          initializeTask,
+        } as RemoteThreadData,
+      },
+    } as RemoteThreadState,
+  };
+};
+
+const expectOneSlotPerIdentity = (state: RemoteThreadState) => {
+  const remoteIds = Object.values(state.threadData)
+    .map((data) => data.remoteId)
+    .filter((remoteId) => remoteId !== undefined);
+  expect(new Set(remoteIds).size).toBe(remoteIds.length);
+
+  for (const id of [...state.threadIds, ...state.archivedThreadIds]) {
+    expect(state.threadData[state.threadIdMap[id]!]?.id).toBe(id);
+  }
+};
 
 describe("remote thread state", () => {
   it("creates an empty state", () => {
@@ -34,4 +79,71 @@ describe("remote thread state", () => {
     );
     expect(Object.keys(second.state.threadData)).toEqual([first.id, second.id]);
   });
+
+  it("refreshes the local slot when a listed thread already has a mapping", () => {
+    const draft = initializedDraft();
+
+    const merged = classifyThreads(
+      [
+        {
+          status: "regular",
+          remoteId: "remote-1",
+          externalId: "remote-1",
+          title: "from the server",
+        },
+      ],
+      {
+        threadIds: [],
+        archivedThreadIds: [],
+        threadIdMap: { ...draft.state.threadIdMap },
+        threadData: { ...draft.state.threadData },
+      },
+    );
+
+    expect(Object.keys(merged.threadData)).toEqual([draft.mappingId]);
+    expect(merged.threadIds).toEqual([draft.id]);
+    expect(merged.threadIdMap["remote-1"]).toBe(draft.mappingId);
+    expect(merged.threadData[draft.mappingId]?.id).toBe(draft.id);
+    expect(merged.threadData[draft.mappingId]?.title).toBe("from the server");
+    expect(merged.threadData[draft.mappingId]?.localOrigin).toBe(true);
+    const refreshed = merged.threadData[draft.mappingId]!;
+    expect(
+      refreshed.status === "new" ? undefined : refreshed.initializeTask,
+    ).toBe(draft.initializeTask);
+    expectOneSlotPerIdentity({ ...draft.state, ...merged });
+  });
+
+  it("lists a repeated remote id once", () => {
+    const listed = classifyThreads(
+      [
+        { status: "regular", remoteId: "a", externalId: "a", title: "first" },
+        { status: "regular", remoteId: "a", externalId: "a", title: "second" },
+      ],
+      {
+        threadIds: [],
+        archivedThreadIds: [],
+        threadIdMap: {},
+        threadData: {},
+      },
+    );
+
+    expect(listed.threadIds).toEqual(["a"]);
+    expect(listed.threadData[createThreadMappingId("a")]?.title).toBe("second");
+  });
+
+  it("deletes every alias of an identity, by either id", () => {
+    for (const target of ["remote-1", "local"] as const) {
+      const draft = initializedDraft();
+      const deleted = updateStatusReducer(
+        draft.state,
+        target === "local" ? draft.id : target,
+        "deleted",
+      );
+
+      expect(deleted.threadData).toEqual({});
+      expect(deleted.threadIdMap).toEqual({});
+      expect(deleted.threadIds).toEqual([]);
+      expect(deleted.archivedThreadIds).toEqual([]);
+    }
+  });
 });

package/src/runtimes/remote-thread-list/remote-thread-state.ts

@@ -47,26 +47,29 @@ export const LOCAL_THREAD_ID_PREFIX = "__LOCALID_";
 export const normalizeCursor = (c: string | undefined): string | undefined =>
   c || undefined;
 
-type ClassifyAccumulator = {
+export type ClassifyAccumulator = {
   threadIds: string[];
   archivedThreadIds: string[];
   threadIdMap: Record<string, THREAD_MAPPING_ID>;
   threadData: Record<THREAD_MAPPING_ID, RemoteThreadData>;
 };
 
+// A slot's `id` is fixed when it is minted: the hook instance manager keys live
+// thread runtimes by it, so renaming a slot would detach the runtime the user is
+// chatting in. A listed thread whose `remoteId` already maps to a slot therefore
+// refreshes that slot instead of minting a second one, and a slot minted by a
+// list() that raced ahead of the remote id collapses when `initialize()` settles.
+// `threadIds`/`archivedThreadIds` carry slot ids, never remote ids.
 export const classifyThreads = (
   threads: readonly RemoteThreadMetadata[],
   acc: ClassifyAccumulator,
 ): ClassifyAccumulator => {
-  for (const thread of threads) {
-    if (acc.threadIdMap[thread.remoteId] !== undefined) continue;
+  const listed = new Set([...acc.threadIds, ...acc.archivedThreadIds]);
 
+  for (const thread of threads) {
     switch (thread.status) {
       case "regular":
-        acc.threadIds.push(thread.remoteId);
-        break;
       case "archived":
-        acc.archivedThreadIds.push(thread.remoteId);
         break;
       default: {
         const _exhaustiveCheck: never = thread.status;
@@ -74,20 +77,52 @@ export const classifyThreads = (
       }
     }
 
-    const mappingId = createThreadMappingId(thread.remoteId);
+    const existingMappingId = acc.threadIdMap[thread.remoteId];
+    const existing =
+      existingMappingId !== undefined
+        ? acc.threadData[existingMappingId]
+        : undefined;
+    const id = existing?.id ?? thread.remoteId;
+    const mappingId = existingMappingId ?? createThreadMappingId(id);
+    const existingTask =
+      existing !== undefined && existing.status !== "new"
+        ? existing.initializeTask
+        : undefined;
+
+    if (!listed.has(id)) {
+      listed.add(id);
+      if (thread.status === "regular") {
+        acc.threadIds.push(id);
+      } else {
+        acc.archivedThreadIds.push(id);
+      }
+    } else if (existing !== undefined && existing.status !== thread.status) {
+      if (thread.status === "regular") {
+        acc.archivedThreadIds = acc.archivedThreadIds.filter((t) => t !== id);
+        acc.threadIds.push(id);
+      } else {
+        acc.threadIds = acc.threadIds.filter((t) => t !== id);
+        acc.archivedThreadIds.push(id);
+      }
+    }
+
+    acc.threadIdMap[id] = mappingId;
     acc.threadIdMap[thread.remoteId] = mappingId;
     acc.threadData[mappingId] = {
-      id: thread.remoteId,
+      ...(existing?.localOrigin === true ? { localOrigin: true as const } : {}),
+      id,
       remoteId: thread.remoteId,
       externalId: thread.externalId,
       status: thread.status,
       title: thread.title,
       lastMessageAt: thread.lastMessageAt,
       custom: thread.custom,
-      initializeTask: Promise.resolve({
-        remoteId: thread.remoteId,
-        externalId: thread.externalId,
-      }),
+      initializeTask:
+        existingTask ??
+        Promise.resolve({
+          remoteId: thread.remoteId,
+          externalId: thread.externalId,
+        }),
     };
   }
   return acc;
@@ -238,7 +273,7 @@ export const updateStatusReducer = (
   const data = getThreadData(state, threadIdOrRemoteId);
   if (!data) return state;
 
-  const { id, remoteId, status: lastStatus } = data;
+  const { id, status: lastStatus } = data;
   if (lastStatus === newStatus) return state;
 
   const newState = { ...state };
@@ -273,16 +308,20 @@ export const updateStatusReducer = (
       newState.archivedThreadIds = [id, ...newState.archivedThreadIds];
       break;
 
-    case "deleted":
+    case "deleted": {
+      const mappingId = state.threadIdMap[threadIdOrRemoteId]!;
       newState.threadData = Object.fromEntries(
-        Object.entries(newState.threadData).filter(([key]) => key !== id),
+        Object.entries(newState.threadData).filter(
+          ([key]) => key !== mappingId,
+        ),
       );
       newState.threadIdMap = Object.fromEntries(
         Object.entries(newState.threadIdMap).filter(
-          ([key]) => key !== id && key !== remoteId,
+          ([, value]) => value !== mappingId,
         ),
       );
       break;
+    }
 
     default: {
       const _exhaustiveCheck: never = newStatus;

package/src/runtimes/remote-thread-list/title.ts

@@ -0,0 +1,3 @@
+export const isTitleSourceMessage = (message: {
+  status?: { type: string } | undefined;
+}) => message.status?.type !== "running";

package/src/runtimes/remote-thread-list/types.ts

@@ -78,11 +78,12 @@ export type RemoteThreadListAdapter = {
   unstable_Provider?: RemoteThreadListProviderComponent | undefined;
 
   /**
-   * Hook the `RemoteThreadList` store entry calls once for the main-thread
-   * slot, then provides to the `thread` factory. This is not mounted per
-   * listed thread. `useRemoteThreadListRuntime` also calls it when
-   * `unstable_Provider` is omitted. Resolve `threadListItem` lazily on each
-   * adapter call; do not capture it at hook mount. The hook must keep a
+   * Hook the `RemoteThreadList` store entry calls once per mounted thread
+   * body (the main-thread slot by default; every started thread with
+   * `backgroundThreads`), then provides to the `thread` factory. This is not
+   * mounted per listed thread. `useRemoteThreadListRuntime` also calls it
+   * when `unstable_Provider` is omitted. Resolve `threadListItem` lazily on
+   * each adapter call; do not capture it at hook mount. The hook must keep a
    * stable hook count across adapter swaps; a different count throws.
    * Memoize the returned object.
    *