@assistant-ui/core 0.3.19 → 0.3.21

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,9 +1,23 @@
-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 = (
+  store: Partial<ExternalStoreAdapter> = {},
+) =>
+  new ExternalStoreThreadRuntimeCore(
+    { getModelContext: () => ({}) } satisfies ModelContextProvider,
+    {
+      messages: [],
+      onNew: async () => {},
+      ...store,
+    } satisfies ExternalStoreAdapter,
+  );
 
 describe("RemoteThreadListHookInstanceManager", () => {
   it("rejects a pending start when the thread runtime is stopped", async () => {
@@ -97,9 +111,10 @@ describe("RemoteThreadListHookInstanceManager.__internal_restartThreadRuntime",
     instances: Map<
       string,
       {
-        runtime?: unknown;
+        runtime?: ThreadRuntimeCore;
         publishedGeneration?: number;
         generation: number;
+        unsubscribeRunning?: () => void;
       }
     >;
     _notifySubscribers: () => void;
@@ -161,7 +176,7 @@ describe("RemoteThreadListHookInstanceManager.__internal_restartThreadRuntime",
   const publish = (
     manager: RemoteThreadListHookInstanceManager,
     id: string,
-    runtime: unknown,
+    runtime: ThreadRuntimeCore,
     options?: { generation?: number },
   ) => {
     const instance = internalsOf(manager).instances.get(id)!;
@@ -170,27 +185,176 @@ 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");
-    publish(manager, "thread-1", { tag: "pre-reload-runtime" });
+    const preReloadRuntime = createExternalStoreRuntime();
+    const postReloadRuntime = createExternalStoreRuntime();
+    publish(manager, "thread-1", preReloadRuntime);
 
     let settledWith = "NOT_SETTLED";
-    manager.__internal_restartThreadRuntime("thread-1").then((r) => {
-      settledWith = (r as { tag: string }).tag;
+    manager.__internal_restartThreadRuntime("thread-1").then((runtime) => {
+      settledWith = runtime === postReloadRuntime ? "post-reload-runtime" : "";
     });
 
     // the outgoing runtime rides across the restart (stays readable)…
-    expect(manager.getThreadRuntimeCore("thread-1")).toEqual({
-      tag: "pre-reload-runtime",
-    });
+    expect(manager.getThreadRuntimeCore("thread-1")).toBe(preReloadRuntime);
     // …but must not count as attached
     await Promise.resolve();
     await Promise.resolve();
     await Promise.resolve();
     expect(settledWith).toBe("NOT_SETTLED");
 
-    publish(manager, "thread-1", { tag: "post-reload-runtime" });
+    publish(manager, "thread-1", postReloadRuntime);
     await Promise.resolve();
     expect(settledWith).toBe("post-reload-runtime");
   });
@@ -198,19 +362,20 @@ describe("RemoteThreadListHookInstanceManager.__internal_restartThreadRuntime",
   it("keeps the outgoing runtime readable while the restart promise is pending", () => {
     const manager = makeManager();
     start(manager, "thread-1");
-    publish(manager, "thread-1", { tag: "pre-reload-runtime" });
+    const preReloadRuntime = createExternalStoreRuntime();
+    publish(manager, "thread-1", preReloadRuntime);
 
     restart(manager, "thread-1");
 
-    expect(manager.getThreadRuntimeCore("thread-1")).toEqual({
-      tag: "pre-reload-runtime",
-    });
+    expect(manager.getThreadRuntimeCore("thread-1")).toBe(preReloadRuntime);
   });
 
   it("a stale-generation publication does not resolve the restart promise", async () => {
     const manager = makeManager();
     start(manager, "thread-1");
-    publish(manager, "thread-1", { tag: "pre-reload-runtime" });
+    const preReloadRuntime = createExternalStoreRuntime();
+    const staleRuntime = createExternalStoreRuntime();
+    publish(manager, "thread-1", preReloadRuntime);
 
     let settled = false;
     manager.__internal_restartThreadRuntime("thread-1").then(() => {
@@ -221,12 +386,7 @@ describe("RemoteThreadListHookInstanceManager.__internal_restartThreadRuntime",
     // outerSubscribe callback) must not count as the new attachment
     const staleGeneration =
       internalsOf(manager).instances.get("thread-1")!.generation - 1;
-    publish(
-      manager,
-      "thread-1",
-      { tag: "stale-publication" },
-      { generation: staleGeneration },
-    );
+    publish(manager, "thread-1", staleRuntime, { generation: staleGeneration });
 
     await Promise.resolve();
     await Promise.resolve();

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

@@ -8,7 +8,9 @@ import { useExternalStoreRuntime } from "./useExternalStoreRuntime";
 import { useLocalRuntime } from "./useLocalRuntime";
 import { useRemoteThreadListRuntime } from "./useRemoteThreadListRuntime";
 import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
-import type { AppendMessage, ThreadMessageLike } from "../../types/message";
+import type { AppendMessage } from "../../types/message";
+import type { ThreadMessageLike } from "../../runtime/utils/thread-message-like";
+import type { RemoteThreadListAdapter } from "../../runtimes/remote-thread-list/types";
 import {
   deferred,
   makeAdapter,
@@ -41,7 +43,9 @@ describe("RemoteThreadListHookInstanceManager title generation", () => {
       remoteId: string;
       externalId: string;
     }>();
-    const generateTitle = vi.fn(async () => new ReadableStream());
+    const generateTitle = vi.fn<RemoteThreadListAdapter["generateTitle"]>(
+      async () => new ReadableStream(),
+    );
     const adapter = makeAdapter({
       initialize: vi.fn(() => initialization.promise),
       generateTitle,
@@ -95,7 +99,9 @@ describe("RemoteThreadListHookInstanceManager title generation", () => {
       remoteId: string;
       externalId: string;
     }>();
-    const generateTitle = vi.fn(async () => new ReadableStream());
+    const generateTitle = vi.fn<RemoteThreadListAdapter["generateTitle"]>(
+      async () => new ReadableStream(),
+    );
     const adapter = makeAdapter({
       initialize: vi.fn(() => initialization.promise),
       generateTitle,
@@ -136,10 +142,9 @@ describe("RemoteThreadListHookInstanceManager title generation", () => {
     await waitFor(() => {
       expect(generateTitle).toHaveBeenCalledTimes(1);
     });
-    const [, titledMessages] = generateTitle.mock.calls[0] as [
-      string,
-      readonly { role: string }[],
-    ];
+    const titleCall = generateTitle.mock.calls[0];
+    if (titleCall === undefined) throw new Error("Expected title generation");
+    const [, titledMessages] = titleCall;
     expect(titledMessages.map((message) => message.role)).toEqual(["user"]);
   });
 
@@ -149,7 +154,9 @@ describe("RemoteThreadListHookInstanceManager title generation", () => {
       externalId: string;
     }>();
     const run = deferred<{ content: { type: "text"; text: string }[] }>();
-    const generateTitle = vi.fn(async () => new ReadableStream());
+    const generateTitle = vi.fn<RemoteThreadListAdapter["generateTitle"]>(
+      async () => new ReadableStream(),
+    );
     const adapter = makeAdapter({
       initialize: vi.fn(() => initialization.promise),
       generateTitle,
@@ -193,17 +200,18 @@ describe("RemoteThreadListHookInstanceManager title generation", () => {
     await waitFor(() => {
       expect(generateTitle).toHaveBeenCalledTimes(1);
     });
-    const [, titledMessages] = generateTitle.mock.calls[0] as [
-      string,
-      readonly { role: string }[],
-    ];
+    const titleCall = generateTitle.mock.calls[0];
+    if (titleCall === undefined) throw new Error("Expected title generation");
+    const [, titledMessages] = titleCall;
     expect(titledMessages.map((message) => message.role)).toEqual([
       "assistant",
     ]);
   });
 
   it("waits for the first message when initialization resolves before the store lands it", async () => {
-    const generateTitle = vi.fn(async () => new ReadableStream());
+    const generateTitle = vi.fn<RemoteThreadListAdapter["generateTitle"]>(
+      async () => new ReadableStream(),
+    );
     const adapter = makeAdapter({ generateTitle });
     const store = {
       messages: [] as readonly ThreadMessageLike[],
@@ -262,11 +270,48 @@ describe("RemoteThreadListHookInstanceManager title generation", () => {
     await waitFor(() => {
       expect(generateTitle).toHaveBeenCalledTimes(1);
     });
-    const [, titledMessages] = generateTitle.mock.calls[0] as [
-      string,
-      readonly { role: string }[],
-    ];
+    const titleCall = generateTitle.mock.calls[0];
+    if (titleCall === undefined) throw new Error("Expected title generation");
+    const [, titledMessages] = titleCall;
     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);
+  });
 });