@assistant-ui/core 0.3.20 → 0.3.21

package/src/react/primitives/thread/ThreadSuggestions.tsx

@@ -6,9 +6,32 @@ import {
   useMemo,
 } from "react";
 import { RenderChildrenWithAccessor, useAuiState } from "@assistant-ui/store";
+import { useShallowSelector } from "@assistant-ui/store/internal";
 import type { SuggestionState } from "../../../store/scopes/suggestion";
+import type { ThreadSuggestion } from "../../../runtime/interfaces/thread-runtime-core";
 import { SuggestionByIndexProvider } from "../../providers/SuggestionByIndexProvider";
 
+/**
+ * A suggestion carries no id, so its identity is its content. Repeats of the
+ * same content get an occurrence suffix, because React keys must be unique
+ * and two suggestions that render the same thing are interchangeable.
+ */
+const toSuggestionKeys = (
+  suggestions: readonly ThreadSuggestion[],
+): string[] => {
+  const seen = new Map<string, number>();
+  return suggestions.map((suggestion) => {
+    const content = JSON.stringify([
+      suggestion.title,
+      suggestion.label,
+      suggestion.prompt,
+    ]);
+    const occurrence = seen.get(content) ?? 0;
+    seen.set(content, occurrence + 1);
+    return occurrence === 0 ? content : `${content}:${occurrence}`;
+  });
+};
+
 type SuggestionsComponentConfig = {
   /** Component used to render each suggestion */
   Suggestion: ComponentType;
@@ -67,14 +90,14 @@ ThreadPrimitiveSuggestionByIndex.displayName =
 const ThreadPrimitiveSuggestionsInner: FC<{
   children: (value: { suggestion: SuggestionState }) => ReactNode;
 }> = ({ children }) => {
-  const suggestionsLength = useAuiState(
-    (s) => s.suggestions.suggestions.length,
+  const suggestionKeys = useAuiState(
+    useShallowSelector((s) => toSuggestionKeys(s.suggestions.suggestions)),
   );
 
   return useMemo(() => {
-    if (suggestionsLength === 0) return null;
-    return Array.from({ length: suggestionsLength }, (_, index) => (
-      <SuggestionByIndexProvider key={index} index={index}>
+    if (suggestionKeys.length === 0) return null;
+    return suggestionKeys.map((suggestionKey, index) => (
+      <SuggestionByIndexProvider key={suggestionKey} index={index}>
         <RenderChildrenWithAccessor
           getItemState={(aui) =>
             aui.suggestions.suggestion({ index }).getState()
@@ -90,7 +113,7 @@ const ThreadPrimitiveSuggestionsInner: FC<{
         </RenderChildrenWithAccessor>
       </SuggestionByIndexProvider>
     ));
-  }, [suggestionsLength, children]);
+  }, [suggestionKeys, children]);
 };
 
 /**

package/src/react/providers/ReadonlyThreadProvider.tsx

@@ -14,14 +14,14 @@ import {
   type ThreadListItemRuntimeBinding,
 } from "../../runtime/internal";
 import { ThreadClient } from "../../store/runtime-clients/thread-runtime-client";
-import type { ThreadListItemState } from "../../runtime/api/bindings";
+import type { ThreadListItemRuntimeState } from "../../runtime/api/bindings";
 
 const READONLY_THREAD_PATH = Object.freeze({
   ref: "readonly-thread",
   threadSelector: { type: "main" as const },
 });
 
-const READONLY_THREAD_LIST_ITEM: ThreadListItemState = Object.freeze({
+const READONLY_THREAD_LIST_ITEM: ThreadListItemRuntimeState = Object.freeze({
   id: "readonly",
   remoteId: undefined,
   externalId: undefined,

package/src/react/providers/TextMessagePartProvider.tsx

@@ -36,6 +36,9 @@ const useTextMessagePartClient = ({
     respondToToolApproval: () => {
       throw new Error("Not supported");
     },
+    unstable_recordInteraction: async () => {
+      throw new Error("Not supported");
+    },
   };
 };
 

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

@@ -64,6 +64,28 @@ const makeManager = () =>
     {} as ThreadListRuntimeCore,
   );
 
+const makeRuntimeWithThrowingCleanup = () => {
+  const thread = makeRuntime();
+  const error = new Error("cleanup failed");
+  const cleanupOrder: number[] = [];
+  let subscriptionCount = 0;
+  const cleanup = () => {
+    const index = subscriptionCount++;
+    return () => {
+      cleanupOrder.push(index);
+      if (index === 0) throw error;
+    };
+  };
+  vi.spyOn(thread.runtime, "subscribe").mockImplementation(cleanup);
+  vi.spyOn(thread.runtime, "unstable_on").mockImplementation(cleanup as never);
+  return {
+    ...thread,
+    error,
+    cleanupOrder,
+    subscriptionCount: () => subscriptionCount,
+  };
+};
+
 // mirrors what the tap fiber does on every publication
 const publish = (
   manager: RemoteThreadListHookInstanceManager,
@@ -217,6 +239,77 @@ describe("RemoteThreadListHookInstanceManager run tracking", () => {
     expect(manager.__internal_isThreadRunning("thread-1")).toBe(false);
   });
 
+  it("finishes stopping a runtime after a cleanup throws", () => {
+    const manager = makeManager();
+    start(manager, "thread-1");
+    const thread = makeRuntimeWithThrowingCleanup();
+    publish(manager, "thread-1", thread.runtime);
+    const internals = manager as unknown as {
+      instances: Map<string, { destroy: AbortController }>;
+    };
+    const destroySignal = internals.instances.get("thread-1")!.destroy.signal;
+
+    expect(() => manager.stopThreadRuntime("thread-1")).toThrow(thread.error);
+
+    expect(thread.cleanupOrder).toEqual(
+      Array.from({ length: thread.subscriptionCount() }, (_, index) => index),
+    );
+    expect(destroySignal.aborted).toBe(true);
+    expect(internals.instances.has("thread-1")).toBe(false);
+  });
+
+  it("finishes restarting a runtime after a cleanup throws", () => {
+    const manager = makeManager();
+    start(manager, "thread-1");
+    const thread = makeRuntimeWithThrowingCleanup();
+    publish(manager, "thread-1", thread.runtime);
+    const internals = manager as unknown as {
+      instances: Map<
+        string,
+        {
+          destroy: AbortController;
+          generation: number;
+          unsubscribeRunning?: () => void;
+        }
+      >;
+    };
+    const before = internals.instances.get("thread-1")!;
+    const destroySignal = before.destroy.signal;
+    const generation = before.generation;
+
+    expect(() => manager.__internal_restartThreadRuntime("thread-1")).toThrow(
+      thread.error,
+    );
+
+    const after = internals.instances.get("thread-1")!;
+    expect(thread.cleanupOrder).toEqual(
+      Array.from({ length: thread.subscriptionCount() }, (_, index) => index),
+    );
+    expect(destroySignal.aborted).toBe(true);
+    expect(after.destroy.signal).not.toBe(destroySignal);
+    expect(after.generation).toBeGreaterThan(generation);
+    expect(after.unsubscribeRunning).toBeUndefined();
+  });
+
+  it("installs replacement tracking after an old cleanup throws", () => {
+    const manager = makeManager();
+    start(manager, "thread-1");
+    const before = makeRuntimeWithThrowingCleanup();
+    publish(manager, "thread-1", before.runtime);
+    const after = makeRuntime({ isRunning: false });
+
+    expect(() => publish(manager, "thread-1", after.runtime)).toThrow(
+      before.error,
+    );
+
+    expect(before.cleanupOrder).toEqual(
+      Array.from({ length: before.subscriptionCount() }, (_, index) => index),
+    );
+    expect(after.subscriberCount()).toBe(1);
+    after.setRunning(true);
+    expect(manager.__internal_isThreadRunning("thread-1")).toBe(true);
+  });
+
   it("forwards every lifecycle event from every tracked thread with its thread id", () => {
     const manager = makeManager();
     const events: unknown[] = [];

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

@@ -1,15 +1,22 @@
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it, onTestFinished, vi } from "vitest";
 import type { ThreadListRuntimeCore } from "../../runtime/interfaces/thread-list-runtime-core";
 import { RemoteThreadListHookInstanceManager } from "./RemoteThreadListHookInstanceManager";
 import { ExternalStoreThreadRuntimeCore } from "../../runtimes/external-store/external-store-thread-runtime-core";
 import type { ExternalStoreAdapter } from "../../runtimes/external-store/external-store-adapter";
 import type { ModelContextProvider } from "../../model-context/types";
 import type { ThreadRuntimeCore } from "../../runtime/interfaces/thread-runtime-core";
+import type { RealtimeVoiceAdapter } from "../../adapters/voice";
 
-const createExternalStoreRuntime = () =>
+const createExternalStoreRuntime = (
+  store: Partial<ExternalStoreAdapter> = {},
+) =>
   new ExternalStoreThreadRuntimeCore(
     { getModelContext: () => ({}) } satisfies ModelContextProvider,
-    { messages: [], onNew: async () => {} } satisfies ExternalStoreAdapter,
+    {
+      messages: [],
+      onNew: async () => {},
+      ...store,
+    } satisfies ExternalStoreAdapter,
   );
 
 describe("RemoteThreadListHookInstanceManager", () => {
@@ -107,6 +114,7 @@ describe("RemoteThreadListHookInstanceManager.__internal_restartThreadRuntime",
         runtime?: ThreadRuntimeCore;
         publishedGeneration?: number;
         generation: number;
+        unsubscribeRunning?: () => void;
       }
     >;
     _notifySubscribers: () => void;
@@ -177,6 +185,155 @@ describe("RemoteThreadListHookInstanceManager.__internal_restartThreadRuntime",
     internalsOf(manager)._notifySubscribers();
   };
 
+  const createVoiceSession = () => {
+    const disconnect = vi.fn();
+    let emitTranscript!: (item: RealtimeVoiceAdapter.TranscriptItem) => void;
+    const session: RealtimeVoiceAdapter.Session = {
+      status: { type: "running" },
+      isMuted: false,
+      disconnect,
+      mute: vi.fn(),
+      unmute: vi.fn(),
+      onStatusChange: () => () => {},
+      onTranscript: (callback) => {
+        emitTranscript = callback;
+        return () => {};
+      },
+      onModeChange: () => () => {},
+      onVolumeChange: () => () => {},
+    };
+    return {
+      session,
+      disconnect,
+      emitTranscript: (item: RealtimeVoiceAdapter.TranscriptItem) =>
+        emitTranscript(item),
+    };
+  };
+
+  it("disconnects voice without delivering the unfinished transcript on remote stop", () => {
+    const onVoiceTranscript = vi.fn();
+    const { session, disconnect, emitTranscript } = createVoiceSession();
+    const runtime = createExternalStoreRuntime({
+      onVoiceTranscript,
+      adapters: { voice: { connect: () => session } },
+    });
+    const manager = makeManager();
+    start(manager, "thread-1");
+    publish(manager, "thread-1", runtime);
+    runtime.connectVoice();
+    emitTranscript({ role: "assistant", text: "unfinished" });
+    expect(runtime.messages).toHaveLength(1);
+
+    manager.stopThreadRuntime("thread-1");
+
+    expect(disconnect).toHaveBeenCalledOnce();
+    expect(onVoiceTranscript).not.toHaveBeenCalled();
+    expect(runtime.messages).toHaveLength(0);
+  });
+
+  it("hangs up on remote restart and commits the unfinished transcript as a disconnect does", () => {
+    const onVoiceTranscript = vi.fn();
+    const { session, disconnect, emitTranscript } = createVoiceSession();
+    const runtime = createExternalStoreRuntime({
+      onVoiceTranscript,
+      adapters: { voice: { connect: () => session } },
+    });
+    const manager = makeManager();
+    start(manager, "thread-1");
+    publish(manager, "thread-1", runtime);
+    runtime.connectVoice();
+    emitTranscript({ role: "assistant", text: "unfinished" });
+
+    restart(manager, "thread-1");
+
+    expect(disconnect).toHaveBeenCalledOnce();
+    expect(onVoiceTranscript).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({
+        role: "assistant",
+        status: { type: "complete", reason: "stop" },
+      }),
+    );
+  });
+
+  it("drops the unfinished transcript on a remote restart while history is still loading", async () => {
+    const onVoiceTranscript = vi.fn();
+    const { session, disconnect, emitTranscript } = createVoiceSession();
+    const runtime = createExternalStoreRuntime({
+      isLoading: true,
+      onVoiceTranscript,
+      adapters: { voice: { connect: () => session } },
+    });
+    const manager = makeManager();
+    start(manager, "thread-1");
+    publish(manager, "thread-1", runtime);
+    runtime.connectVoice();
+    emitTranscript({ role: "assistant", text: "unfinished" });
+
+    restart(manager, "thread-1");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(disconnect).toHaveBeenCalledOnce();
+    expect(onVoiceTranscript).not.toHaveBeenCalled();
+  });
+
+  it("stops every thread when one running subscription cleanup throws", () => {
+    const first = createVoiceSession();
+    const second = createVoiceSession();
+    const firstRuntime = createExternalStoreRuntime({
+      adapters: { voice: { connect: () => first.session } },
+    });
+    const secondRuntime = createExternalStoreRuntime({
+      adapters: { voice: { connect: () => second.session } },
+    });
+    const manager = makeManager();
+    start(manager, "thread-1");
+    start(manager, "thread-2");
+    publish(manager, "thread-1", firstRuntime);
+    publish(manager, "thread-2", secondRuntime);
+    firstRuntime.connectVoice();
+    secondRuntime.connectVoice();
+    const error = new Error("unsubscribe failed");
+    internalsOf(manager).instances.get("thread-1")!.unsubscribeRunning = () => {
+      throw error;
+    };
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    onTestFinished(() => consoleError.mockRestore());
+
+    expect(() => manager.__internal_dispose()).not.toThrow();
+
+    expect(first.disconnect).toHaveBeenCalledOnce();
+    expect(second.disconnect).toHaveBeenCalledOnce();
+    expect(internalsOf(manager).instances.size).toBe(0);
+    expect(consoleError).toHaveBeenCalledExactlyOnceWith(
+      "[assistant-ui] Thread runtime cleanup threw while stopping a thread",
+      error,
+    );
+  });
+
+  it("keeps a send made before the restarted runtime publishes", async () => {
+    const onNew = vi.fn(async () => {});
+    const runtime = createExternalStoreRuntime({ onNew });
+    const manager = makeManager();
+    start(manager, "thread-1");
+    publish(manager, "thread-1", runtime);
+
+    restart(manager, "thread-1");
+    await runtime.append({
+      parentId: null,
+      sourceId: null,
+      runConfig: {},
+      role: "user",
+      content: [{ type: "text", text: "hello" }],
+      attachments: [],
+      metadata: { custom: {} },
+      createdAt: new Date(0),
+    });
+
+    expect(onNew).toHaveBeenCalledOnce();
+  });
+
   it("does not settle with the pre-restart runtime; only the incoming binder's publication resolves it", async () => {
     const manager = makeManager();
     start(manager, "thread-1");

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

@@ -276,4 +276,42 @@ describe("RemoteThreadListHookInstanceManager title generation", () => {
     expect(titledMessages).toHaveLength(1);
     expect(titledMessages[0]).toMatchObject({ role: "user" });
   });
+
+  it("titles a new thread that another caller initialized first", async () => {
+    const generateTitle = vi.fn<RemoteThreadListAdapter["generateTitle"]>(
+      async () => new ReadableStream(),
+    );
+    const adapter = makeAdapter({ generateTitle });
+    const runtimeRef: { current: AssistantRuntime | null } = { current: null };
+
+    const App = () => {
+      const runtime = useRemoteThreadListRuntime({
+        adapter,
+        runtimeHook: function useThreadRuntime() {
+          return useLocalRuntime({ run: async () => ({ content: [] }) });
+        },
+      });
+      runtimeRef.current = runtime;
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          {null}
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    render(<App />);
+    await waitFor(() => {
+      expect(runtimeRef.current?.threads.mainItem.getState().id).toBeDefined();
+    });
+
+    await act(async () => {
+      await runtimeRef.current!.threads.mainItem.initialize();
+    });
+    void getThreadCore(runtimeRef.current!).append(userMessage("hello"));
+
+    await waitFor(() => {
+      expect(generateTitle).toHaveBeenCalledTimes(1);
+    });
+    expect(adapter.initialize).toHaveBeenCalledTimes(1);
+  });
 });

package/src/react/runtimes/RemoteThreadListHookInstanceManager.tsx

@@ -25,12 +25,16 @@ import type { Unsubscribe } from "../../types/unsubscribe";
 import {
   BaseSubscribable,
   notifySubscribers,
+  runCleanups,
   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 {
+  disposeThreadRuntime,
+  supersedeThreadRuntime,
+} from "../../runtime/utils/thread-runtime-lifecycle";
 import { notifyEventListeners } from "../../utils/notify-event-listeners";
 import {
   useRuntimeAdapters,
@@ -149,18 +153,21 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     const instance = this.instances.get(threadId);
     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();
+    // Detach before superseding and aborting, as stopThreadRuntime does: both
+    // tear the outgoing runtime down synchronously, and its terminal events
+    // would otherwise reach the subscription the next generation is about to
+    // reuse.
+    try {
+      instance.unsubscribeRunning?.();
+    } finally {
+      instance.unsubscribeRunning = undefined;
+      if (instance.runtime) supersedeThreadRuntime(instance.runtime);
+      instance.destroy.abort();
+      instance.destroy = new AbortController();
+      instance.generation = this.nextGeneration++;
+      this._syncHostThreads();
+      this._notifySubscribers();
+    }
 
     return this._whenRuntimeAttached(threadId);
   }
@@ -214,12 +221,15 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     const previousRuntime = instance.runtime;
     instance.runtime = runtime;
     instance.publishedGeneration = generation;
-    if (previousRuntime !== runtime) {
-      this._trackRunning(threadId, instance);
-    }
-    this._notifySubscribers();
-    if (previousRuntime !== undefined && previousRuntime !== runtime) {
-      notifySubscribers(this.replacedSubscribers);
+    try {
+      if (previousRuntime !== runtime) {
+        this._trackRunning(threadId, instance);
+      }
+    } finally {
+      this._notifySubscribers();
+      if (previousRuntime !== undefined && previousRuntime !== runtime) {
+        notifySubscribers(this.replacedSubscribers);
+      }
     }
   }
 
@@ -236,33 +246,33 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
     threadId: string,
     instance: RemoteThreadListHookInstance,
   ) {
-    instance.unsubscribeRunning?.();
-
-    const runtime = instance.runtime;
-    if (!runtime) {
-      instance.unsubscribeRunning = undefined;
-      this._setRunning(instance, false);
-      return;
-    }
-
-    this._setRunning(instance, getThreadRuntimeCoreIsRunning(runtime));
-    const unsubscribers = [
-      runtime.subscribe(() => {
+    const previousCleanup = instance.unsubscribeRunning;
+    instance.unsubscribeRunning = undefined;
+    try {
+      previousCleanup?.();
+    } finally {
+      const runtime = instance.runtime;
+      if (!runtime) {
+        this._setRunning(instance, false);
+      } else {
         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();
-    };
+        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 = () => runCleanups(unsubscribers);
+      }
+    }
   }
 
   private _setRunning(
@@ -276,13 +286,16 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
 
   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();
-    this._notifySubscribers();
+    try {
+      instance?.unsubscribeRunning?.();
+    } finally {
+      if (instance?.runtime) disposeThreadRuntime(instance.runtime);
+      instance?.destroy.abort();
+      this.instances.delete(threadId);
+      this.pendingThreadAdapters.delete(threadId);
+      this._syncHostThreads();
+      this._notifySubscribers();
+    }
   }
 
   public setRuntimeHook(newRuntimeHook: RemoteThreadListHook) {
@@ -311,7 +324,14 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
 
   public __internal_dispose() {
     for (const threadId of [...this.instances.keys()]) {
-      this.stopThreadRuntime(threadId);
+      try {
+        this.stopThreadRuntime(threadId);
+      } catch (error) {
+        console.error(
+          "[assistant-ui] Thread runtime cleanup threw while stopping a thread",
+          error,
+        );
+      }
     }
   }
 

package/src/react/runtimes/RemoteThreadListThreadListRuntimeCore.tsx

@@ -7,6 +7,7 @@ import {
   WritableSubscribable,
 } from "../../subscribable/subscribable";
 import { useSubscribable } from "../../store/runtime-clients/useSubscribable";
+import { handleThreadListAction } from "../../store/runtime-clients/handle-thread-list-action";
 import { nullProtoRecord } from "../../utils/record";
 import { OptimisticState } from "../../runtimes/remote-thread-list/optimistic-state";
 import { EMPTY_THREAD_CORE } from "../../runtimes/remote-thread-list/empty-thread-core";
@@ -461,8 +462,14 @@ export class RemoteThreadListThreadListRuntimeCore
       Object.values(nextState.threadData).map((item) => item.id),
     );
     for (const item of Object.values(state.threadData)) {
-      if (!nextIds.has(item.id)) {
+      if (nextIds.has(item.id)) continue;
+      try {
         this._hookManager.stopThreadRuntime(item.id);
+      } catch (error) {
+        console.error(
+          "[assistant-ui] Thread runtime cleanup threw while stopping a thread",
+          error,
+        );
       }
     }
     void this._hookManager.startThreadRuntime(this._mainThreadId).then(
@@ -769,8 +776,12 @@ export class RemoteThreadListThreadListRuntimeCore
 
   private _switchToThreadFromProp(threadId: string | undefined): Promise<void> {
     return threadId !== undefined
-      ? this._startSwitchToThread(threadId, undefined, false)
-      : this._startSwitchToNewThread(false);
+      ? handleThreadListAction("switch", () =>
+          this._startSwitchToThread(threadId, undefined, false),
+        )
+      : handleThreadListAction("create", () =>
+          this._startSwitchToNewThread(false),
+        );
   }
 
   private _startSwitchToNewThread(emitThreadIdChange: boolean): Promise<void> {
@@ -1012,6 +1023,11 @@ export class RemoteThreadListThreadListRuntimeCore
     let lastAwaitedTask: Promise<void> | undefined;
 
     while (threadId === this._mainThreadId) {
+      // Rechecked each pass: the draft can become the new thread again
+      // mid-loop when its failed first save rolls it back, and switching to a
+      // new thread then re-adopts it, so no switch can move main off it.
+      if (threadId === this.newThreadId)
+        throw new Error("Cannot ensure new thread is not main");
       let switchTask = this._switchTask;
       const startedFallback = !switchTask || switchTask === lastAwaitedTask;
       if (startedFallback) switchTask = this.switchToNewThread();

package/src/react/runtimes/RemoteThreadResource.ts

@@ -106,15 +106,18 @@ const useRemoteThreadBinder = ({
 
   const initPromiseRef = useRef<Promise<unknown> | undefined>(undefined);
   const hasInitializedRef = useRef(false);
+  // Any caller's initialize() moves the item off "new"; a thread born "new"
+  // here still joins that initialization so its title arms.
+  const bornNewRef = useRef(itemRuntime.getState().status === "new");
   const titleDisposeRef = useRef<(() => void) | undefined>(undefined);
   const titleAliveRef = useRef(false);
 
   const handleInitialize = useEffectEvent(() => {
     if (hasInitializedRef.current) return;
 
-    const state = itemRuntime.getState();
-    if (state.status !== "new") return;
+    if (itemRuntime.getState().status !== "new" && !bornNewRef.current) return;
     hasInitializedRef.current = true;
+    bornNewRef.current = false;
 
     const initPromise = itemRuntime.initialize();
     initPromiseRef.current = initPromise;