@assistant-ui/core 0.3.16 → 0.3.18

package/src/runtimes/remote-thread-list/remote-thread-state.test.ts

@@ -1,14 +1,67 @@
 import { describe, expect, it } from "vitest";
 import {
+  classifyThreads,
   createEmptyRemoteThreadState,
   createThreadMappingId,
+  getThreadData,
+  promoteNewThreadReducer,
+  reconcileInitializedThread,
   seedNewThread,
+  updateStatusReducer,
 } from "./remote-thread-state";
+import type {
+  RemoteThreadData,
+  RemoteThreadState,
+} from "./remote-thread-state";
+
+const initializedDraft = () => {
+  const seeded = seedNewThread(createEmptyRemoteThreadState());
+  const initializeTask = Promise.resolve({
+    remoteId: "remote-1",
+    externalId: "remote-1",
+  });
+  const regular = promoteNewThreadReducer(
+    seeded.state,
+    seeded.id,
+    initializeTask,
+  );
+  const mappingId = regular.threadIdMap[seeded.id]!;
+  return {
+    id: seeded.id,
+    mappingId,
+    initializeTask,
+    state: {
+      ...regular,
+      threadIdMap: { ...regular.threadIdMap, "remote-1": mappingId },
+      threadData: {
+        ...regular.threadData,
+        [mappingId]: {
+          ...regular.threadData[mappingId]!,
+          remoteId: "remote-1",
+          externalId: "remote-1",
+          initializeTask,
+        } as RemoteThreadData,
+      },
+    } as RemoteThreadState,
+  };
+};
+
+const expectOneSlotPerIdentity = (state: RemoteThreadState) => {
+  const remoteIds = Object.values(state.threadData)
+    .map((data) => data.remoteId)
+    .filter((remoteId) => remoteId !== undefined);
+  expect(new Set(remoteIds).size).toBe(remoteIds.length);
+
+  for (const id of [...state.threadIds, ...state.archivedThreadIds]) {
+    expect(state.threadData[state.threadIdMap[id]!]?.id).toBe(id);
+  }
+};
 
 describe("remote thread state", () => {
   it("creates an empty state", () => {
     expect(createEmptyRemoteThreadState()).toEqual({
       isLoading: true,
+      loadError: undefined,
       isLoadingMore: false,
       cursor: undefined,
       newThreadId: undefined,
@@ -34,4 +87,189 @@ describe("remote thread state", () => {
     );
     expect(Object.keys(second.state.threadData)).toEqual([first.id, second.id]);
   });
+
+  it("carries the initialization task onto the promoted slot", () => {
+    const seeded = seedNewThread(createEmptyRemoteThreadState());
+    const initializeTask = Promise.resolve({
+      remoteId: "remote-1",
+      externalId: "external-1",
+    });
+
+    const promoted = promoteNewThreadReducer(
+      seeded.state,
+      seeded.id,
+      initializeTask,
+    );
+    const data = getThreadData(promoted, seeded.id);
+
+    expect(data?.status).toBe("regular");
+    expect(data?.status === "new" ? undefined : data?.initializeTask).toBe(
+      initializeTask,
+    );
+    expect(promoted.newThreadId).toBeUndefined();
+    expect(promoted.threadIds).toEqual([seeded.id]);
+  });
+
+  it.each(["regular", "archived"] as const)(
+    "leaves a new thread untouched when moved to %s without an initialization task",
+    (newStatus) => {
+      const seeded = seedNewThread(createEmptyRemoteThreadState());
+
+      expect(updateStatusReducer(seeded.state, seeded.id, newStatus)).toBe(
+        seeded.state,
+      );
+    },
+  );
+
+  it("refreshes the local slot when a listed thread already has a mapping", () => {
+    const draft = initializedDraft();
+
+    const merged = classifyThreads(
+      [
+        {
+          status: "regular",
+          remoteId: "remote-1",
+          externalId: "remote-1",
+          title: "from the server",
+        },
+      ],
+      {
+        threadIds: [],
+        archivedThreadIds: [],
+        threadIdMap: { ...draft.state.threadIdMap },
+        threadData: { ...draft.state.threadData },
+      },
+    );
+
+    expect(Object.keys(merged.threadData)).toEqual([draft.mappingId]);
+    expect(merged.threadIds).toEqual([draft.id]);
+    expect(merged.threadIdMap["remote-1"]).toBe(draft.mappingId);
+    expect(merged.threadData[draft.mappingId]?.id).toBe(draft.id);
+    expect(merged.threadData[draft.mappingId]?.title).toBe("from the server");
+    expect(merged.threadData[draft.mappingId]?.localOrigin).toBe(true);
+    const refreshed = merged.threadData[draft.mappingId]!;
+    expect(
+      refreshed.status === "new" ? undefined : refreshed.initializeTask,
+    ).toBe(draft.initializeTask);
+    expectOneSlotPerIdentity({ ...draft.state, ...merged });
+  });
+
+  it("lists a repeated remote id once", () => {
+    const listed = classifyThreads(
+      [
+        { status: "regular", remoteId: "a", externalId: "a", title: "first" },
+        { status: "regular", remoteId: "a", externalId: "a", title: "second" },
+      ],
+      {
+        threadIds: [],
+        archivedThreadIds: [],
+        threadIdMap: {},
+        threadData: {},
+      },
+    );
+
+    expect(listed.threadIds).toEqual(["a"]);
+    expect(listed.threadData[createThreadMappingId("a")]?.title).toBe("second");
+  });
+
+  it("retains a listed external id when that slot survives reconciliation", async () => {
+    const seeded = seedNewThread(createEmptyRemoteThreadState());
+    const regular = promoteNewThreadReducer(
+      seeded.state,
+      seeded.id,
+      Promise.resolve({ remoteId: "remote-1", externalId: "external-1" }),
+    );
+    const classified = classifyThreads(
+      [
+        {
+          status: "regular",
+          remoteId: "remote-1",
+          externalId: "external-1",
+        },
+      ],
+      {
+        threadIds: [...regular.threadIds],
+        archivedThreadIds: [...regular.archivedThreadIds],
+        threadIdMap: { ...regular.threadIdMap },
+        threadData: { ...regular.threadData },
+      },
+    );
+    const state = { ...regular, ...classified };
+
+    const reconciled = reconcileInitializedThread(
+      state,
+      seeded.id,
+      "remote-1",
+      undefined,
+      "remote-1",
+    );
+    const survivor = reconciled.state.threadData[reconciled.survivorMappingId]!;
+
+    expect(survivor.externalId).toBe("external-1");
+    if (survivor.status === "new") throw new Error("Expected initialized slot");
+    await expect(survivor.initializeTask).resolves.toEqual({
+      remoteId: "remote-1",
+      externalId: "external-1",
+    });
+  });
+
+  it.each(["__proto__", "constructor", "toString"])(
+    "handles a prototype-named remote id %s",
+    (remoteId) => {
+      const classified = classifyThreads(
+        [
+          {
+            status: "regular",
+            remoteId,
+            externalId: undefined,
+            title: `title-${remoteId}`,
+          },
+          {
+            status: "regular",
+            remoteId: "ok",
+            externalId: undefined,
+            title: "title-ok",
+          },
+        ],
+        {
+          threadIds: [],
+          archivedThreadIds: [],
+          threadIdMap: {},
+          threadData: {},
+        },
+      );
+      const listed: RemoteThreadState = {
+        ...createEmptyRemoteThreadState(),
+        threadIds: classified.threadIds,
+        archivedThreadIds: classified.archivedThreadIds,
+        threadIdMap: classified.threadIdMap,
+        threadData: classified.threadData,
+      };
+
+      expect(Object.keys(listed.threadIdMap)).toEqual([remoteId, "ok"]);
+      expect(typeof listed.threadIdMap[remoteId]).toBe("string");
+      expect(Object.keys(listed.threadData)).toEqual([remoteId, "ok"]);
+
+      const deleted = updateStatusReducer(listed, remoteId, "deleted");
+      expect(Object.keys(deleted.threadIdMap)).toEqual(["ok"]);
+      expect(Object.keys(deleted.threadData)).toEqual(["ok"]);
+      expect(deleted.threadIds).toEqual(["ok"]);
+    },
+  );
+
+  it("deletes every alias of an identity, by either id", () => {
+    for (const target of ["remote-1", "local"] as const) {
+      const draft = initializedDraft();
+      const deleted = updateStatusReducer(
+        draft.state,
+        target === "local" ? draft.id : target,
+        "deleted",
+      );
+
+      expect(deleted.threadData).toEqual({});
+      expect(deleted.threadIdMap).toEqual({});
+      expect(deleted.threadIds).toEqual([]);
+      expect(deleted.archivedThreadIds).toEqual([]);
+    }
+  });
 });

package/src/runtimes/remote-thread-list/remote-thread-state.ts

@@ -3,6 +3,7 @@ import type {
   RemoteThreadMetadata,
 } from "./types";
 import { generateId } from "../../utils/id";
+import { nullProtoRecord } from "../../utils/record";
 
 export type RemoteThreadData =
   | {
@@ -47,26 +48,33 @@ export const LOCAL_THREAD_ID_PREFIX = "__LOCALID_";
 export const normalizeCursor = (c: string | undefined): string | undefined =>
   c || undefined;
 
-type ClassifyAccumulator = {
+export type ClassifyAccumulator = {
   threadIds: string[];
   archivedThreadIds: string[];
   threadIdMap: Record<string, THREAD_MAPPING_ID>;
   threadData: Record<THREAD_MAPPING_ID, RemoteThreadData>;
 };
 
+// A slot's `id` is fixed when it is minted: the hook instance manager keys live
+// thread runtimes by it, so renaming a slot would detach the runtime the user is
+// chatting in. A listed thread whose `remoteId` already maps to a slot therefore
+// refreshes that slot instead of minting a second one, and a slot minted by a
+// list() that raced ahead of the remote id collapses when `initialize()` settles.
+// `threadIds`/`archivedThreadIds` carry slot ids, never remote ids.
 export const classifyThreads = (
   threads: readonly RemoteThreadMetadata[],
   acc: ClassifyAccumulator,
 ): ClassifyAccumulator => {
-  for (const thread of threads) {
-    if (acc.threadIdMap[thread.remoteId] !== undefined) continue;
+  let threadIds = [...acc.threadIds];
+  let archivedThreadIds = [...acc.archivedThreadIds];
+  const threadIdMap = nullProtoRecord(acc.threadIdMap);
+  const threadData = nullProtoRecord(acc.threadData);
+  const listed = new Set([...threadIds, ...archivedThreadIds]);
 
+  for (const thread of threads) {
     switch (thread.status) {
       case "regular":
-        acc.threadIds.push(thread.remoteId);
-        break;
       case "archived":
-        acc.archivedThreadIds.push(thread.remoteId);
         break;
       default: {
         const _exhaustiveCheck: never = thread.status;
@@ -74,27 +82,60 @@ export const classifyThreads = (
       }
     }
 
-    const mappingId = createThreadMappingId(thread.remoteId);
-    acc.threadIdMap[thread.remoteId] = mappingId;
-    acc.threadData[mappingId] = {
-      id: thread.remoteId,
+    const existingMappingId = threadIdMap[thread.remoteId];
+    const existing =
+      existingMappingId !== undefined
+        ? threadData[existingMappingId]
+        : undefined;
+    const id = existing?.id ?? thread.remoteId;
+    const mappingId = existingMappingId ?? createThreadMappingId(id);
+    const existingTask =
+      existing !== undefined && existing.status !== "new"
+        ? existing.initializeTask
+        : undefined;
+
+    if (!listed.has(id)) {
+      listed.add(id);
+      if (thread.status === "regular") {
+        threadIds.push(id);
+      } else {
+        archivedThreadIds.push(id);
+      }
+    } else if (existing !== undefined && existing.status !== thread.status) {
+      if (thread.status === "regular") {
+        archivedThreadIds = archivedThreadIds.filter((t) => t !== id);
+        threadIds.push(id);
+      } else {
+        threadIds = threadIds.filter((t) => t !== id);
+        archivedThreadIds.push(id);
+      }
+    }
+
+    threadIdMap[id] = mappingId;
+    threadIdMap[thread.remoteId] = mappingId;
+    threadData[mappingId] = {
+      ...(existing?.localOrigin === true ? { localOrigin: true as const } : {}),
+      id,
       remoteId: thread.remoteId,
       externalId: thread.externalId,
       status: thread.status,
       title: thread.title,
       lastMessageAt: thread.lastMessageAt,
       custom: thread.custom,
-      initializeTask: Promise.resolve({
-        remoteId: thread.remoteId,
-        externalId: thread.externalId,
-      }),
+      initializeTask:
+        existingTask ??
+        Promise.resolve({
+          remoteId: thread.remoteId,
+          externalId: thread.externalId,
+        }),
     };
   }
-  return acc;
+  return { threadIds, archivedThreadIds, threadIdMap, threadData };
 };
 
 export type RemoteThreadState = {
   readonly isLoading: boolean;
+  readonly loadError: unknown;
   readonly isLoadingMore: boolean;
   readonly cursor: string | undefined;
   readonly newThreadId: string | undefined;
@@ -106,13 +147,14 @@ export type RemoteThreadState = {
 
 export const createEmptyRemoteThreadState = (): RemoteThreadState => ({
   isLoading: true,
+  loadError: undefined,
   isLoadingMore: false,
   cursor: undefined,
   newThreadId: undefined,
   threadIds: [],
   archivedThreadIds: [],
-  threadIdMap: {},
-  threadData: {},
+  threadIdMap: nullProtoRecord(),
+  threadData: nullProtoRecord(),
 });
 
 export const seedNewThread = (
@@ -128,12 +170,10 @@ export const seedNewThread = (
     state: {
       ...state,
       newThreadId: id,
-      threadIdMap: {
-        ...state.threadIdMap,
+      threadIdMap: nullProtoRecord(state.threadIdMap, {
         [id]: mappingId,
-      },
-      threadData: {
-        ...state.threadData,
+      }),
+      threadData: nullProtoRecord(state.threadData, {
         [mappingId]: {
           status: "new",
           id,
@@ -143,7 +183,7 @@ export const seedNewThread = (
           custom: undefined,
           localOrigin: true,
         } satisfies RemoteThreadData,
-      },
+      }),
     },
   };
 };
@@ -225,22 +265,143 @@ export const getThreadData = (
   state: RemoteThreadState,
   threadIdOrRemoteId: string,
 ) => {
-  const idx = state.threadIdMap[threadIdOrRemoteId];
+  const idx = Object.hasOwn(state.threadIdMap, threadIdOrRemoteId)
+    ? state.threadIdMap[threadIdOrRemoteId]
+    : undefined;
   if (idx === undefined) return undefined;
-  return state.threadData[idx];
+  return Object.hasOwn(state.threadData, idx)
+    ? state.threadData[idx]
+    : undefined;
 };
 
-export const updateStatusReducer = (
+export const reconcileInitializedThread = (
+  state: RemoteThreadState,
+  threadId: string,
+  remoteId: string,
+  externalId: string | undefined,
+  retainedThreadId?: string,
+): {
+  state: RemoteThreadState;
+  removedMappingId: THREAD_MAPPING_ID | undefined;
+  survivorMappingId: THREAD_MAPPING_ID;
+} => {
+  const mappingId = createThreadMappingId(threadId);
+  const data = Object.hasOwn(state.threadData, mappingId)
+    ? state.threadData[mappingId]
+    : undefined;
+  if (!data) {
+    return { state, removedMappingId: undefined, survivorMappingId: mappingId };
+  }
+
+  // A concurrent list cannot associate the remote ID with this initializing
+  // slot and may mint a duplicate. Retain the slot whose mounted runtime owns
+  // local state; initialized metadata remains authoritative over list metadata.
+  const listedMappingId = Object.hasOwn(state.threadIdMap, remoteId)
+    ? state.threadIdMap[remoteId]
+    : undefined;
+  const listedData =
+    listedMappingId !== undefined &&
+    listedMappingId !== mappingId &&
+    Object.hasOwn(state.threadData, listedMappingId)
+      ? state.threadData[listedMappingId]
+      : undefined;
+  const listedSlot =
+    listedMappingId !== undefined && listedData !== undefined
+      ? { mappingId: listedMappingId, data: listedData }
+      : undefined;
+  const retainedMappingId =
+    retainedThreadId !== undefined &&
+    Object.hasOwn(state.threadIdMap, retainedThreadId)
+      ? state.threadIdMap[retainedThreadId]
+      : undefined;
+  const survivorMappingId =
+    listedSlot !== undefined && retainedMappingId === listedSlot.mappingId
+      ? listedSlot.mappingId
+      : mappingId;
+  const removedMappingId =
+    listedSlot === undefined
+      ? undefined
+      : survivorMappingId === mappingId
+        ? listedSlot.mappingId
+        : mappingId;
+  const resolvedExternalId = externalId ?? listedSlot?.data.externalId;
+  const threadData = nullProtoRecord(state.threadData);
+  if (removedMappingId !== undefined) delete threadData[removedMappingId];
+  const initializedData = {
+    ...data,
+    id: survivorMappingId,
+    initializeTask: Promise.resolve({
+      remoteId,
+      externalId: resolvedExternalId,
+    }),
+    remoteId,
+    externalId: resolvedExternalId,
+  } as RemoteThreadData;
+  threadData[survivorMappingId] = {
+    ...listedSlot?.data,
+    ...initializedData,
+    title: data.title ?? listedSlot?.data.title,
+    lastMessageAt:
+      ("lastMessageAt" in data ? data.lastMessageAt : undefined) ??
+      (listedSlot && "lastMessageAt" in listedSlot.data
+        ? listedSlot.data.lastMessageAt
+        : undefined),
+    custom: data.custom ?? listedSlot?.data.custom,
+  } as RemoteThreadData;
+
+  const threadIdMap = nullProtoRecord(state.threadIdMap);
+  if (removedMappingId !== undefined) {
+    for (const [id, target] of Object.entries(threadIdMap)) {
+      if (target === removedMappingId) threadIdMap[id] = survivorMappingId;
+    }
+  }
+  threadIdMap[threadId] = survivorMappingId;
+  threadIdMap[remoteId] = survivorMappingId;
+
+  const rewire = (ids: readonly string[]) =>
+    listedSlot === undefined
+      ? ids
+      : ids
+          .filter((id) => id !== listedSlot.data.id)
+          .map((id) => (id === data.id ? survivorMappingId : id));
+
+  return {
+    state: {
+      ...state,
+      threadIds: rewire(state.threadIds),
+      archivedThreadIds: rewire(state.archivedThreadIds),
+      threadIdMap,
+      threadData,
+    },
+    removedMappingId,
+    survivorMappingId,
+  };
+};
+
+const transitionReducer = (
   state: RemoteThreadState,
   threadIdOrRemoteId: string,
   newStatus: "regular" | "archived" | "deleted",
+  initializeTask: Promise<RemoteThreadInitializeResponse> | undefined,
 ) => {
   const data = getThreadData(state, threadIdOrRemoteId);
   if (!data) return state;
 
-  const { id, remoteId, status: lastStatus } = data;
+  const { id, status: lastStatus } = data;
   if (lastStatus === newStatus) return state;
 
+  let nextData: RemoteThreadData | undefined;
+  if (newStatus !== "deleted") {
+    if (data.status === "new") {
+      // The new variant holds no initialization promise, so the destination
+      // union member cannot be built unless the caller supplies one.
+      if (initializeTask === undefined) return state;
+      nextData = { ...data, initializeTask, status: newStatus };
+    } else {
+      nextData = { ...data, status: newStatus };
+    }
+  }
+
   const newState = { ...state };
 
   // lastStatus
@@ -273,16 +434,18 @@ export const updateStatusReducer = (
       newState.archivedThreadIds = [id, ...newState.archivedThreadIds];
       break;
 
-    case "deleted":
-      newState.threadData = Object.fromEntries(
-        Object.entries(newState.threadData).filter(([key]) => key !== id),
-      );
-      newState.threadIdMap = Object.fromEntries(
-        Object.entries(newState.threadIdMap).filter(
-          ([key]) => key !== id && key !== remoteId,
-        ),
-      );
+    case "deleted": {
+      const mappingId = state.threadIdMap[threadIdOrRemoteId]!;
+      const threadData = nullProtoRecord(newState.threadData);
+      delete threadData[mappingId];
+      newState.threadData = threadData;
+      const threadIdMap = nullProtoRecord(newState.threadIdMap);
+      for (const [key, value] of Object.entries(threadIdMap)) {
+        if (value === mappingId) delete threadIdMap[key];
+      }
+      newState.threadIdMap = threadIdMap;
       break;
+    }
 
     default: {
       const _exhaustiveCheck: never = newStatus;
@@ -290,15 +453,31 @@ export const updateStatusReducer = (
     }
   }
 
-  if (newStatus !== "deleted") {
-    newState.threadData = {
-      ...newState.threadData,
-      [id]: {
-        ...data,
-        status: newStatus,
-      },
-    };
+  if (nextData !== undefined) {
+    newState.threadData = { ...newState.threadData, [id]: nextData };
   }
 
   return newState;
 };
+
+/**
+ * Transitions a thread that already exists remotely. Promoting the local draft
+ * off `new` needs the initialization promise its destination variant requires,
+ * so that goes through `promoteNewThreadReducer`; asking for it here leaves the
+ * state unchanged.
+ */
+export const updateStatusReducer = (
+  state: RemoteThreadState,
+  threadIdOrRemoteId: string,
+  newStatus: "regular" | "archived" | "deleted",
+) => transitionReducer(state, threadIdOrRemoteId, newStatus, undefined);
+
+/**
+ * Promotes the local draft to `regular`, carrying the initialization promise
+ * onto the slot.
+ */
+export const promoteNewThreadReducer = (
+  state: RemoteThreadState,
+  threadIdOrRemoteId: string,
+  initializeTask: Promise<RemoteThreadInitializeResponse>,
+) => transitionReducer(state, threadIdOrRemoteId, "regular", initializeTask);