@assistant-ui/core 0.3.14 → 0.3.15

package/src/react/runtimes/RemoteThreadListThreadListRuntimeCore.republish.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from "vitest";
+import { RemoteThreadListThreadListRuntimeCore } from "./RemoteThreadListThreadListRuntimeCore";
+import { ThreadListRuntimeImpl } from "../../runtime/api/thread-list-runtime";
+import { ReadonlyThreadRuntimeCore } from "../../runtimes/readonly/ReadonlyThreadRuntimeCore";
+import {
+  contextProvider,
+  makeAdapter,
+} from "../../tests/remote-thread-list-test-helpers";
+import type { ThreadMessage } from "../../types/message";
+
+const message = (id: string): ThreadMessage =>
+  ({
+    id,
+    role: "user",
+    content: [{ type: "text", text: id }],
+    createdAt: new Date(0),
+    attachments: [],
+    metadata: { custom: {} },
+  }) as unknown as ThreadMessage;
+
+const setup = () => {
+  const core = new RemoteThreadListThreadListRuntimeCore(
+    { adapter: makeAdapter(), runtimeHook: () => ({}) as never },
+    contextProvider,
+  );
+  const hookManager = (
+    core as unknown as {
+      _hookManager: {
+        _publishThreadRuntime: (
+          id: string,
+          runtime: ReadonlyThreadRuntimeCore,
+          generation: number,
+        ) => void;
+        instances: Map<string, { generation: number }>;
+      };
+    }
+  )._hookManager;
+  const threadId = core.mainThreadId!;
+  const publish = (runtime: ReadonlyThreadRuntimeCore) =>
+    hookManager._publishThreadRuntime(
+      threadId,
+      runtime,
+      hookManager.instances.get(threadId)!.generation,
+    );
+  return { core, publish };
+};
+
+describe("RemoteThreadListThreadListRuntimeCore republish", () => {
+  it("keeps the subscribed main thread state on the republished core", async () => {
+    const { core, publish } = setup();
+    const first = new ReadonlyThreadRuntimeCore();
+    first.setMessages([message("m1")]);
+    publish(first);
+
+    const thread = new ThreadListRuntimeImpl(core).main;
+    thread.subscribe(() => {});
+    expect(thread.getState().messages.map((m) => m.id)).toEqual(["m1"]);
+
+    const second = new ReadonlyThreadRuntimeCore();
+    second.setMessages([message("m2")]);
+    publish(second);
+    await Promise.resolve();
+
+    const ids = thread.getState().messages.map((m) => m.id);
+    expect(ids).toEqual(["m2"]);
+    for (const id of ids) {
+      expect(() => thread.getMessageById(id).getState()).not.toThrow();
+    }
+  });
+
+  it("notifies thread subscribers when the core is republished", async () => {
+    const { core, publish } = setup();
+    publish(new ReadonlyThreadRuntimeCore());
+
+    const thread = new ThreadListRuntimeImpl(core).main;
+    let notified = 0;
+    thread.subscribe(() => notified++);
+
+    const next = new ReadonlyThreadRuntimeCore();
+    next.setMessages([message("m1")]);
+    publish(next);
+    await Promise.resolve();
+
+    expect(notified).toBeGreaterThan(0);
+    expect(thread.getState().messages.map((m) => m.id)).toEqual(["m1"]);
+  });
+});

package/src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx

@@ -17,7 +17,9 @@ import {
 import type {
   RemoteThreadListAdapter,
   RemoteThreadListOptions,
+  RemoteThreadMetadata,
 } from "../../runtimes/remote-thread-list/types";
+import { ThreadListAdapterChangedError } from "../../runtimes/remote-thread-list/adapter-changed";
 import { RemoteThreadListHookInstanceManager } from "./RemoteThreadListHookInstanceManager";
 import { isTitleSourceMessage } from "./RemoteThreadResource";
 import {
@@ -47,6 +49,48 @@ const threadStatusError = (
     `Thread "${threadIdOrRemoteId}" has status "${status}", so it cannot ${action}.`,
   );
 
+const EMPTY_REMOTE_STATE: RemoteThreadState = {
+  isLoading: true,
+  isLoadingMore: false,
+  cursor: undefined,
+  newThreadId: undefined,
+  threadIds: [],
+  archivedThreadIds: [],
+  threadIdMap: {},
+  threadData: {},
+};
+
+const addNewThread = (state: RemoteThreadState) => {
+  let id: string;
+  do {
+    id = `__LOCALID_${generateId()}`;
+  } while (state.threadIdMap[id]);
+
+  const mappingId = createThreadMappingId(id);
+  return {
+    id,
+    state: {
+      ...state,
+      newThreadId: id,
+      threadIdMap: {
+        ...state.threadIdMap,
+        [id]: mappingId,
+      },
+      threadData: {
+        ...state.threadData,
+        [mappingId]: {
+          status: "new",
+          id,
+          remoteId: undefined,
+          externalId: undefined,
+          title: undefined,
+          custom: undefined,
+        } satisfies RemoteThreadData,
+      },
+    },
+  };
+};
+
 export class RemoteThreadListThreadListRuntimeCore
   extends BaseSubscribable
   implements ThreadListRuntimeCore
@@ -58,20 +102,16 @@ export class RemoteThreadListThreadListRuntimeCore
   private _loadThreadsPromise: Promise<void> | undefined;
   private _loadMorePromise: Promise<void> | undefined;
   private _loadGeneration = 0;
+  private _adapterGeneration = 0;
+  private _replaceListOnNextLoad = false;
+  private _staleThreadIdsOnReplace: ReadonlySet<string> | undefined;
   private _switchGeneration = 0;
   private _switchTask: Promise<void> | undefined;
 
   private _mainThreadId!: string;
-  private readonly _state = new OptimisticState<RemoteThreadState>({
-    isLoading: true,
-    isLoadingMore: false,
-    cursor: undefined,
-    newThreadId: undefined,
-    threadIds: [],
-    archivedThreadIds: [],
-    threadIdMap: {},
-    threadData: {},
-  });
+  private readonly _state = new OptimisticState<RemoteThreadState>(
+    EMPTY_REMOTE_STATE,
+  );
 
   private readonly _useAdaptersProvider: FC<PropsWithChildren> = ({
     children,
@@ -117,6 +157,7 @@ export class RemoteThreadListThreadListRuntimeCore
     // TODO this needs to be cached in case this promise is loaded during suspense
     if (!this._loadThreadsPromise) {
       const generation = this._loadGeneration;
+      let replacedList = false;
       this._loadThreadsPromise = this._state
         .optimisticUpdate({
           execute: () => this._options.adapter.list(),
@@ -128,27 +169,31 @@ export class RemoteThreadListThreadListRuntimeCore
           },
           then: (state, l) => {
             if (generation !== this._loadGeneration) return state;
+            const replaceList = this._replaceListOnNextLoad;
+            if (replaceList) {
+              this._replaceListOnNextLoad = false;
+              replacedList = true;
+              return this._replaceWithThreads(
+                state,
+                l.threads,
+                normalizeCursor(l.nextCursor),
+              );
+            }
+
             const fresh = classifyThreads(l.threads, {
               threadIds: [],
               archivedThreadIds: [],
               threadIdMap: {},
               threadData: {},
             });
-
             return {
               ...state,
               isLoading: false,
               cursor: normalizeCursor(l.nextCursor),
               threadIds: fresh.threadIds,
               archivedThreadIds: fresh.archivedThreadIds,
-              threadIdMap: {
-                ...state.threadIdMap,
-                ...fresh.threadIdMap,
-              },
-              threadData: {
-                ...state.threadData,
-                ...fresh.threadData,
-              },
+              threadIdMap: { ...state.threadIdMap, ...fresh.threadIdMap },
+              threadData: { ...state.threadData, ...fresh.threadData },
             };
           },
         })
@@ -156,12 +201,26 @@ export class RemoteThreadListThreadListRuntimeCore
           if (generation !== this._loadGeneration) return;
           console.error("[assistant-ui] thread list load failed:", error);
           this._loadThreadsPromise = undefined;
-          this._state.update({
-            ...this._state.baseValue,
-            isLoading: false,
-          });
+          if (!this._replaceListOnNextLoad) {
+            this._state.update({
+              ...this._state.baseValue,
+              isLoading: false,
+            });
+            return;
+          }
+          this._replaceListOnNextLoad = false;
+          replacedList = true;
+          this._state.update(
+            this._replaceWithThreads(this._state.baseValue, [], undefined),
+          );
         })
-        .then(() => {});
+        .then(() => {
+          if (!replacedList) return;
+          const threadId = this._options.threadId;
+          if (threadId === undefined) return;
+          if (this.getItemById(threadId)?.id === this._mainThreadId) return;
+          this._switchToThreadFromProp(threadId).catch(() => {});
+        });
     }
 
     return this._loadThreadsPromise;
@@ -206,6 +265,7 @@ export class RemoteThreadListThreadListRuntimeCore
         },
       })
       .catch((error: unknown) => {
+        if (generation !== this._loadGeneration) return;
         console.error("[assistant-ui] thread list loadMore failed:", error);
       })
       .then(() => {
@@ -237,6 +297,11 @@ export class RemoteThreadListThreadListRuntimeCore
     this._hookManager.__internal_subscribeRunningChanged(() =>
       this._notifySubscribers(),
     );
+    this._hookManager.__internal_subscribeRuntimeReplaced(() => {
+      // A republish can land during the thread resource's render, where a
+      // synchronous notify would re-enter store consumers mid-render.
+      queueMicrotask(() => this._notifySubscribers());
+    });
     this.useProvider = create(() => ({
       Provider: this.resolveProvider(options.adapter),
     }));
@@ -268,8 +333,17 @@ export class RemoteThreadListThreadListRuntimeCore
 
     if (adapterChanged) {
       this._loadGeneration++;
+      this._adapterGeneration++;
+      this._switchGeneration++;
+      this._switchTask = undefined;
       this._loadThreadsPromise = undefined;
       this._loadMorePromise = undefined;
+      this._replaceListOnNextLoad = true;
+      this._staleThreadIdsOnReplace = new Set(
+        Object.values(this._state.baseValue.threadData)
+          .filter((item) => item.status !== "new")
+          .map((item) => item.id),
+      );
       this._state.update({
         ...this._state.baseValue,
         cursor: undefined,
@@ -281,6 +355,115 @@ export class RemoteThreadListThreadListRuntimeCore
     }
   }
 
+  private _requireAdapterGeneration(generation: number) {
+    if (generation !== this._adapterGeneration) {
+      throw new ThreadListAdapterChangedError();
+    }
+  }
+
+  private _requireAdapterSettled() {
+    if (this._replaceListOnNextLoad) {
+      throw new ThreadListAdapterChangedError();
+    }
+  }
+
+  private _replaceWithThreads(
+    state: RemoteThreadState,
+    threads: readonly RemoteThreadMetadata[],
+    cursor: string | undefined,
+  ): RemoteThreadState {
+    const fresh = classifyThreads(threads, {
+      threadIds: [],
+      archivedThreadIds: [],
+      threadIdMap: {},
+      threadData: {},
+    });
+    const threadIdMap = { ...fresh.threadIdMap };
+    const threadData = { ...fresh.threadData };
+    const threadIds = [...fresh.threadIds];
+    const archivedThreadIds = [...fresh.archivedThreadIds];
+
+    if (state.newThreadId) {
+      const mappingId = state.threadIdMap[state.newThreadId];
+      const draft = mappingId ? state.threadData[mappingId] : undefined;
+      if (draft?.status === "new") {
+        threadIdMap[state.newThreadId] = mappingId!;
+        threadData[mappingId!] = draft;
+      }
+    }
+
+    const stale = this._staleThreadIdsOnReplace;
+    if (stale) {
+      for (const item of Object.values(state.threadData)) {
+        if (stale.has(item.id)) continue;
+        if (item.status !== "new" && item.remoteId === undefined) continue;
+        const mappingId = createThreadMappingId(item.id);
+        if (threadData[mappingId]) continue;
+        threadIdMap[item.id] = mappingId;
+        if (item.remoteId !== undefined) {
+          threadIdMap[item.remoteId] = mappingId;
+        }
+        threadData[mappingId] = item;
+        if (item.remoteId === undefined) continue;
+        if (item.status === "regular" && !threadIds.includes(item.remoteId)) {
+          threadIds.push(item.remoteId);
+        } else if (
+          item.status === "archived" &&
+          !archivedThreadIds.includes(item.remoteId)
+        ) {
+          archivedThreadIds.push(item.remoteId);
+        }
+      }
+    }
+    this._staleThreadIdsOnReplace = undefined;
+
+    let nextState: RemoteThreadState = {
+      ...state,
+      isLoading: false,
+      cursor,
+      threadIds,
+      archivedThreadIds,
+      threadIdMap,
+      threadData,
+      newThreadId:
+        state.newThreadId !== undefined &&
+        threadIdMap[state.newThreadId] === undefined
+          ? undefined
+          : state.newThreadId,
+    };
+
+    if (getThreadData(nextState, this._mainThreadId) === undefined) {
+      const preservedDraft = nextState.newThreadId;
+      if (preservedDraft !== undefined) {
+        this._mainThreadId = preservedDraft;
+      } else {
+        const seeded = addNewThread(nextState);
+        this._mainThreadId = seeded.id;
+        nextState = seeded.state;
+      }
+      if (this._options.threadId === undefined) {
+        this._notifyThreadIdChange();
+      } else {
+        this._lastNotifiedThreadId = undefined;
+      }
+    }
+
+    const nextIds = new Set(
+      Object.values(nextState.threadData).map((item) => item.id),
+    );
+    for (const item of Object.values(state.threadData)) {
+      if (!nextIds.has(item.id)) {
+        this._hookManager.stopThreadRuntime(item.id);
+      }
+    }
+    void this._hookManager.startThreadRuntime(this._mainThreadId).then(
+      () => this._notifySubscribers(),
+      () => undefined,
+    );
+
+    return nextState;
+  }
+
   public __internal_load() {
     this.getLoadThreadsPromise(); // begin loading on initial bind
     if (this._initialThreadLoaded) return;
@@ -440,6 +623,12 @@ export class RemoteThreadListThreadListRuntimeCore
     generation: number,
     emitThreadIdChange: boolean,
   ): Promise<void> {
+    if (
+      this._replaceListOnNextLoad &&
+      threadIdOrRemoteId !== this._state.value.newThreadId
+    ) {
+      throw new ThreadListAdapterChangedError();
+    }
     let data = this.getItemById(threadIdOrRemoteId);
 
     if (!data) {
@@ -573,48 +762,32 @@ export class RemoteThreadListThreadListRuntimeCore
     const state = this._state.baseValue;
     let id: string | undefined = this._state.value.newThreadId;
     if (id === undefined) {
-      do {
-        id = `__LOCALID_${generateId()}`;
-      } while (state.threadIdMap[id]);
-
-      const mappingId = createThreadMappingId(id);
-      this._state.update({
-        ...state,
-        newThreadId: id,
-        threadIdMap: {
-          ...state.threadIdMap,
-          [id]: mappingId,
-        },
-        threadData: {
-          ...state.threadData,
-          [mappingId]: {
-            status: "new",
-            id,
-            remoteId: undefined,
-            externalId: undefined,
-            title: undefined,
-            custom: undefined,
-          } satisfies RemoteThreadData,
-        },
-      });
+      const next = addNewThread(state);
+      id = next.id;
+      this._state.update(next.state);
     }
 
     return this._switchToThread(id, undefined, generation, emitThreadIdChange);
   }
 
   public initialize = async (threadId: string) => {
+    const adapter = this._options.adapter;
+    const adapterGeneration = this._adapterGeneration;
     if (this._state.value.newThreadId !== threadId) {
+      this._requireAdapterSettled();
       const data = this.getItemById(threadId);
       if (!data) throw threadNotFoundError(threadId, "initializing it");
       if (data.status === "new")
         throw threadStatusError(threadId, data.status, "be initialized here");
       const { remoteId, externalId } = await data.initializeTask;
+      this._requireAdapterGeneration(adapterGeneration);
       return { remoteId, externalId };
     }
 
     const { remoteId, externalId } = await this._state.optimisticUpdate({
       execute: () => {
-        return this._options.adapter.initialize(threadId);
+        this._requireAdapterGeneration(adapterGeneration);
+        return adapter.initialize(threadId);
       },
       optimistic: (state) => {
         return updateStatusReducer(state, threadId, "regular");
@@ -633,6 +806,7 @@ export class RemoteThreadListThreadListRuntimeCore
         };
       },
       then: (state, { remoteId, externalId }) => {
+        if (adapterGeneration !== this._adapterGeneration) return state;
         const data = getThreadData(state, threadId);
         if (!data) return state;
 
@@ -655,16 +829,21 @@ export class RemoteThreadListThreadListRuntimeCore
         };
       },
     });
+    this._requireAdapterGeneration(adapterGeneration);
     return { remoteId, externalId };
   };
 
   public generateTitle = async (threadId: string) => {
+    this._requireAdapterSettled();
+    const adapter = this._options.adapter;
+    const adapterGeneration = this._adapterGeneration;
     const data = this.getItemById(threadId);
     if (!data) throw threadNotFoundError(threadId, "generating its title");
     if (data.status === "new")
       throw threadStatusError(threadId, data.status, "generate a title");
 
     const { remoteId } = await data.initializeTask;
+    this._requireAdapterGeneration(adapterGeneration);
 
     const runtimeCore = this._hookManager.getThreadRuntimeCore(data.id);
     if (!runtimeCore) return; // thread is no longer running
@@ -673,12 +852,10 @@ export class RemoteThreadListThreadListRuntimeCore
     // would make the payload race-dependent; the title reads settled
     // messages only, matching the trigger's readiness gate.
     const messages = runtimeCore.messages.filter(isTitleSourceMessage);
-    const stream = await this._options.adapter.generateTitle(
-      remoteId,
-      messages,
-    );
+    const stream = await adapter.generateTitle(remoteId, messages);
     const messageStream = AssistantMessageStream.fromAssistantStream(stream);
     for await (const result of messageStream) {
+      if (adapterGeneration !== this._adapterGeneration) return;
       const newTitle = result.parts.filter((c) => c.type === "text")[0]?.text;
       const state = this._state.baseValue;
       const currentData = getThreadData(state, data.id);
@@ -696,7 +873,13 @@ export class RemoteThreadListThreadListRuntimeCore
     }
   };
 
-  public rename(threadIdOrRemoteId: string, newTitle: string): Promise<void> {
+  public async rename(
+    threadIdOrRemoteId: string,
+    newTitle: string,
+  ): Promise<void> {
+    this._requireAdapterSettled();
+    const adapter = this._options.adapter;
+    const adapterGeneration = this._adapterGeneration;
     const data = this.getItemById(threadIdOrRemoteId);
     if (!data) throw threadNotFoundError(threadIdOrRemoteId, "renaming it");
     if (data.status === "new")
@@ -705,7 +888,8 @@ export class RemoteThreadListThreadListRuntimeCore
     return this._state.optimisticUpdate({
       execute: async () => {
         const { remoteId } = await data.initializeTask;
-        return this._options.adapter.rename(remoteId, newTitle);
+        this._requireAdapterGeneration(adapterGeneration);
+        return adapter.rename(remoteId, newTitle);
       },
       optimistic: (state) => {
         const data = getThreadData(state, threadIdOrRemoteId);
@@ -725,10 +909,13 @@ export class RemoteThreadListThreadListRuntimeCore
     });
   }
 
-  public updateCustom(
+  public async updateCustom(
     threadIdOrRemoteId: string,
     custom: Record<string, unknown> | undefined,
   ): Promise<void> {
+    this._requireAdapterSettled();
+    const adapter = this._options.adapter;
+    const adapterGeneration = this._adapterGeneration;
     const data = this.getItemById(threadIdOrRemoteId);
     if (!data)
       throw threadNotFoundError(
@@ -742,7 +929,7 @@ export class RemoteThreadListThreadListRuntimeCore
         "update custom metadata",
       );
 
-    if (!this._options.adapter.updateCustom) {
+    if (!adapter.updateCustom) {
       throw new Error(
         "Remote thread list adapter does not support updating custom metadata",
       );
@@ -751,7 +938,7 @@ export class RemoteThreadListThreadListRuntimeCore
     return this._state.optimisticUpdate({
       execute: async () => {
         const { remoteId } = await data.initializeTask;
-        const adapter = this._options.adapter;
+        this._requireAdapterGeneration(adapterGeneration);
         if (!adapter.updateCustom) {
           throw new Error(
             "Remote thread list adapter does not support updating custom metadata",
@@ -800,17 +987,22 @@ export class RemoteThreadListThreadListRuntimeCore
   }
 
   public async archive(threadIdOrRemoteId: string) {
+    this._requireAdapterSettled();
+    const adapter = this._options.adapter;
+    const adapterGeneration = this._adapterGeneration;
     const data = this.getItemById(threadIdOrRemoteId);
     if (!data) throw threadNotFoundError(threadIdOrRemoteId, "archiving it");
     if (data.status !== "regular")
       throw threadStatusError(threadIdOrRemoteId, data.status, "be archived");
 
     await this._ensureThreadIsNotMain(data.id);
+    this._requireAdapterGeneration(adapterGeneration);
 
     return this._state.optimisticUpdate({
       execute: async () => {
         const { remoteId } = await data.initializeTask;
-        return this._options.adapter.archive(remoteId);
+        this._requireAdapterGeneration(adapterGeneration);
+        return adapter.archive(remoteId);
       },
       optimistic: (state) => {
         return updateStatusReducer(state, data.id, "archived");
@@ -818,7 +1010,10 @@ export class RemoteThreadListThreadListRuntimeCore
     });
   }
 
-  public unarchive(threadIdOrRemoteId: string): Promise<void> {
+  public async unarchive(threadIdOrRemoteId: string): Promise<void> {
+    this._requireAdapterSettled();
+    const adapter = this._options.adapter;
+    const adapterGeneration = this._adapterGeneration;
     const data = this.getItemById(threadIdOrRemoteId);
     if (!data) throw threadNotFoundError(threadIdOrRemoteId, "unarchiving it");
     if (data.status !== "archived")
@@ -828,9 +1023,12 @@ export class RemoteThreadListThreadListRuntimeCore
       execute: async () => {
         try {
           const { remoteId } = await data.initializeTask;
-          return await this._options.adapter.unarchive(remoteId);
+          this._requireAdapterGeneration(adapterGeneration);
+          return await adapter.unarchive(remoteId);
         } catch (error) {
-          await this._ensureThreadIsNotMain(data.id);
+          if (adapterGeneration === this._adapterGeneration) {
+            await this._ensureThreadIsNotMain(data.id);
+          }
           throw error;
         }
       },
@@ -841,18 +1039,23 @@ export class RemoteThreadListThreadListRuntimeCore
   }
 
   public async delete(threadIdOrRemoteId: string) {
+    this._requireAdapterSettled();
+    const adapter = this._options.adapter;
+    const adapterGeneration = this._adapterGeneration;
     const data = this.getItemById(threadIdOrRemoteId);
     if (!data) throw threadNotFoundError(threadIdOrRemoteId, "deleting it");
     if (data.status !== "regular" && data.status !== "archived")
       throw threadStatusError(threadIdOrRemoteId, data.status, "be deleted");
 
     await this._ensureThreadIsNotMain(data.id);
+    this._requireAdapterGeneration(adapterGeneration);
     this._hookManager.stopThreadRuntime(data.id);
 
     return this._state.optimisticUpdate({
       execute: async () => {
         const { remoteId } = await data.initializeTask;
-        return await this._options.adapter.delete(remoteId);
+        this._requireAdapterGeneration(adapterGeneration);
+        return await adapter.delete(remoteId);
       },
       optimistic: (state) => {
         return updateStatusReducer(state, data.id, "deleted");
@@ -865,12 +1068,14 @@ export class RemoteThreadListThreadListRuntimeCore
   }
 
   public async detach(threadIdOrRemoteId: string): Promise<void> {
+    const adapterGeneration = this._adapterGeneration;
     const data = this.getItemById(threadIdOrRemoteId);
     if (!data) throw threadNotFoundError(threadIdOrRemoteId, "detaching it");
     if (data.status !== "regular" && data.status !== "archived")
       throw threadStatusError(threadIdOrRemoteId, data.status, "be detached");
 
     await this._ensureThreadIsNotMain(data.id);
+    this._requireAdapterGeneration(adapterGeneration);
     this._hookManager.stopThreadRuntime(data.id);
   }
 

package/src/react/runtimes/RemoteThreadResource.ts

@@ -21,6 +21,7 @@ import {
   useRuntimeAdaptersProvider,
   type RuntimeAdapters,
 } from "./RuntimeAdapterProvider";
+import { isSilentRuntimeAction } from "../../utils/silent-runtime-action";
 
 export type RemoteThreadListHook = () => AssistantRuntime;
 
@@ -48,6 +49,7 @@ export const subscribeToTitleGeneration = (
 ) => {
   const generate = () =>
     void itemRuntime.generateTitle().catch((error: unknown) => {
+      if (isSilentRuntimeAction(error)) return;
       console.error("[assistant-ui] Thread title generation failed", error);
     });