@assistant-ui/core 0.3.12 → 0.3.14

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

@@ -0,0 +1,116 @@
+// @vitest-environment jsdom
+
+import { render, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { AssistantRuntimeProvider } from "../AssistantRuntimeProvider";
+import { useExternalStoreRuntime } from "./useExternalStoreRuntime";
+import { useLocalRuntime } from "./useLocalRuntime";
+import { useRemoteThreadListRuntime } from "./useRemoteThreadListRuntime";
+import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
+import type { AppendMessage } from "../../types/message";
+import { makeAdapter } from "../../tests/remote-thread-list-test-helpers";
+
+const userMessage = (text: string): AppendMessage => ({
+  parentId: null,
+  sourceId: null,
+  runConfig: {},
+  role: "user",
+  content: [{ type: "text", text }],
+  attachments: [],
+  metadata: { custom: {} },
+  createdAt: new Date(),
+  startRun: false,
+});
+
+const getThreadCore = (runtime: AssistantRuntime) =>
+  (
+    runtime.thread as unknown as {
+      __internal_threadBinding: {
+        getState(): { append(message: AppendMessage): Promise<void> };
+      };
+    }
+  ).__internal_threadBinding.getState();
+
+const testInitializationRetry = async (
+  runtimeHook: () => AssistantRuntime,
+  onNew?: ReturnType<typeof vi.fn>,
+) => {
+  const initializationError = new Error("initialization failed");
+  let initializeCount = 0;
+  const adapter = makeAdapter({
+    initialize: vi.fn(async (threadId: string) => {
+      initializeCount++;
+      if (initializeCount === 1) throw initializationError;
+      return {
+        remoteId: `remote-${threadId}`,
+        externalId: `external-${threadId}`,
+      };
+    }),
+  });
+  const runtimeRef: { current: AssistantRuntime | null } = { current: null };
+
+  const App = () => {
+    const runtime = useRemoteThreadListRuntime({ adapter, runtimeHook });
+    runtimeRef.current = runtime;
+    return (
+      <AssistantRuntimeProvider runtime={runtime}>
+        {null}
+      </AssistantRuntimeProvider>
+    );
+  };
+
+  render(<App />);
+  await waitFor(() => {
+    expect(runtimeRef.current?.threads.mainItem.getState().id).toBeDefined();
+  });
+
+  const item = runtimeRef.current!.threads.mainItem;
+  const localId = item.getState().id;
+  const thread = getThreadCore(runtimeRef.current!);
+
+  if (onNew) {
+    // The external-store core dispatches without holding the append on the
+    // initialization barrier; the failure surfaces at the dispatch seam.
+    await expect(thread.append(userMessage("first"))).resolves.toBeUndefined();
+    // Drain the rejection through RemoteThreadResource's catch so the retry
+    // re-arms before the second append; the exact chain depth is not
+    // load-bearing.
+    for (let i = 0; i < 20; i++) await Promise.resolve();
+  } else {
+    await expect(thread.append(userMessage("first"))).rejects.toMatchObject({
+      name: "MessageNotSentError",
+      cause: initializationError,
+    });
+  }
+  expect(item.getState().status).toBe("new");
+
+  await expect(thread.append(userMessage("second"))).resolves.toBeUndefined();
+  expect(adapter.initialize).toHaveBeenCalledTimes(2);
+  expect(adapter.initialize).toHaveBeenLastCalledWith(localId);
+  await waitFor(() => {
+    expect(item.getState()).toMatchObject({
+      id: localId,
+      status: "regular",
+      remoteId: `remote-${localId}`,
+    });
+  });
+  if (onNew) expect(onNew).toHaveBeenCalledTimes(2);
+};
+
+describe("RemoteThreadListHookInstanceManager initialization retry", () => {
+  it("retries a rejected initialization for local runtimes", async () => {
+    await testInitializationRetry(() =>
+      useLocalRuntime({
+        run: async () => ({ content: [] }),
+      }),
+    );
+  });
+
+  it("retries a rejected initialization for external-store runtimes", async () => {
+    const onNew = vi.fn(async () => {});
+    await testInitializationRetry(
+      () => useExternalStoreRuntime({ messages: [], onNew }),
+      onNew,
+    );
+  });
+});

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

@@ -36,7 +36,7 @@ const makeManager = () =>
     {} as ThreadListRuntimeCore,
   );
 
-// mirrors what the React binder does on every publication
+// mirrors what the tap fiber does on every publication
 const publish = (
   manager: RemoteThreadListHookInstanceManager,
   threadId: string,

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

@@ -1,6 +1,9 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, 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";
 
 describe("RemoteThreadListHookInstanceManager", () => {
   it("rejects a pending start when the thread runtime is stopped", async () => {
@@ -15,6 +18,54 @@ describe("RemoteThreadListHookInstanceManager", () => {
       "Thread was deleted before runtime was started",
     );
   });
+
+  it("dispatches an append before the thread runtime stops", async () => {
+    let resolveInitialization!: () => void;
+    const initialization = new Promise<void>((resolve) => {
+      resolveInitialization = resolve;
+    });
+    const onNew = vi.fn(async () => {});
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      { getModelContext: () => ({}) } satisfies ModelContextProvider,
+      { messages: [], onNew } as ExternalStoreAdapter,
+    );
+    runtime.__internal_setGetInitializePromise(() => initialization);
+    const manager = new RemoteThreadListHookInstanceManager(
+      () => ({}) as never,
+      {} as ThreadListRuntimeCore,
+    );
+    const internals = manager as unknown as {
+      instances: Map<
+        string,
+        { runtime: typeof runtime; generation: number; isRunning: boolean }
+      >;
+    };
+    internals.instances.set("thread-1", {
+      runtime,
+      generation: 0,
+      isRunning: false,
+    });
+
+    const appendPromise = runtime.append({
+      parentId: null,
+      sourceId: null,
+      runConfig: {},
+      role: "user",
+      content: [{ type: "text", text: "hello" }],
+      attachments: [],
+      metadata: { custom: {} },
+      createdAt: new Date(0),
+    });
+    await Promise.resolve();
+
+    expect(onNew).toHaveBeenCalledTimes(1);
+
+    manager.stopThreadRuntime("thread-1");
+    resolveInitialization();
+
+    await appendPromise;
+    expect(onNew).toHaveBeenCalledTimes(1);
+  });
 });
 
 describe("RemoteThreadListHookInstanceManager.__internal_restartThreadRuntime", () => {
@@ -24,7 +75,7 @@ describe("RemoteThreadListHookInstanceManager.__internal_restartThreadRuntime",
       {} as ThreadListRuntimeCore,
     );
 
-  // no React binder attaches a runtime in these tests, so the returned promises
+  // no AdapterSink attaches a runtime in these tests, so the returned promises
   // stay pending or reject on stop; neither is what is under test here
   const start = (manager: RemoteThreadListHookInstanceManager, id: string) => {
     manager.startThreadRuntime(id).catch(() => {});
@@ -55,7 +106,7 @@ describe("RemoteThreadListHookInstanceManager.__internal_restartThreadRuntime",
       ([id, { generation }]) => `${id}:${generation}`,
     );
 
-  it("changes the binder key so React remounts the runtime hook", () => {
+  it("changes the resource key so the tap host remounts the runtime hook", () => {
     const manager = makeManager();
     start(manager, "thread-1");
     const before = renderedKeys(manager);
@@ -87,7 +138,7 @@ describe("RemoteThreadListHookInstanceManager.__internal_restartThreadRuntime",
     expect(renderedKeys(manager)).toEqual(["thread-1:0"]);
   });
 
-  it("stop then start in one tick yields a fresh key, so the old still-mounted binder cannot satisfy the new start", () => {
+  it("stop then start in one tick yields a fresh key, so the old still-mounted resource cannot satisfy the new start", () => {
     const manager = makeManager();
     start(manager, "thread-1");
     const before = renderedKeys(manager);
@@ -99,7 +150,7 @@ describe("RemoteThreadListHookInstanceManager.__internal_restartThreadRuntime",
     expect(renderedKeys(manager)).toEqual(["thread-1:1"]);
   });
 
-  // simulates the binder's updateRuntime: publish a runtime for the
+  // simulates the resource publish: attach a runtime for the
   // instance's current generation (or an explicit stale one)
   const publish = (
     manager: RemoteThreadListHookInstanceManager,
@@ -160,7 +211,7 @@ describe("RemoteThreadListHookInstanceManager.__internal_restartThreadRuntime",
       settled = true;
     });
 
-    // an outgoing binder re-publishing for its old generation (e.g. a late
+    // an outgoing resource re-publishing for its old generation (e.g. a late
     // outerSubscribe callback) must not count as the new attachment
     const staleGeneration =
       internalsOf(manager).instances.get("thread-1")!.generation - 1;

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

@@ -0,0 +1,272 @@
+// @vitest-environment jsdom
+
+import { act, render, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { useSyncExternalStore } from "react";
+import { AssistantRuntimeProvider } from "../AssistantRuntimeProvider";
+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 {
+  deferred,
+  makeAdapter,
+} from "../../tests/remote-thread-list-test-helpers";
+
+const userMessage = (text: string): AppendMessage => ({
+  parentId: null,
+  sourceId: null,
+  runConfig: {},
+  role: "user",
+  content: [{ type: "text", text }],
+  attachments: [],
+  metadata: { custom: {} },
+  createdAt: new Date(),
+  startRun: false,
+});
+
+const getThreadCore = (runtime: AssistantRuntime) =>
+  (
+    runtime.thread as unknown as {
+      __internal_threadBinding: {
+        getState(): { append(message: AppendMessage): Promise<void> };
+      };
+    }
+  ).__internal_threadBinding.getState();
+
+describe("RemoteThreadListHookInstanceManager title generation", () => {
+  it("generates the title once initialization resolves, without waiting for a run", async () => {
+    const initialization = deferred<{
+      remoteId: string;
+      externalId: string;
+    }>();
+    const generateTitle = vi.fn(async () => new ReadableStream());
+    const adapter = makeAdapter({
+      initialize: vi.fn(() => initialization.promise),
+      generateTitle,
+    });
+    const runtimeRef: { current: AssistantRuntime | null } = { current: null };
+
+    const App = () => {
+      const runtime = useRemoteThreadListRuntime({
+        adapter,
+        runtimeHook: () =>
+          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();
+    });
+    const localId = runtimeRef.current!.threads.mainItem.getState().id;
+
+    void getThreadCore(runtimeRef.current!).append(userMessage("hello"));
+    await Promise.resolve();
+
+    expect(adapter.initialize).toHaveBeenCalledTimes(1);
+    expect(generateTitle).not.toHaveBeenCalled();
+
+    initialization.resolve({
+      remoteId: `remote-${localId}`,
+      externalId: `external-${localId}`,
+    });
+
+    await waitFor(() => {
+      expect(generateTitle).toHaveBeenCalledTimes(1);
+    });
+    expect(generateTitle).toHaveBeenCalledWith(`remote-${localId}`, [
+      expect.objectContaining({
+        role: "user",
+        content: [expect.objectContaining({ type: "text", text: "hello" })],
+      }),
+    ]);
+  });
+
+  it("excludes the in-flight assistant message from the title payload", async () => {
+    const initialization = deferred<{
+      remoteId: string;
+      externalId: string;
+    }>();
+    const generateTitle = vi.fn(async () => new ReadableStream());
+    const adapter = makeAdapter({
+      initialize: vi.fn(() => initialization.promise),
+      generateTitle,
+    });
+    const runtimeRef: { current: AssistantRuntime | null } = { current: null };
+
+    const App = () => {
+      const runtime = useRemoteThreadListRuntime({
+        adapter,
+        runtimeHook: () =>
+          useLocalRuntime({ run: () => new Promise<never>(() => {}) }),
+      });
+      runtimeRef.current = runtime;
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          {null}
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    render(<App />);
+    await waitFor(() => {
+      expect(runtimeRef.current?.threads.mainItem.getState().id).toBeDefined();
+    });
+    const localId = runtimeRef.current!.threads.mainItem.getState().id;
+
+    void getThreadCore(runtimeRef.current!).append({
+      ...userMessage("hello"),
+      startRun: true,
+    });
+    await act(async () => {});
+
+    initialization.resolve({
+      remoteId: `remote-${localId}`,
+      externalId: `external-${localId}`,
+    });
+
+    await waitFor(() => {
+      expect(generateTitle).toHaveBeenCalledTimes(1);
+    });
+    const [, titledMessages] = generateTitle.mock.calls[0] as [
+      string,
+      readonly { role: string }[],
+    ];
+    expect(titledMessages.map((message) => message.role)).toEqual(["user"]);
+  });
+
+  it("waits for a settled message on an agent-initiated first turn", async () => {
+    const initialization = deferred<{
+      remoteId: string;
+      externalId: string;
+    }>();
+    const run = deferred<{ content: { type: "text"; text: string }[] }>();
+    const generateTitle = vi.fn(async () => new ReadableStream());
+    const adapter = makeAdapter({
+      initialize: vi.fn(() => initialization.promise),
+      generateTitle,
+    });
+    const runtimeRef: { current: AssistantRuntime | null } = { current: null };
+
+    const App = () => {
+      const runtime = useRemoteThreadListRuntime({
+        adapter,
+        runtimeHook: () => useLocalRuntime({ run: () => run.promise }),
+      });
+      runtimeRef.current = runtime;
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          {null}
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    render(<App />);
+    await waitFor(() => {
+      expect(runtimeRef.current?.threads.mainItem.getState().id).toBeDefined();
+    });
+    const localId = runtimeRef.current!.threads.mainItem.getState().id;
+
+    act(() => {
+      runtimeRef.current!.thread.startRun({ parentId: null });
+    });
+    await act(async () => {});
+
+    initialization.resolve({
+      remoteId: `remote-${localId}`,
+      externalId: `external-${localId}`,
+    });
+    await act(async () => {});
+
+    expect(generateTitle).not.toHaveBeenCalled();
+
+    run.resolve({ content: [{ type: "text", text: "hi there" }] });
+
+    await waitFor(() => {
+      expect(generateTitle).toHaveBeenCalledTimes(1);
+    });
+    const [, titledMessages] = generateTitle.mock.calls[0] as [
+      string,
+      readonly { role: string }[],
+    ];
+    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 adapter = makeAdapter({ generateTitle });
+    const store = {
+      messages: [] as readonly ThreadMessageLike[],
+      listeners: new Set<() => void>(),
+      subscribe(callback: () => void) {
+        store.listeners.add(callback);
+        return () => store.listeners.delete(callback);
+      },
+      set(messages: readonly ThreadMessageLike[]) {
+        store.messages = messages;
+        for (const listener of store.listeners) listener();
+      },
+    };
+    const capture: { runtime: AssistantRuntime | null } = { runtime: null };
+
+    const App = () => {
+      const runtime = useRemoteThreadListRuntime({
+        adapter,
+        runtimeHook: () => {
+          const messages = useSyncExternalStore(
+            store.subscribe,
+            () => store.messages,
+          );
+          return useExternalStoreRuntime({
+            messages,
+            convertMessage: (message: ThreadMessageLike) => message,
+            onNew: async () => {},
+          });
+        },
+      });
+      capture.runtime = runtime;
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          {null}
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    render(<App />);
+    await waitFor(() => {
+      expect(capture.runtime?.threads.mainItem.getState().id).toBeDefined();
+    });
+
+    void getThreadCore(capture.runtime!).append(userMessage("hello"));
+    await waitFor(() => {
+      expect(adapter.initialize).toHaveBeenCalledTimes(1);
+    });
+
+    await act(async () => {});
+    expect(generateTitle).not.toHaveBeenCalled();
+
+    await act(async () => {
+      store.set([{ role: "user", content: [{ type: "text", text: "hello" }] }]);
+    });
+
+    await waitFor(() => {
+      expect(generateTitle).toHaveBeenCalledTimes(1);
+    });
+    const [, titledMessages] = generateTitle.mock.calls[0] as [
+      string,
+      readonly { role: string }[],
+    ];
+    expect(titledMessages).toHaveLength(1);
+    expect(titledMessages[0]).toMatchObject({ role: "user" });
+  });
+});