@assistant-ui/core 0.2.21 → 0.2.22

package/src/subscribable/subscribable.ts

@@ -1,4 +1,5 @@
 import type { Unsubscribe } from "../types/unsubscribe";
+import { notifyEventListeners } from "../utils/notify-event-listeners";
 
 export const SKIP_UPDATE = Symbol("skip-update");
 export type SKIP_UPDATE = typeof SKIP_UPDATE;
@@ -39,7 +40,10 @@ function shallowEqual<T extends object>(
   if (objA === undefined) return false;
   if (objB === undefined) return false;
 
-  for (const key of Object.keys(objA)) {
+  const keysA = Object.keys(objA);
+  if (keysA.length !== Object.keys(objB).length) return false;
+
+  for (const key of keysA) {
     const valueA = objA[key as keyof T];
     const valueB = objB[key as keyof T];
     if (!Object.is(valueA, valueB)) return false;
@@ -99,7 +103,12 @@ export abstract class BaseSubject {
 
   protected abstract _connect(): Unsubscribe;
 
-  protected notifySubscribers(payload?: unknown) {
+  protected notifySubscribers(payload?: unknown, errorContext?: string) {
+    if (errorContext) {
+      notifyEventListeners(this._subscriptions, payload, errorContext);
+      return;
+    }
+
     for (const callback of this._subscriptions) callback(payload);
   }
 
@@ -273,8 +282,9 @@ export class EventSubscriptionSubject<
   }
 
   protected _connect(): Unsubscribe {
+    const errorContext = `Runtime event "${this.config.event}"`;
     const callback = (payload?: unknown) => {
-      this.notifySubscribers(payload);
+      this.notifySubscribers(payload, errorContext);
     };
 
     let lastState = this.config.binding.getState();

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

@@ -79,6 +79,39 @@ const applyListResult = (
 };
 
 describe("list + delete race condition", () => {
+  it("stale list() does not re-add a thread deleted before list started", async () => {
+    const state = new OptimisticState<RemoteThreadState>(
+      applyListResult(EMPTY_STATE, {
+        threads: [{ remoteId: "thread-A", status: "regular", title: "A" }],
+      }),
+    );
+    const deleteDeferred = deferred<void>();
+    const listDeferred = deferred<ListResult>();
+
+    const deletePromise = state.optimisticUpdate({
+      execute: () => deleteDeferred.promise,
+      optimistic: (s) => updateStatusReducer(s, "thread-A", "deleted"),
+    });
+    const listPromise = state.optimisticUpdate({
+      execute: () => listDeferred.promise,
+      loading: (s) => ({ ...s, isLoading: true }),
+      then: applyListResult,
+    });
+
+    deleteDeferred.resolve();
+    await deletePromise;
+
+    listDeferred.resolve({
+      threads: [{ remoteId: "thread-A", status: "regular", title: "A" }],
+    });
+    await listPromise;
+
+    expect(state.value.threadIds).not.toContain("thread-A");
+    expect(
+      state.value.threadData[createThreadMappingId("thread-A")],
+    ).toBeUndefined();
+  });
+
   it("stale list() does not re-add a thread deleted while list was in flight", async () => {
     const state = new OptimisticState<RemoteThreadState>(EMPTY_STATE);
 

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

@@ -0,0 +1,223 @@
+import { describe, expect, it, vi } from "vitest";
+import type { RemoteThreadMetadata } from "../runtimes/remote-thread-list/types";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+  setStartThreadRuntime,
+} from "./remote-thread-list-test-helpers";
+
+const thread = (id: string): RemoteThreadMetadata => ({
+  status: "regular",
+  remoteId: id,
+  externalId: id,
+  title: id,
+});
+
+describe("RemoteThreadListThreadListRuntimeCore.switchToThread order", () => {
+  it("preserves the latest switch when an earlier fetch resolves last", async () => {
+    const fetchB = deferred<RemoteThreadMetadata>();
+    const fetchC = deferred<RemoteThreadMetadata>();
+    const adapter = makeAdapter({
+      fetch: vi.fn((id: string) =>
+        id === "thread-b" ? fetchB.promise : fetchC.promise,
+      ),
+    });
+    const core = createCore(adapter);
+
+    const switchToB = core.switchToThread("thread-b");
+    const switchToC = core.switchToThread("thread-c");
+
+    fetchC.resolve(thread("thread-c"));
+    await switchToC;
+    fetchB.resolve(thread("thread-b"));
+    await switchToB;
+
+    expect(core.mainThreadId).toBe(core.getItemById("thread-c")?.id);
+  });
+
+  it("preserves the latest switch when an earlier runtime starts last", async () => {
+    const runtimeB = deferred<unknown>();
+    const runtimeC = deferred<unknown>();
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [thread("thread-b"), thread("thread-c")],
+      })),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+
+    setStartThreadRuntime(core, (id) =>
+      id === core.getItemById("thread-b")?.id
+        ? runtimeB.promise
+        : runtimeC.promise,
+    );
+
+    const switchToB = core.switchToThread("thread-b");
+    const switchToC = core.switchToThread("thread-c");
+
+    runtimeC.resolve({});
+    await switchToC;
+    runtimeB.resolve({});
+    await switchToB;
+
+    expect(core.mainThreadId).toBe(core.getItemById("thread-c")?.id);
+  });
+
+  it("invalidates an earlier switch while a new thread request is pending", async () => {
+    const initializeThread = deferred<{
+      remoteId: string;
+      externalId: string;
+    }>();
+    const runtimeB = deferred<unknown>();
+    const adapter = makeAdapter({
+      initialize: vi.fn(() => initializeThread.promise),
+      list: vi.fn(async () => ({ threads: [thread("thread-b")] })),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+
+    const initialNewThreadId = core.newThreadId;
+    if (!initialNewThreadId) throw new Error("Expected an initial new thread");
+
+    const threadBId = core.getItemById("thread-b")?.id;
+    setStartThreadRuntime(core, (id) =>
+      id === threadBId ? runtimeB.promise : Promise.resolve({}),
+    );
+
+    const initialize = core.initialize(initialNewThreadId);
+    const switchToB = core.switchToThread("thread-b");
+    const switchToNewThread = core.switchToNewThread();
+
+    runtimeB.resolve({});
+    await switchToB;
+
+    expect(core.mainThreadId).not.toBe(threadBId);
+
+    initializeThread.resolve({
+      remoteId: "initialized-thread",
+      externalId: "initialized-thread",
+    });
+    await initialize;
+    await switchToNewThread;
+
+    expect(core.mainThreadId).toBe(core.getItemById(core.newThreadId!)?.id);
+  });
+
+  it("does not let a pending new thread request override a later switch", async () => {
+    const initializeThread = deferred<{
+      remoteId: string;
+      externalId: string;
+    }>();
+    const adapter = makeAdapter({
+      initialize: vi.fn(() => initializeThread.promise),
+      list: vi.fn(async () => ({ threads: [thread("thread-c")] })),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+
+    const initialNewThreadId = core.newThreadId;
+    if (!initialNewThreadId) throw new Error("Expected an initial new thread");
+
+    const initialize = core.initialize(initialNewThreadId);
+    const switchToNewThread = core.switchToNewThread();
+    await core.switchToThread("thread-c");
+
+    initializeThread.resolve({
+      remoteId: "initialized-thread",
+      externalId: "initialized-thread",
+    });
+    await initialize;
+    await switchToNewThread;
+
+    expect(core.mainThreadId).toBe(core.getItemById("thread-c")?.id);
+  });
+
+  it("keeps mutations waiting when a newer switch fails", async () => {
+    const fetchB = deferred<RemoteThreadMetadata>();
+    const newThreadRuntime = deferred<unknown>();
+    const adapter = makeAdapter({
+      fetch: vi.fn(() => fetchB.promise),
+      list: vi.fn(async () => ({ threads: [thread("thread-a")] })),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    const threadAId = core.getItemById("thread-a")?.id;
+    const newThreadId = core.newThreadId;
+    if (!newThreadId) throw new Error("Expected an initial new thread");
+
+    setStartThreadRuntime(core, (id) =>
+      id === core.getItemById(newThreadId)?.id
+        ? newThreadRuntime.promise
+        : Promise.resolve({}),
+    );
+
+    const deleteA = core.delete("thread-a");
+    const switchToB = core.switchToThread("thread-b");
+    const switchToBResult = expect(switchToB).rejects.toThrow("fetch failed");
+
+    newThreadRuntime.resolve({});
+    fetchB.reject(new Error("fetch failed"));
+
+    await switchToBResult;
+    await deleteA;
+
+    expect(core.mainThreadId).not.toBe(threadAId);
+    expect(core.mainThreadId).toBe(core.getItemById(core.newThreadId!)?.id);
+  });
+
+  it("lets a newer successful switch move the mutation target away", async () => {
+    const fetchB = deferred<RemoteThreadMetadata>();
+    const newThreadRuntime = deferred<unknown>();
+    const adapter = makeAdapter({
+      fetch: vi.fn(() => fetchB.promise),
+      list: vi.fn(async () => ({ threads: [thread("thread-a")] })),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    const newThreadId = core.newThreadId;
+    if (!newThreadId) throw new Error("Expected an initial new thread");
+
+    setStartThreadRuntime(core, (id) =>
+      id === core.getItemById(newThreadId)?.id
+        ? newThreadRuntime.promise
+        : Promise.resolve({}),
+    );
+
+    const deleteA = core.delete("thread-a");
+    const switchToB = core.switchToThread("thread-b");
+
+    newThreadRuntime.resolve({});
+    fetchB.resolve(thread("thread-b"));
+
+    await switchToB;
+    await deleteA;
+
+    expect(core.mainThreadId).toBe(core.getItemById("thread-b")?.id);
+  });
+
+  it("does not let a mutation cancel an existing pending switch", async () => {
+    const fetchB = deferred<RemoteThreadMetadata>();
+    const adapter = makeAdapter({
+      fetch: vi.fn(() => fetchB.promise),
+      list: vi.fn(async () => ({ threads: [thread("thread-a")] })),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    const switchToB = core.switchToThread("thread-b");
+    const deleteA = core.delete("thread-a");
+
+    fetchB.resolve(thread("thread-b"));
+
+    await switchToB;
+    await deleteA;
+
+    expect(core.mainThreadId).toBe(core.getItemById("thread-b")?.id);
+  });
+});

package/src/tests/base-composer-runtime-core-addAttachment.test.ts

@@ -128,6 +128,50 @@ describe("BaseComposerRuntimeCore.addAttachment error events", () => {
     expect(onError).not.toHaveBeenCalled();
   });
 
+  it("adds prepared attachments when File is unavailable", async () => {
+    const composer = makeComposer();
+    const fileConstructor = globalThis.File;
+    vi.stubGlobal("File", undefined);
+
+    try {
+      await composer.addAttachment({
+        name: "notes.txt",
+        contentType: "text/plain",
+        content: [{ type: "text", text: "hello" }],
+      });
+    } finally {
+      vi.stubGlobal("File", fileConstructor);
+    }
+
+    expect(composer.attachments[0]).toMatchObject({
+      type: "document",
+      name: "notes.txt",
+      contentType: "text/plain",
+      content: [{ type: "text", text: "hello" }],
+      status: { type: "complete" },
+    });
+  });
+
+  it("uses the adapter for foreign files that expose content", async () => {
+    const add = vi.fn(makeAdapter().add);
+    const composer = makeComposer(makeAdapter({ add }));
+    const foreignFile = {
+      name: "photo.png",
+      type: "image/png",
+      lastModified: 0,
+      content: [{ type: "text", text: "implementation detail" }],
+    } as File;
+
+    await composer.addAttachment(foreignFile);
+
+    expect(add).toHaveBeenCalledWith({ file: foreignFile });
+    expect(composer.attachments[0]).toMatchObject({
+      type: "image",
+      name: "photo.png",
+      contentType: "image/png",
+    });
+  });
+
   it("accepts JSON files with the application/json media type", async () => {
     const composer = makeComposer(new SimpleTextAttachmentAdapter());