@assistant-ui/core 0.3.17 → 0.3.18

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

@@ -3,6 +3,9 @@ import {
   classifyThreads,
   createEmptyRemoteThreadState,
   createThreadMappingId,
+  getThreadData,
+  promoteNewThreadReducer,
+  reconcileInitializedThread,
   seedNewThread,
   updateStatusReducer,
 } from "./remote-thread-state";
@@ -13,12 +16,16 @@ import type {
 
 const initializedDraft = () => {
   const seeded = seedNewThread(createEmptyRemoteThreadState());
-  const regular = updateStatusReducer(seeded.state, seeded.id, "regular");
-  const mappingId = regular.threadIdMap[seeded.id]!;
   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,
@@ -54,6 +61,7 @@ describe("remote thread state", () => {
   it("creates an empty state", () => {
     expect(createEmptyRemoteThreadState()).toEqual({
       isLoading: true,
+      loadError: undefined,
       isLoadingMore: false,
       cursor: undefined,
       newThreadId: undefined,
@@ -80,6 +88,39 @@ 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();
 
@@ -131,6 +172,91 @@ describe("remote thread state", () => {
     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();

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 =
   | {
@@ -64,7 +65,11 @@ export const classifyThreads = (
   threads: readonly RemoteThreadMetadata[],
   acc: ClassifyAccumulator,
 ): ClassifyAccumulator => {
-  const listed = new Set([...acc.threadIds, ...acc.archivedThreadIds]);
+  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) {
@@ -77,10 +82,10 @@ export const classifyThreads = (
       }
     }
 
-    const existingMappingId = acc.threadIdMap[thread.remoteId];
+    const existingMappingId = threadIdMap[thread.remoteId];
     const existing =
       existingMappingId !== undefined
-        ? acc.threadData[existingMappingId]
+        ? threadData[existingMappingId]
         : undefined;
     const id = existing?.id ?? thread.remoteId;
     const mappingId = existingMappingId ?? createThreadMappingId(id);
@@ -92,23 +97,23 @@ export const classifyThreads = (
     if (!listed.has(id)) {
       listed.add(id);
       if (thread.status === "regular") {
-        acc.threadIds.push(id);
+        threadIds.push(id);
       } else {
-        acc.archivedThreadIds.push(id);
+        archivedThreadIds.push(id);
       }
     } else if (existing !== undefined && existing.status !== thread.status) {
       if (thread.status === "regular") {
-        acc.archivedThreadIds = acc.archivedThreadIds.filter((t) => t !== id);
-        acc.threadIds.push(id);
+        archivedThreadIds = archivedThreadIds.filter((t) => t !== id);
+        threadIds.push(id);
       } else {
-        acc.threadIds = acc.threadIds.filter((t) => t !== id);
-        acc.archivedThreadIds.push(id);
+        threadIds = threadIds.filter((t) => t !== id);
+        archivedThreadIds.push(id);
       }
     }
 
-    acc.threadIdMap[id] = mappingId;
-    acc.threadIdMap[thread.remoteId] = mappingId;
-    acc.threadData[mappingId] = {
+    threadIdMap[id] = mappingId;
+    threadIdMap[thread.remoteId] = mappingId;
+    threadData[mappingId] = {
       ...(existing?.localOrigin === true ? { localOrigin: true as const } : {}),
       id,
       remoteId: thread.remoteId,
@@ -125,11 +130,12 @@ export const classifyThreads = (
         }),
     };
   }
-  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;
@@ -141,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 = (
@@ -163,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,
@@ -178,7 +183,7 @@ export const seedNewThread = (
           custom: undefined,
           localOrigin: true,
         } satisfies RemoteThreadData,
-      },
+      }),
     },
   };
 };
@@ -260,15 +265,124 @@ 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;
@@ -276,6 +390,18 @@ export const updateStatusReducer = (
   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
@@ -310,16 +436,14 @@ export const updateStatusReducer = (
 
     case "deleted": {
       const mappingId = state.threadIdMap[threadIdOrRemoteId]!;
-      newState.threadData = Object.fromEntries(
-        Object.entries(newState.threadData).filter(
-          ([key]) => key !== mappingId,
-        ),
-      );
-      newState.threadIdMap = Object.fromEntries(
-        Object.entries(newState.threadIdMap).filter(
-          ([, value]) => value !== mappingId,
-        ),
-      );
+      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;
     }
 
@@ -329,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);