@assistant-ui/core 0.1.13 → 0.1.15

package/src/store/scopes/threads.ts

@@ -27,6 +27,7 @@ export type ThreadsMethods = {
   ): ThreadListItemMethods;
   thread(selector: "main"): ThreadMethods;
   getLoadThreadsPromise(): Promise<void>;
+  reload(): Promise<void>;
   __internal_getAssistantRuntime?(): AssistantRuntime;
 };
 

package/src/subscribable/subscribable.ts

@@ -1,16 +1,8 @@
 import type { Unsubscribe } from "../types/unsubscribe";
 
-// =============================================================================
-// Sentinel
-// =============================================================================
-
 export const SKIP_UPDATE = Symbol("skip-update");
 export type SKIP_UPDATE = typeof SKIP_UPDATE;
 
-// =============================================================================
-// Types
-// =============================================================================
-
 export type Subscribable = {
   subscribe: (callback: () => void) => Unsubscribe;
 };
@@ -36,10 +28,6 @@ export type EventSubscribable<TEvent extends string> = {
   >;
 };
 
-// =============================================================================
-// Utilities
-// =============================================================================
-
 function shallowEqual<T extends object>(
   objA: T | undefined,
   objB: T | undefined,
@@ -57,10 +45,6 @@ function shallowEqual<T extends object>(
   return true;
 }
 
-// =============================================================================
-// Base Subscribable (simple pub-sub)
-// =============================================================================
-
 export class BaseSubscribable {
   private _subscribers = new Set<() => void>();
 
@@ -101,10 +85,7 @@ export class BaseSubscribable {
   }
 }
 
-// =============================================================================
-// Base Subject (lazy connect/disconnect)
-// =============================================================================
-
+// lazy connect/disconnect: only opens upstream subscription while it has subscribers
 export abstract class BaseSubject {
   private _subscriptions = new Set<() => void>();
   private _connection: Unsubscribe | undefined;
@@ -140,10 +121,6 @@ export abstract class BaseSubject {
   }
 }
 
-// =============================================================================
-// Subject Implementations
-// =============================================================================
-
 export class ShallowMemoizeSubject<TState extends object, TPath>
   extends BaseSubject
   implements SubscribableWithState<TState, TPath>

package/src/tests/MessageRepository.test.ts

@@ -457,6 +457,147 @@ describe("MessageRepository", () => {
     });
   });
 
+  describe("ExportedMessageRepository.fromBranchableArray", () => {
+    it("should create a branching tree structure", () => {
+      const items = [
+        {
+          message: {
+            id: "user-1",
+            role: "user" as const,
+            content: [{ type: "text" as const, text: "Hello" }],
+          },
+          parentId: null,
+        },
+        {
+          message: {
+            id: "assistant-1",
+            role: "assistant" as const,
+            content: [{ type: "text" as const, text: "Hi there" }],
+          },
+          parentId: "user-1",
+        },
+        {
+          message: {
+            id: "assistant-2",
+            role: "assistant" as const,
+            content: [{ type: "text" as const, text: "Hey!" }],
+          },
+          parentId: "user-1",
+        },
+      ];
+
+      const result = ExportedMessageRepository.fromBranchableArray(items);
+
+      expect(result.messages).toHaveLength(3);
+      expect(result.messages[0]!.parentId).toBeNull();
+      expect(result.messages[0]!.message.id).toBe("user-1");
+      expect(result.messages[1]!.parentId).toBe("user-1");
+      expect(result.messages[1]!.message.id).toBe("assistant-1");
+      expect(result.messages[2]!.parentId).toBe("user-1");
+      expect(result.messages[2]!.message.id).toBe("assistant-2");
+    });
+
+    it("should support headId option", () => {
+      const items = [
+        {
+          message: {
+            id: "msg-1",
+            role: "user" as const,
+            content: [{ type: "text" as const, text: "Hello" }],
+          },
+          parentId: null,
+        },
+        {
+          message: {
+            id: "msg-2a",
+            role: "assistant" as const,
+            content: [{ type: "text" as const, text: "Branch A" }],
+          },
+          parentId: "msg-1",
+        },
+        {
+          message: {
+            id: "msg-2b",
+            role: "assistant" as const,
+            content: [{ type: "text" as const, text: "Branch B" }],
+          },
+          parentId: "msg-1",
+        },
+      ];
+
+      const result = ExportedMessageRepository.fromBranchableArray(items, {
+        headId: "msg-2b",
+      });
+
+      expect(result.headId).toBe("msg-2b");
+    });
+
+    it("should throw if a message has no id", () => {
+      const items = [
+        {
+          message: {
+            role: "user" as const,
+            content: [{ type: "text" as const, text: "Hello" }],
+          },
+          parentId: null,
+        },
+      ];
+
+      expect(() =>
+        ExportedMessageRepository.fromBranchableArray(items),
+      ).toThrow(/Each message must have an 'id' field set/);
+    });
+
+    it("should handle empty arrays", () => {
+      const result = ExportedMessageRepository.fromBranchableArray([]);
+      expect(result.messages).toHaveLength(0);
+    });
+
+    it("should work with MessageRepository.import for branch switching", () => {
+      const items = [
+        {
+          message: {
+            id: "user-1",
+            role: "user" as const,
+            content: [{ type: "text" as const, text: "Hello" }],
+          },
+          parentId: null,
+        },
+        {
+          message: {
+            id: "assistant-a",
+            role: "assistant" as const,
+            content: [{ type: "text" as const, text: "Response A" }],
+          },
+          parentId: "user-1",
+        },
+        {
+          message: {
+            id: "assistant-b",
+            role: "assistant" as const,
+            content: [{ type: "text" as const, text: "Response B" }],
+          },
+          parentId: "user-1",
+        },
+      ];
+
+      const repo = ExportedMessageRepository.fromBranchableArray(items, {
+        headId: "assistant-a",
+      });
+
+      repository.import(repo);
+
+      // Should show branch A
+      let messages = repository.getMessages();
+      expect(messages.map((m) => m.id)).toEqual(["user-1", "assistant-a"]);
+
+      // Switch to branch B
+      repository.switchToBranch("assistant-b");
+      messages = repository.getMessages();
+      expect(messages.map((m) => m.id)).toEqual(["user-1", "assistant-b"]);
+    });
+  });
+
   describe("Complex scenarios", () => {
     it("should maintain tree structure after deletions", () => {
       const root = createTestMessage({ id: "root-id" });

package/src/tests/OptimisticState-list-race.test.ts

@@ -7,6 +7,7 @@ import {
   createThreadMappingId,
   updateStatusReducer,
 } from "../runtimes/remote-thread-list/remote-thread-state";
+import { deferred } from "./remote-thread-list-test-helpers";
 
 /**
  * Reproduces the race condition where a stale list() response
@@ -75,15 +76,6 @@ const applyListResult = (
   };
 };
 
-/** Creates a deferred promise for controlling resolution order. */
-function deferred<T>() {
-  let resolve!: (v: T) => void;
-  const promise = new Promise<T>((r) => {
-    resolve = r;
-  });
-  return { promise, resolve };
-}
-
 describe("list + delete race condition", () => {
   it("stale list() does not re-add a thread deleted while list was in flight", async () => {
     const state = new OptimisticState<RemoteThreadState>(EMPTY_STATE);
@@ -95,6 +87,7 @@ describe("list + delete race condition", () => {
     const listPromise = state.optimisticUpdate({
       execute: () => listDeferred.promise,
       loading: (s) => ({ ...s, isLoading: true }),
+      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 
@@ -152,6 +145,7 @@ describe("list + delete race condition", () => {
     const listPromise = state.optimisticUpdate({
       execute: () => listDeferred.promise,
       loading: (s) => ({ ...s, isLoading: true }),
+      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 
@@ -189,6 +183,7 @@ describe("list + delete race condition", () => {
     const listPromise = state.optimisticUpdate({
       execute: () => listDeferred.promise,
       loading: (s) => ({ ...s, isLoading: true }),
+      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 
@@ -226,6 +221,7 @@ describe("list + delete race condition", () => {
     const listPromise = state.optimisticUpdate({
       execute: () => listDeferred.promise,
       loading: (s) => ({ ...s, isLoading: true }),
+      // biome-ignore lint/suspicious/noThenProperty: OptimisticState reducer pattern
       then: applyListResult,
     });
 

package/src/tests/RemoteThreadListThreadListRuntimeCore-reload.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect, vi } from "vitest";
+import type { RemoteThreadListResponse } from "../runtimes/remote-thread-list/types";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+} from "./remote-thread-list-test-helpers";
+
+describe("RemoteThreadListThreadListRuntimeCore.reload", () => {
+  it("refetches list() after a successful empty load", async () => {
+    const listFn = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockResolvedValueOnce({ threads: [] })
+      .mockResolvedValueOnce({
+        threads: [
+          {
+            status: "regular",
+            remoteId: "t-1",
+            externalId: "t-1",
+            title: "After auth",
+          },
+        ],
+      });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    expect(listFn).toHaveBeenCalledTimes(1);
+    expect(core.threadIds).toEqual([]);
+
+    await core.reload();
+    expect(listFn).toHaveBeenCalledTimes(2);
+    expect(core.threadIds).toEqual(["t-1"]);
+  });
+
+  it("returns the same cached promise from getLoadThreadsPromise when reload is not called", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({ threads: [] })),
+    });
+    const core = createCore(adapter);
+
+    const p1 = core.getLoadThreadsPromise();
+    const p2 = core.getLoadThreadsPromise();
+    await p1;
+    await p2;
+
+    expect(adapter.list).toHaveBeenCalledTimes(1);
+  });
+
+  it("drops stale responses when a reload is triggered mid-flight", async () => {
+    const first = deferred<RemoteThreadListResponse>();
+    const second = deferred<RemoteThreadListResponse>();
+    const listFn = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockReturnValueOnce(first.promise)
+      .mockReturnValueOnce(second.promise);
+
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    core.getLoadThreadsPromise();
+    const reloaded = core.reload();
+
+    second.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "fresh",
+          externalId: "fresh",
+          title: "Fresh",
+        },
+      ],
+    });
+    await reloaded;
+
+    first.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "stale",
+          externalId: "stale",
+          title: "Stale",
+        },
+      ],
+    });
+    // flush microtasks so the stale then() reducer runs and its generation
+    // guard has a chance to discard the result
+    await Promise.resolve();
+
+    expect(core.threadIds).toEqual(["fresh"]);
+    expect(core.threadIds).not.toContain("stale");
+  });
+
+  it("recovers after a failed initial load", async () => {
+    const listFn = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockRejectedValueOnce(new Error("401"))
+      .mockResolvedValueOnce({
+        threads: [
+          {
+            status: "regular",
+            remoteId: "t-1",
+            externalId: "t-1",
+            title: "Authed",
+          },
+        ],
+      });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    expect(core.threadIds).toEqual([]);
+    expect(core.isLoading).toBe(false);
+
+    await core.reload();
+    expect(listFn).toHaveBeenCalledTimes(2);
+    expect(core.threadIds).toEqual(["t-1"]);
+  });
+
+  it("does not clear the active reload's promise when a stale load rejects", async () => {
+    const first = deferred<RemoteThreadListResponse>();
+    const second = deferred<RemoteThreadListResponse>();
+    const listFn = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockReturnValueOnce(first.promise)
+      .mockReturnValueOnce(second.promise);
+
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    core.getLoadThreadsPromise();
+    const reloaded = core.reload();
+
+    first.reject(new Error("stale 401"));
+    await Promise.resolve();
+
+    second.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "fresh",
+          externalId: "fresh",
+          title: "Fresh",
+        },
+      ],
+    });
+
+    await reloaded;
+    expect(core.threadIds).toEqual(["fresh"]);
+    expect(core.isLoading).toBe(false);
+  });
+
+  it("only the last of several overlapping reloads wins", async () => {
+    const deferreds = [
+      deferred<RemoteThreadListResponse>(),
+      deferred<RemoteThreadListResponse>(),
+      deferred<RemoteThreadListResponse>(),
+    ];
+    const listFn = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockImplementationOnce(() => deferreds[0]!.promise)
+      .mockImplementationOnce(() => deferreds[1]!.promise)
+      .mockImplementationOnce(() => deferreds[2]!.promise);
+
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    const r1 = core.getLoadThreadsPromise();
+    const r2 = core.reload();
+    const r3 = core.reload();
+
+    deferreds[2]!.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "c",
+          externalId: "c",
+          title: "c",
+        },
+      ],
+    });
+    await r3;
+
+    deferreds[0]!.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "a",
+          externalId: "a",
+          title: "a",
+        },
+      ],
+    });
+    deferreds[1]!.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "b",
+          externalId: "b",
+          title: "b",
+        },
+      ],
+    });
+    await r1;
+    await r2;
+
+    expect(core.threadIds).toEqual(["c"]);
+  });
+});

package/src/tests/RemoteThreadListThreadListRuntimeCore-switchToThread-dedupe.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi } from "vitest";
+import type {
+  RemoteThreadListResponse,
+  RemoteThreadMetadata,
+} from "../runtimes/remote-thread-list/types";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+} from "./remote-thread-list-test-helpers";
+
+describe("RemoteThreadListThreadListRuntimeCore.switchToThread dedupe", () => {
+  it("does not duplicate threadIds when list() resolves during fetch()", async () => {
+    const THREAD_ID = "thread-1";
+    const listDeferred = deferred<RemoteThreadListResponse>();
+    const fetchDeferred = deferred<RemoteThreadMetadata>();
+
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      fetch: vi.fn(() => fetchDeferred.promise),
+    });
+
+    const core = createCore(adapter, THREAD_ID);
+
+    const loadPromise = core.getLoadThreadsPromise();
+    const switchPromise = core.switchToThread(THREAD_ID);
+
+    // Commit `list()` before resolving `fetch()` so `switchToThread` reads a
+    // state that already contains THREAD_ID.
+    listDeferred.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: THREAD_ID,
+          externalId: THREAD_ID,
+          title: "Test",
+        },
+      ],
+    });
+    await loadPromise;
+
+    fetchDeferred.resolve({
+      status: "regular",
+      remoteId: THREAD_ID,
+      externalId: THREAD_ID,
+      title: "Test",
+    });
+    await switchPromise;
+
+    expect(core.threadIds.filter((id) => id === THREAD_ID)).toEqual([
+      THREAD_ID,
+    ]);
+  });
+
+  it("does not duplicate archivedThreadIds when list() resolves during fetch()", async () => {
+    const THREAD_ID = "archived-1";
+    const listDeferred = deferred<RemoteThreadListResponse>();
+    const fetchDeferred = deferred<RemoteThreadMetadata>();
+
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      fetch: vi.fn(() => fetchDeferred.promise),
+    });
+
+    const core = createCore(adapter, THREAD_ID);
+    // Without this stub, auto-unarchive would filter `archivedThreadIds` via
+    // `updateStatusReducer`, hiding any duplicate written by `switchToThread`.
+    (
+      core as unknown as { unarchive: (id: string) => Promise<void> }
+    ).unarchive = async () => {};
+
+    const loadPromise = core.getLoadThreadsPromise();
+    const switchPromise = core.switchToThread(THREAD_ID);
+
+    listDeferred.resolve({
+      threads: [
+        {
+          status: "archived",
+          remoteId: THREAD_ID,
+          externalId: THREAD_ID,
+          title: "Archived",
+        },
+      ],
+    });
+    await loadPromise;
+
+    fetchDeferred.resolve({
+      status: "archived",
+      remoteId: THREAD_ID,
+      externalId: THREAD_ID,
+      title: "Archived",
+    });
+    await switchPromise;
+
+    expect(core.archivedThreadIds.filter((id) => id === THREAD_ID)).toEqual([
+      THREAD_ID,
+    ]);
+  });
+
+  it("moves the id to the correct array when list() and fetch() disagree on status", async () => {
+    const THREAD_ID = "flipped-1";
+    const listDeferred = deferred<RemoteThreadListResponse>();
+    const fetchDeferred = deferred<RemoteThreadMetadata>();
+
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      fetch: vi.fn(() => fetchDeferred.promise),
+    });
+
+    const core = createCore(adapter, THREAD_ID);
+
+    const loadPromise = core.getLoadThreadsPromise();
+    const switchPromise = core.switchToThread(THREAD_ID);
+
+    // A concurrent unarchive between `list()` and `fetch()` flips the status.
+    listDeferred.resolve({
+      threads: [
+        {
+          status: "archived",
+          remoteId: THREAD_ID,
+          externalId: THREAD_ID,
+          title: "Flipped",
+        },
+      ],
+    });
+    await loadPromise;
+
+    fetchDeferred.resolve({
+      status: "regular",
+      remoteId: THREAD_ID,
+      externalId: THREAD_ID,
+      title: "Flipped",
+    });
+    await switchPromise;
+
+    expect(core.threadIds).toContain(THREAD_ID);
+    expect(core.archivedThreadIds).not.toContain(THREAD_ID);
+  });
+});